1//! Generated by `cargo xtask codegen grammar`, do not edit by hand.23#![allow(non_snake_case)]4use crate::{5    SyntaxKind::{self, *},6    SyntaxNode, SyntaxToken, T,7    ast::{self, AstChildren, AstNode, support},8};9use std::{fmt, hash};10pub struct Abi {11    pub(crate) syntax: SyntaxNode,12}13impl Abi {14    #[inline]15    pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }16    #[inline]17    pub fn string_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![string]) }18}19pub struct ArgList {20    pub(crate) syntax: SyntaxNode,21}22impl ArgList {23    #[inline]24    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }25    #[inline]26    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }27}28pub struct ArrayExpr {29    pub(crate) syntax: SyntaxNode,30}31impl ast::HasAttrs for ArrayExpr {}32impl ArrayExpr {33    #[inline]34    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }35    #[inline]36    pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }37    #[inline]38    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }39    #[inline]40    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }41    #[inline]42    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }43}44pub struct ArrayType {45    pub(crate) syntax: SyntaxNode,46}47impl ArrayType {48    #[inline]49    pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }50    #[inline]51    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }52    #[inline]53    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }54    #[inline]55    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }56    #[inline]57    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }58}59pub struct AsmClobberAbi {60    pub(crate) syntax: SyntaxNode,61}62impl ast::HasAttrs for AsmClobberAbi {}63impl AsmClobberAbi {64    #[inline]65    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }66    #[inline]67    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }68    #[inline]69    pub fn clobber_abi_token(&self) -> Option<SyntaxToken> {70        support::token(&self.syntax, T![clobber_abi])71    }72    #[inline]73    pub fn string_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![string]) }74}75pub struct AsmConst {76    pub(crate) syntax: SyntaxNode,77}78impl AsmConst {79    #[inline]80    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }81    #[inline]82    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }83}84pub struct AsmDirSpec {85    pub(crate) syntax: SyntaxNode,86}87impl AsmDirSpec {88    #[inline]89    pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }90    #[inline]91    pub fn inlateout_token(&self) -> Option<SyntaxToken> {92        support::token(&self.syntax, T![inlateout])93    }94    #[inline]95    pub fn inout_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![inout]) }96    #[inline]97    pub fn lateout_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![lateout]) }98    #[inline]99    pub fn out_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![out]) }100}101pub struct AsmExpr {102    pub(crate) syntax: SyntaxNode,103}104impl ast::HasAttrs for AsmExpr {}105impl AsmExpr {106    #[inline]107    pub fn asm_pieces(&self) -> AstChildren<AsmPiece> { support::children(&self.syntax) }108    #[inline]109    pub fn template(&self) -> AstChildren<Expr> { support::children(&self.syntax) }110    #[inline]111    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }112    #[inline]113    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }114    #[inline]115    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }116    #[inline]117    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }118    #[inline]119    pub fn asm_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![asm]) }120    #[inline]121    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }122    #[inline]123    pub fn global_asm_token(&self) -> Option<SyntaxToken> {124        support::token(&self.syntax, T![global_asm])125    }126    #[inline]127    pub fn naked_asm_token(&self) -> Option<SyntaxToken> {128        support::token(&self.syntax, T![naked_asm])129    }130}131pub struct AsmLabel {132    pub(crate) syntax: SyntaxNode,133}134impl AsmLabel {135    #[inline]136    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }137    #[inline]138    pub fn label_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![label]) }139}140pub struct AsmOperandExpr {141    pub(crate) syntax: SyntaxNode,142}143impl AsmOperandExpr {144    #[inline]145    pub fn in_expr(&self) -> Option<Expr> { support::child(&self.syntax) }146    #[inline]147    pub fn out_expr(&self) -> Option<Expr> { support::child(&self.syntax) }148    #[inline]149    pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }150}151pub struct AsmOperandNamed {152    pub(crate) syntax: SyntaxNode,153}154impl ast::HasAttrs for AsmOperandNamed {}155impl ast::HasName for AsmOperandNamed {}156impl AsmOperandNamed {157    #[inline]158    pub fn asm_operand(&self) -> Option<AsmOperand> { support::child(&self.syntax) }159    #[inline]160    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }161}162pub struct AsmOption {163    pub(crate) syntax: SyntaxNode,164}165impl AsmOption {166    #[inline]167    pub fn att_syntax_token(&self) -> Option<SyntaxToken> {168        support::token(&self.syntax, T![att_syntax])169    }170    #[inline]171    pub fn may_unwind_token(&self) -> Option<SyntaxToken> {172        support::token(&self.syntax, T![may_unwind])173    }174    #[inline]175    pub fn nomem_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![nomem]) }176    #[inline]177    pub fn noreturn_token(&self) -> Option<SyntaxToken> {178        support::token(&self.syntax, T![noreturn])179    }180    #[inline]181    pub fn nostack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![nostack]) }182    #[inline]183    pub fn preserves_flags_token(&self) -> Option<SyntaxToken> {184        support::token(&self.syntax, T![preserves_flags])185    }186    #[inline]187    pub fn pure_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pure]) }188    #[inline]189    pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) }190    #[inline]191    pub fn readonly_token(&self) -> Option<SyntaxToken> {192        support::token(&self.syntax, T![readonly])193    }194}195pub struct AsmOptions {196    pub(crate) syntax: SyntaxNode,197}198impl ast::HasAttrs for AsmOptions {}199impl AsmOptions {200    #[inline]201    pub fn asm_options(&self) -> AstChildren<AsmOption> { support::children(&self.syntax) }202    #[inline]203    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }204    #[inline]205    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }206    #[inline]207    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }208    #[inline]209    pub fn options_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![options]) }210}211pub struct AsmRegOperand {212    pub(crate) syntax: SyntaxNode,213}214impl AsmRegOperand {215    #[inline]216    pub fn asm_dir_spec(&self) -> Option<AsmDirSpec> { support::child(&self.syntax) }217    #[inline]218    pub fn asm_operand_expr(&self) -> Option<AsmOperandExpr> { support::child(&self.syntax) }219    #[inline]220    pub fn asm_reg_spec(&self) -> Option<AsmRegSpec> { support::child(&self.syntax) }221    #[inline]222    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }223    #[inline]224    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }225}226pub struct AsmRegSpec {227    pub(crate) syntax: SyntaxNode,228}229impl AsmRegSpec {230    #[inline]231    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }232    #[inline]233    pub fn string_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![string]) }234}235pub struct AsmSym {236    pub(crate) syntax: SyntaxNode,237}238impl AsmSym {239    #[inline]240    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }241    #[inline]242    pub fn sym_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![sym]) }243}244pub struct AssocItemList {245    pub(crate) syntax: SyntaxNode,246}247impl ast::HasAttrs for AssocItemList {}248impl AssocItemList {249    #[inline]250    pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) }251    #[inline]252    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }253    #[inline]254    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }255}256pub struct AssocTypeArg {257    pub(crate) syntax: SyntaxNode,258}259impl ast::HasGenericArgs for AssocTypeArg {}260impl ast::HasTypeBounds for AssocTypeArg {}261impl AssocTypeArg {262    #[inline]263    pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }264    #[inline]265    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }266    #[inline]267    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }268    #[inline]269    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }270    #[inline]271    pub fn return_type_syntax(&self) -> Option<ReturnTypeSyntax> { support::child(&self.syntax) }272    #[inline]273    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }274    #[inline]275    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }276}277pub struct Attr {278    pub(crate) syntax: SyntaxNode,279}280impl Attr {281    #[inline]282    pub fn meta(&self) -> Option<Meta> { support::child(&self.syntax) }283    #[inline]284    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }285    #[inline]286    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }287    #[inline]288    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }289    #[inline]290    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }291}292pub struct AwaitExpr {293    pub(crate) syntax: SyntaxNode,294}295impl ast::HasAttrs for AwaitExpr {}296impl AwaitExpr {297    #[inline]298    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }299    #[inline]300    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }301    #[inline]302    pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) }303}304pub struct BecomeExpr {305    pub(crate) syntax: SyntaxNode,306}307impl ast::HasAttrs for BecomeExpr {}308impl BecomeExpr {309    #[inline]310    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }311    #[inline]312    pub fn become_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![become]) }313}314pub struct BinExpr {315    pub(crate) syntax: SyntaxNode,316}317impl ast::HasAttrs for BinExpr {}318impl BinExpr {}319pub struct BlockExpr {320    pub(crate) syntax: SyntaxNode,321}322impl ast::HasAttrs for BlockExpr {}323impl BlockExpr {324    #[inline]325    pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }326    #[inline]327    pub fn stmt_list(&self) -> Option<StmtList> { support::child(&self.syntax) }328    #[inline]329    pub fn try_block_modifier(&self) -> Option<TryBlockModifier> { support::child(&self.syntax) }330    #[inline]331    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }332    #[inline]333    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }334    #[inline]335    pub fn gen_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![gen]) }336    #[inline]337    pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) }338    #[inline]339    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }340}341pub struct BoxPat {342    pub(crate) syntax: SyntaxNode,343}344impl BoxPat {345    #[inline]346    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }347    #[inline]348    pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }349}350pub struct BreakExpr {351    pub(crate) syntax: SyntaxNode,352}353impl ast::HasAttrs for BreakExpr {}354impl BreakExpr {355    #[inline]356    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }357    #[inline]358    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }359    #[inline]360    pub fn break_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![break]) }361}362pub struct CallExpr {363    pub(crate) syntax: SyntaxNode,364}365impl ast::HasArgList for CallExpr {}366impl ast::HasAttrs for CallExpr {}367impl CallExpr {368    #[inline]369    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }370}371pub struct CastExpr {372    pub(crate) syntax: SyntaxNode,373}374impl ast::HasAttrs for CastExpr {}375impl CastExpr {376    #[inline]377    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }378    #[inline]379    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }380    #[inline]381    pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }382}383pub struct CfgAtom {384    pub(crate) syntax: SyntaxNode,385}386impl CfgAtom {387    #[inline]388    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }389    #[inline]390    pub fn false_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![false]) }391    #[inline]392    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }393    #[inline]394    pub fn string_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![string]) }395    #[inline]396    pub fn true_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![true]) }397}398pub struct CfgAttrMeta {399    pub(crate) syntax: SyntaxNode,400}401impl CfgAttrMeta {402    #[inline]403    pub fn cfg_predicate(&self) -> Option<CfgPredicate> { support::child(&self.syntax) }404    #[inline]405    pub fn metas(&self) -> AstChildren<Meta> { support::children(&self.syntax) }406    #[inline]407    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }408    #[inline]409    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }410    #[inline]411    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }412    #[inline]413    pub fn cfg_attr_token(&self) -> Option<SyntaxToken> {414        support::token(&self.syntax, T![cfg_attr])415    }416}417pub struct CfgComposite {418    pub(crate) syntax: SyntaxNode,419}420impl CfgComposite {421    #[inline]422    pub fn cfg_predicates(&self) -> AstChildren<CfgPredicate> { support::children(&self.syntax) }423    #[inline]424    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }425    #[inline]426    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }427    #[inline]428    pub fn keyword(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }429}430pub struct CfgMeta {431    pub(crate) syntax: SyntaxNode,432}433impl CfgMeta {434    #[inline]435    pub fn cfg_predicate(&self) -> Option<CfgPredicate> { support::child(&self.syntax) }436    #[inline]437    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }438    #[inline]439    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }440    #[inline]441    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }442    #[inline]443    pub fn cfg_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![cfg]) }444}445pub struct CfgPredExpr {446    pub(crate) syntax: SyntaxNode,447}448impl CfgPredExpr {449    #[inline]450    pub fn cfg_predicate(&self) -> Option<CfgPredicate> { support::child(&self.syntax) }451    #[inline]452    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }453    #[inline]454    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }455    #[inline]456    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }457    #[inline]458    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }459    #[inline]460    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }461    #[inline]462    pub fn cfg_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![cfg]) }463}464pub struct CfgPredPat {465    pub(crate) syntax: SyntaxNode,466}467impl CfgPredPat {468    #[inline]469    pub fn cfg_predicate(&self) -> Option<CfgPredicate> { support::child(&self.syntax) }470    #[inline]471    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }472    #[inline]473    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }474    #[inline]475    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }476    #[inline]477    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }478    #[inline]479    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }480    #[inline]481    pub fn cfg_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![cfg]) }482}483pub struct ClosureExpr {484    pub(crate) syntax: SyntaxNode,485}486impl ast::HasAttrs for ClosureExpr {}487impl ClosureExpr {488    #[inline]489    pub fn for_binder(&self) -> Option<ForBinder> { support::child(&self.syntax) }490    #[inline]491    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }492    #[inline]493    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }494    #[inline]495    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }496    #[inline]497    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }498    #[inline]499    pub fn gen_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![gen]) }500    #[inline]501    pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) }502    #[inline]503    pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }504}505pub struct Const {506    pub(crate) syntax: SyntaxNode,507}508impl ast::HasAttrs for Const {}509impl ast::HasGenericParams for Const {}510impl ast::HasName for Const {}511impl ast::HasVisibility for Const {}512impl Const {513    #[inline]514    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }515    #[inline]516    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }517    #[inline]518    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }519    #[inline]520    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }521    #[inline]522    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }523    #[inline]524    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }525    #[inline]526    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }527    #[inline]528    pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }529}530pub struct ConstArg {531    pub(crate) syntax: SyntaxNode,532}533impl ConstArg {534    #[inline]535    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }536}537pub struct ConstBlockPat {538    pub(crate) syntax: SyntaxNode,539}540impl ConstBlockPat {541    #[inline]542    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }543    #[inline]544    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }545}546pub struct ConstParam {547    pub(crate) syntax: SyntaxNode,548}549impl ast::HasAttrs for ConstParam {}550impl ast::HasName for ConstParam {}551impl ConstParam {552    #[inline]553    pub fn default_val(&self) -> Option<ConstArg> { support::child(&self.syntax) }554    #[inline]555    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }556    #[inline]557    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }558    #[inline]559    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }560    #[inline]561    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }562}563pub struct ContinueExpr {564    pub(crate) syntax: SyntaxNode,565}566impl ast::HasAttrs for ContinueExpr {}567impl ContinueExpr {568    #[inline]569    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }570    #[inline]571    pub fn continue_token(&self) -> Option<SyntaxToken> {572        support::token(&self.syntax, T![continue])573    }574}575pub struct DerefPat {576    pub(crate) syntax: SyntaxNode,577}578impl DerefPat {579    #[inline]580    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }581    #[inline]582    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }583    #[inline]584    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }585    #[inline]586    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }587    #[inline]588    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }589    #[inline]590    pub fn deref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![deref]) }591}592pub struct DocComment {593    pub(crate) syntax: SyntaxNode,594}595impl DocComment {596    #[inline]597    pub fn inner_doc_comment_token(&self) -> Option<SyntaxToken> {598        support::token(&self.syntax, T![inner_doc_comment])599    }600    #[inline]601    pub fn outer_doc_comment_token(&self) -> Option<SyntaxToken> {602        support::token(&self.syntax, T![outer_doc_comment])603    }604}605pub struct DynTraitType {606    pub(crate) syntax: SyntaxNode,607}608impl DynTraitType {609    #[inline]610    pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }611    #[inline]612    pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) }613}614pub struct Enum {615    pub(crate) syntax: SyntaxNode,616}617impl ast::HasAttrs for Enum {}618impl ast::HasGenericParams for Enum {}619impl ast::HasName for Enum {}620impl ast::HasVisibility for Enum {}621impl Enum {622    #[inline]623    pub fn variant_list(&self) -> Option<VariantList> { support::child(&self.syntax) }624    #[inline]625    pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) }626}627pub struct ExprStmt {628    pub(crate) syntax: SyntaxNode,629}630impl ExprStmt {631    #[inline]632    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }633    #[inline]634    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }635}636pub struct ExternBlock {637    pub(crate) syntax: SyntaxNode,638}639impl ast::HasAttrs for ExternBlock {}640impl ExternBlock {641    #[inline]642    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }643    #[inline]644    pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) }645    #[inline]646    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }647}648pub struct ExternCrate {649    pub(crate) syntax: SyntaxNode,650}651impl ast::HasAttrs for ExternCrate {}652impl ast::HasVisibility for ExternCrate {}653impl ExternCrate {654    #[inline]655    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }656    #[inline]657    pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }658    #[inline]659    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }660    #[inline]661    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }662    #[inline]663    pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }664}665pub struct ExternItemList {666    pub(crate) syntax: SyntaxNode,667}668impl ast::HasAttrs for ExternItemList {}669impl ExternItemList {670    #[inline]671    pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }672    #[inline]673    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }674    #[inline]675    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }676}677pub struct FieldExpr {678    pub(crate) syntax: SyntaxNode,679}680impl ast::HasAttrs for FieldExpr {}681impl FieldExpr {682    #[inline]683    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }684    #[inline]685    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }686    #[inline]687    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }688}689pub struct Fn {690    pub(crate) syntax: SyntaxNode,691}692impl ast::HasAttrs for Fn {}693impl ast::HasGenericParams for Fn {}694impl ast::HasName for Fn {}695impl ast::HasVisibility for Fn {}696impl Fn {697    #[inline]698    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }699    #[inline]700    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }701    #[inline]702    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }703    #[inline]704    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }705    #[inline]706    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }707    #[inline]708    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }709    #[inline]710    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }711    #[inline]712    pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }713    #[inline]714    pub fn gen_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![gen]) }715    #[inline]716    pub fn safe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![safe]) }717    #[inline]718    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }719}720pub struct FnPtrType {721    pub(crate) syntax: SyntaxNode,722}723impl FnPtrType {724    #[inline]725    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }726    #[inline]727    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }728    #[inline]729    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }730    #[inline]731    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }732    #[inline]733    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }734    #[inline]735    pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }736    #[inline]737    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }738}739pub struct ForBinder {740    pub(crate) syntax: SyntaxNode,741}742impl ForBinder {743    #[inline]744    pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }745    #[inline]746    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }747}748pub struct ForExpr {749    pub(crate) syntax: SyntaxNode,750}751impl ast::HasAttrs for ForExpr {}752impl ForExpr {753    #[inline]754    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }755    #[inline]756    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }757    #[inline]758    pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }759}760pub struct ForType {761    pub(crate) syntax: SyntaxNode,762}763impl ForType {764    #[inline]765    pub fn for_binder(&self) -> Option<ForBinder> { support::child(&self.syntax) }766    #[inline]767    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }768}769pub struct FormatArgsArg {770    pub(crate) syntax: SyntaxNode,771}772impl ast::HasName for FormatArgsArg {}773impl FormatArgsArg {774    #[inline]775    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }776    #[inline]777    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }778}779pub struct FormatArgsExpr {780    pub(crate) syntax: SyntaxNode,781}782impl ast::HasAttrs for FormatArgsExpr {}783impl FormatArgsExpr {784    #[inline]785    pub fn template(&self) -> Option<Expr> { support::child(&self.syntax) }786    #[inline]787    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }788    #[inline]789    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }790    #[inline]791    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }792    #[inline]793    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }794    #[inline]795    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }796    #[inline]797    pub fn format_args_token(&self) -> Option<SyntaxToken> {798        support::token(&self.syntax, T![format_args])799    }800}801pub struct GenericArgList {802    pub(crate) syntax: SyntaxNode,803}804impl GenericArgList {805    #[inline]806    pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) }807    #[inline]808    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }809    #[inline]810    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }811    #[inline]812    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }813}814pub struct GenericParamList {815    pub(crate) syntax: SyntaxNode,816}817impl GenericParamList {818    #[inline]819    pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }820    #[inline]821    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }822    #[inline]823    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }824}825pub struct IdentPat {826    pub(crate) syntax: SyntaxNode,827}828impl ast::HasAttrs for IdentPat {}829impl ast::HasName for IdentPat {}830impl IdentPat {831    #[inline]832    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }833    #[inline]834    pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) }835    #[inline]836    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }837    #[inline]838    pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) }839}840pub struct IfExpr {841    pub(crate) syntax: SyntaxNode,842}843impl ast::HasAttrs for IfExpr {}844impl IfExpr {845    #[inline]846    pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }847    #[inline]848    pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }849}850pub struct Impl {851    pub(crate) syntax: SyntaxNode,852}853impl ast::HasAttrs for Impl {}854impl ast::HasGenericParams for Impl {}855impl ast::HasVisibility for Impl {}856impl Impl {857    #[inline]858    pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }859    #[inline]860    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }861    #[inline]862    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }863    #[inline]864    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }865    #[inline]866    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }867    #[inline]868    pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }869    #[inline]870    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }871}872pub struct ImplRestriction {873    pub(crate) syntax: SyntaxNode,874}875impl ImplRestriction {876    #[inline]877    pub fn visibility_inner(&self) -> Option<VisibilityInner> { support::child(&self.syntax) }878    #[inline]879    pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }880}881pub struct ImplTraitType {882    pub(crate) syntax: SyntaxNode,883}884impl ImplTraitType {885    #[inline]886    pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }887    #[inline]888    pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }889}890pub struct IncludeBytesExpr {891    pub(crate) syntax: SyntaxNode,892}893impl IncludeBytesExpr {894    #[inline]895    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }896    #[inline]897    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }898    #[inline]899    pub fn include_bytes_token(&self) -> Option<SyntaxToken> {900        support::token(&self.syntax, T![include_bytes])901    }902}903pub struct IndexExpr {904    pub(crate) syntax: SyntaxNode,905}906impl ast::HasAttrs for IndexExpr {}907impl IndexExpr {908    #[inline]909    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }910    #[inline]911    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }912}913pub struct InferType {914    pub(crate) syntax: SyntaxNode,915}916impl InferType {917    #[inline]918    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }919}920pub struct ItemList {921    pub(crate) syntax: SyntaxNode,922}923impl ast::HasAttrs for ItemList {}924impl ast::HasModuleItem for ItemList {}925impl ItemList {926    #[inline]927    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }928    #[inline]929    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }930}931pub struct KeyValueMeta {932    pub(crate) syntax: SyntaxNode,933}934impl KeyValueMeta {935    #[inline]936    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }937    #[inline]938    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }939    #[inline]940    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }941}942pub struct Label {943    pub(crate) syntax: SyntaxNode,944}945impl Label {946    #[inline]947    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }948    #[inline]949    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }950}951pub struct LetElse {952    pub(crate) syntax: SyntaxNode,953}954impl LetElse {955    #[inline]956    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }957    #[inline]958    pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) }959}960pub struct LetExpr {961    pub(crate) syntax: SyntaxNode,962}963impl ast::HasAttrs for LetExpr {}964impl LetExpr {965    #[inline]966    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }967    #[inline]968    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }969    #[inline]970    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }971    #[inline]972    pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }973}974pub struct LetStmt {975    pub(crate) syntax: SyntaxNode,976}977impl ast::HasAttrs for LetStmt {}978impl LetStmt {979    #[inline]980    pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }981    #[inline]982    pub fn let_else(&self) -> Option<LetElse> { support::child(&self.syntax) }983    #[inline]984    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }985    #[inline]986    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }987    #[inline]988    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }989    #[inline]990    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }991    #[inline]992    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }993    #[inline]994    pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }995    #[inline]996    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }997}998pub struct Lifetime {999    pub(crate) syntax: SyntaxNode,1000}1001impl Lifetime {1002    #[inline]1003    pub fn lifetime_ident_token(&self) -> Option<SyntaxToken> {1004        support::token(&self.syntax, T![lifetime_ident])1005    }1006}1007pub struct LifetimeArg {1008    pub(crate) syntax: SyntaxNode,1009}1010impl LifetimeArg {1011    #[inline]1012    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }1013}1014pub struct LifetimeParam {1015    pub(crate) syntax: SyntaxNode,1016}1017impl ast::HasAttrs for LifetimeParam {}1018impl ast::HasTypeBounds for LifetimeParam {}1019impl LifetimeParam {1020    #[inline]1021    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }1022}1023pub struct Literal {1024    pub(crate) syntax: SyntaxNode,1025}1026impl ast::HasAttrs for Literal {}1027impl Literal {}1028pub struct LiteralPat {1029    pub(crate) syntax: SyntaxNode,1030}1031impl LiteralPat {1032    #[inline]1033    pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }1034    #[inline]1035    pub fn minus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![-]) }1036}1037pub struct LoopExpr {1038    pub(crate) syntax: SyntaxNode,1039}1040impl ast::HasAttrs for LoopExpr {}1041impl ast::HasLoopBody for LoopExpr {}1042impl LoopExpr {1043    #[inline]1044    pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) }1045}1046pub struct MacroCall {1047    pub(crate) syntax: SyntaxNode,1048}1049impl ast::HasAttrs for MacroCall {}1050impl MacroCall {1051    #[inline]1052    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }1053    #[inline]1054    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }1055    #[inline]1056    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }1057    #[inline]1058    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }1059}1060pub struct MacroDef {1061    pub(crate) syntax: SyntaxNode,1062}1063impl ast::HasAttrs for MacroDef {}1064impl ast::HasName for MacroDef {}1065impl ast::HasVisibility for MacroDef {}1066impl MacroDef {1067    #[inline]1068    pub fn macro_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![macro]) }1069}1070pub struct MacroExpr {1071    pub(crate) syntax: SyntaxNode,1072}1073impl MacroExpr {1074    #[inline]1075    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }1076}1077pub struct MacroItems {1078    pub(crate) syntax: SyntaxNode,1079}1080impl ast::HasModuleItem for MacroItems {}1081impl MacroItems {}1082pub struct MacroPat {1083    pub(crate) syntax: SyntaxNode,1084}1085impl MacroPat {1086    #[inline]1087    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }1088}1089pub struct MacroRules {1090    pub(crate) syntax: SyntaxNode,1091}1092impl ast::HasAttrs for MacroRules {}1093impl ast::HasName for MacroRules {}1094impl ast::HasVisibility for MacroRules {}1095impl MacroRules {1096    #[inline]1097    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }1098    #[inline]1099    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }1100    #[inline]1101    pub fn macro_rules_token(&self) -> Option<SyntaxToken> {1102        support::token(&self.syntax, T![macro_rules])1103    }1104}1105pub struct MacroStmts {1106    pub(crate) syntax: SyntaxNode,1107}1108impl MacroStmts {1109    #[inline]1110    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }1111    #[inline]1112    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }1113}1114pub struct MacroType {1115    pub(crate) syntax: SyntaxNode,1116}1117impl MacroType {1118    #[inline]1119    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }1120}1121pub struct MatchArm {1122    pub(crate) syntax: SyntaxNode,1123}1124impl ast::HasAttrs for MatchArm {}1125impl MatchArm {1126    #[inline]1127    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }1128    #[inline]1129    pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) }1130    #[inline]1131    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }1132    #[inline]1133    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }1134    #[inline]1135    pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }1136}1137pub struct MatchArmList {1138    pub(crate) syntax: SyntaxNode,1139}1140impl ast::HasAttrs for MatchArmList {}1141impl MatchArmList {1142    #[inline]1143    pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }1144    #[inline]1145    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }1146    #[inline]1147    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }1148}1149pub struct MatchExpr {1150    pub(crate) syntax: SyntaxNode,1151}1152impl ast::HasAttrs for MatchExpr {}1153impl MatchExpr {1154    #[inline]1155    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }1156    #[inline]1157    pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }1158    #[inline]1159    pub fn match_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![match]) }1160}1161pub struct MatchGuard {1162    pub(crate) syntax: SyntaxNode,1163}1164impl MatchGuard {1165    #[inline]1166    pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }1167}1168pub struct MethodCallExpr {1169    pub(crate) syntax: SyntaxNode,1170}1171impl ast::HasArgList for MethodCallExpr {}1172impl ast::HasAttrs for MethodCallExpr {}1173impl ast::HasGenericArgs for MethodCallExpr {}1174impl MethodCallExpr {1175    #[inline]1176    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }1177    #[inline]1178    pub fn receiver(&self) -> Option<Expr> { support::child(&self.syntax) }1179    #[inline]1180    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }1181}1182pub struct Module {1183    pub(crate) syntax: SyntaxNode,1184}1185impl ast::HasAttrs for Module {}1186impl ast::HasName for Module {}1187impl ast::HasVisibility for Module {}1188impl Module {1189    #[inline]1190    pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }1191    #[inline]1192    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }1193    #[inline]1194    pub fn mod_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mod]) }1195}1196pub struct MutRestriction {1197    pub(crate) syntax: SyntaxNode,1198}1199impl MutRestriction {1200    #[inline]1201    pub fn visibility_inner(&self) -> Option<VisibilityInner> { support::child(&self.syntax) }1202    #[inline]1203    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }1204}1205pub struct Name {1206    pub(crate) syntax: SyntaxNode,1207}1208impl Name {1209    #[inline]1210    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }1211    #[inline]1212    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }1213}1214pub struct NameRef {1215    pub(crate) syntax: SyntaxNode,1216}1217impl NameRef {1218    #[inline]1219    pub fn Self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![Self]) }1220    #[inline]1221    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }1222    #[inline]1223    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }1224    #[inline]1225    pub fn int_number_token(&self) -> Option<SyntaxToken> {1226        support::token(&self.syntax, T![int_number])1227    }1228    #[inline]1229    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }1230    #[inline]1231    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }1232}1233pub struct NeverType {1234    pub(crate) syntax: SyntaxNode,1235}1236impl NeverType {1237    #[inline]1238    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }1239}1240pub struct NotNull {1241    pub(crate) syntax: SyntaxNode,1242}1243impl NotNull {1244    #[inline]1245    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }1246    #[inline]1247    pub fn null_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![null]) }1248}1249pub struct OffsetOfExpr {1250    pub(crate) syntax: SyntaxNode,1251}1252impl ast::HasAttrs for OffsetOfExpr {}1253impl OffsetOfExpr {1254    #[inline]1255    pub fn fields(&self) -> AstChildren<NameRef> { support::children(&self.syntax) }1256    #[inline]1257    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1258    #[inline]1259    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }1260    #[inline]1261    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1262    #[inline]1263    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1264    #[inline]1265    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }1266    #[inline]1267    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }1268    #[inline]1269    pub fn offset_of_token(&self) -> Option<SyntaxToken> {1270        support::token(&self.syntax, T![offset_of])1271    }1272}1273pub struct OrPat {1274    pub(crate) syntax: SyntaxNode,1275}1276impl OrPat {1277    #[inline]1278    pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }1279    #[inline]1280    pub fn pipe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) }1281}1282pub struct Param {1283    pub(crate) syntax: SyntaxNode,1284}1285impl ast::HasAttrs for Param {}1286impl Param {1287    #[inline]1288    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }1289    #[inline]1290    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1291    #[inline]1292    pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }1293    #[inline]1294    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }1295}1296pub struct ParamList {1297    pub(crate) syntax: SyntaxNode,1298}1299impl ParamList {1300    #[inline]1301    pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }1302    #[inline]1303    pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) }1304    #[inline]1305    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1306    #[inline]1307    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1308    #[inline]1309    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }1310    #[inline]1311    pub fn pipe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) }1312}1313pub struct ParenExpr {1314    pub(crate) syntax: SyntaxNode,1315}1316impl ast::HasAttrs for ParenExpr {}1317impl ParenExpr {1318    #[inline]1319    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }1320    #[inline]1321    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1322    #[inline]1323    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1324}1325pub struct ParenPat {1326    pub(crate) syntax: SyntaxNode,1327}1328impl ParenPat {1329    #[inline]1330    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }1331    #[inline]1332    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1333    #[inline]1334    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1335}1336pub struct ParenType {1337    pub(crate) syntax: SyntaxNode,1338}1339impl ParenType {1340    #[inline]1341    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1342    #[inline]1343    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1344    #[inline]1345    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1346}1347pub struct ParenthesizedArgList {1348    pub(crate) syntax: SyntaxNode,1349}1350impl ParenthesizedArgList {1351    #[inline]1352    pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) }1353    #[inline]1354    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1355    #[inline]1356    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1357    #[inline]1358    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }1359}1360pub struct Path {1361    pub(crate) syntax: SyntaxNode,1362}1363impl Path {1364    #[inline]1365    pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) }1366    #[inline]1367    pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) }1368    #[inline]1369    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }1370}1371pub struct PathExpr {1372    pub(crate) syntax: SyntaxNode,1373}1374impl ast::HasAttrs for PathExpr {}1375impl PathExpr {1376    #[inline]1377    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }1378}1379pub struct PathMeta {1380    pub(crate) syntax: SyntaxNode,1381}1382impl PathMeta {1383    #[inline]1384    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }1385}1386pub struct PathPat {1387    pub(crate) syntax: SyntaxNode,1388}1389impl PathPat {1390    #[inline]1391    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }1392}1393pub struct PathSegment {1394    pub(crate) syntax: SyntaxNode,1395}1396impl ast::HasGenericArgs for PathSegment {}1397impl PathSegment {1398    #[inline]1399    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }1400    #[inline]1401    pub fn parenthesized_arg_list(&self) -> Option<ParenthesizedArgList> {1402        support::child(&self.syntax)1403    }1404    #[inline]1405    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }1406    #[inline]1407    pub fn return_type_syntax(&self) -> Option<ReturnTypeSyntax> { support::child(&self.syntax) }1408    #[inline]1409    pub fn type_anchor(&self) -> Option<TypeAnchor> { support::child(&self.syntax) }1410    #[inline]1411    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }1412}1413pub struct PathType {1414    pub(crate) syntax: SyntaxNode,1415}1416impl PathType {1417    #[inline]1418    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }1419}1420pub struct PatternType {1421    pub(crate) syntax: SyntaxNode,1422}1423impl PatternType {1424    #[inline]1425    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }1426    #[inline]1427    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1428    #[inline]1429    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }1430    #[inline]1431    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1432    #[inline]1433    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1434    #[inline]1435    pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) }1436    #[inline]1437    pub fn is_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![is]) }1438    #[inline]1439    pub fn pattern_type_token(&self) -> Option<SyntaxToken> {1440        support::token(&self.syntax, T![pattern_type])1441    }1442}1443pub struct PrefixExpr {1444    pub(crate) syntax: SyntaxNode,1445}1446impl ast::HasAttrs for PrefixExpr {}1447impl PrefixExpr {1448    #[inline]1449    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }1450}1451pub struct PtrType {1452    pub(crate) syntax: SyntaxNode,1453}1454impl PtrType {1455    #[inline]1456    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1457    #[inline]1458    pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }1459    #[inline]1460    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }1461    #[inline]1462    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }1463}1464pub struct RangeExpr {1465    pub(crate) syntax: SyntaxNode,1466}1467impl ast::HasAttrs for RangeExpr {}1468impl RangeExpr {}1469pub struct RangePat {1470    pub(crate) syntax: SyntaxNode,1471}1472impl RangePat {}1473pub struct RecordExpr {1474    pub(crate) syntax: SyntaxNode,1475}1476impl RecordExpr {1477    #[inline]1478    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }1479    #[inline]1480    pub fn record_expr_field_list(&self) -> Option<RecordExprFieldList> {1481        support::child(&self.syntax)1482    }1483}1484pub struct RecordExprField {1485    pub(crate) syntax: SyntaxNode,1486}1487impl ast::HasAttrs for RecordExprField {}1488impl RecordExprField {1489    #[inline]1490    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }1491    #[inline]1492    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }1493    #[inline]1494    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }1495}1496pub struct RecordExprFieldList {1497    pub(crate) syntax: SyntaxNode,1498}1499impl ast::HasAttrs for RecordExprFieldList {}1500impl RecordExprFieldList {1501    #[inline]1502    pub fn fields(&self) -> AstChildren<RecordExprField> { support::children(&self.syntax) }1503    #[inline]1504    pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }1505    #[inline]1506    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }1507    #[inline]1508    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }1509    #[inline]1510    pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }1511}1512pub struct RecordField {1513    pub(crate) syntax: SyntaxNode,1514}1515impl ast::HasAttrs for RecordField {}1516impl ast::HasName for RecordField {}1517impl ast::HasVisibility for RecordField {}1518impl RecordField {1519    #[inline]1520    pub fn default_val(&self) -> Option<ConstArg> { support::child(&self.syntax) }1521    #[inline]1522    pub fn mut_restriction(&self) -> Option<MutRestriction> { support::child(&self.syntax) }1523    #[inline]1524    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1525    #[inline]1526    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }1527    #[inline]1528    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }1529    #[inline]1530    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }1531}1532pub struct RecordFieldList {1533    pub(crate) syntax: SyntaxNode,1534}1535impl RecordFieldList {1536    #[inline]1537    pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }1538    #[inline]1539    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }1540    #[inline]1541    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }1542}1543pub struct RecordPat {1544    pub(crate) syntax: SyntaxNode,1545}1546impl RecordPat {1547    #[inline]1548    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }1549    #[inline]1550    pub fn record_pat_field_list(&self) -> Option<RecordPatFieldList> {1551        support::child(&self.syntax)1552    }1553}1554pub struct RecordPatField {1555    pub(crate) syntax: SyntaxNode,1556}1557impl ast::HasAttrs for RecordPatField {}1558impl RecordPatField {1559    #[inline]1560    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }1561    #[inline]1562    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }1563    #[inline]1564    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }1565}1566pub struct RecordPatFieldList {1567    pub(crate) syntax: SyntaxNode,1568}1569impl RecordPatFieldList {1570    #[inline]1571    pub fn fields(&self) -> AstChildren<RecordPatField> { support::children(&self.syntax) }1572    #[inline]1573    pub fn rest_pat(&self) -> Option<RestPat> { support::child(&self.syntax) }1574    #[inline]1575    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }1576    #[inline]1577    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }1578}1579pub struct RefExpr {1580    pub(crate) syntax: SyntaxNode,1581}1582impl ast::HasAttrs for RefExpr {}1583impl RefExpr {1584    #[inline]1585    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }1586    #[inline]1587    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }1588    #[inline]1589    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }1590    #[inline]1591    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }1592    #[inline]1593    pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) }1594}1595pub struct RefPat {1596    pub(crate) syntax: SyntaxNode,1597}1598impl RefPat {1599    #[inline]1600    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }1601    #[inline]1602    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }1603    #[inline]1604    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }1605}1606pub struct RefType {1607    pub(crate) syntax: SyntaxNode,1608}1609impl RefType {1610    #[inline]1611    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }1612    #[inline]1613    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1614    #[inline]1615    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }1616    #[inline]1617    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }1618}1619pub struct Rename {1620    pub(crate) syntax: SyntaxNode,1621}1622impl ast::HasName for Rename {}1623impl Rename {1624    #[inline]1625    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }1626    #[inline]1627    pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }1628}1629pub struct RestPat {1630    pub(crate) syntax: SyntaxNode,1631}1632impl ast::HasAttrs for RestPat {}1633impl RestPat {1634    #[inline]1635    pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }1636}1637pub struct RetType {1638    pub(crate) syntax: SyntaxNode,1639}1640impl RetType {1641    #[inline]1642    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1643    #[inline]1644    pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }1645}1646pub struct ReturnExpr {1647    pub(crate) syntax: SyntaxNode,1648}1649impl ast::HasAttrs for ReturnExpr {}1650impl ReturnExpr {1651    #[inline]1652    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }1653    #[inline]1654    pub fn return_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![return]) }1655}1656pub struct ReturnTypeSyntax {1657    pub(crate) syntax: SyntaxNode,1658}1659impl ReturnTypeSyntax {1660    #[inline]1661    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1662    #[inline]1663    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1664    #[inline]1665    pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }1666}1667pub struct SelfParam {1668    pub(crate) syntax: SyntaxNode,1669}1670impl ast::HasAttrs for SelfParam {}1671impl ast::HasName for SelfParam {}1672impl SelfParam {1673    #[inline]1674    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }1675    #[inline]1676    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1677    #[inline]1678    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }1679    #[inline]1680    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }1681    #[inline]1682    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }1683}1684pub struct SlicePat {1685    pub(crate) syntax: SyntaxNode,1686}1687impl SlicePat {1688    #[inline]1689    pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }1690    #[inline]1691    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }1692    #[inline]1693    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }1694}1695pub struct SliceType {1696    pub(crate) syntax: SyntaxNode,1697}1698impl SliceType {1699    #[inline]1700    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1701    #[inline]1702    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }1703    #[inline]1704    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }1705}1706pub struct SourceFile {1707    pub(crate) syntax: SyntaxNode,1708}1709impl ast::HasAttrs for SourceFile {}1710impl ast::HasModuleItem for SourceFile {}1711impl SourceFile {1712    #[inline]1713    pub fn frontmatter_token(&self) -> Option<SyntaxToken> {1714        support::token(&self.syntax, T![frontmatter])1715    }1716    #[inline]1717    pub fn shebang_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![shebang]) }1718}1719pub struct Static {1720    pub(crate) syntax: SyntaxNode,1721}1722impl ast::HasAttrs for Static {}1723impl ast::HasName for Static {}1724impl ast::HasVisibility for Static {}1725impl Static {1726    #[inline]1727    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1728    #[inline]1729    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }1730    #[inline]1731    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }1732    #[inline]1733    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }1734    #[inline]1735    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }1736    #[inline]1737    pub fn safe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![safe]) }1738    #[inline]1739    pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }1740    #[inline]1741    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }1742}1743pub struct StmtList {1744    pub(crate) syntax: SyntaxNode,1745}1746impl ast::HasAttrs for StmtList {}1747impl StmtList {1748    #[inline]1749    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }1750    #[inline]1751    pub fn tail_expr(&self) -> Option<Expr> { support::child(&self.syntax) }1752    #[inline]1753    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }1754    #[inline]1755    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }1756}1757pub struct Struct {1758    pub(crate) syntax: SyntaxNode,1759}1760impl ast::HasAttrs for Struct {}1761impl ast::HasGenericParams for Struct {}1762impl ast::HasName for Struct {}1763impl ast::HasVisibility for Struct {}1764impl Struct {1765    #[inline]1766    pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }1767    #[inline]1768    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }1769    #[inline]1770    pub fn struct_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![struct]) }1771}1772pub struct TokenTree {1773    pub(crate) syntax: SyntaxNode,1774}1775impl TokenTree {1776    #[inline]1777    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1778    #[inline]1779    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1780    #[inline]1781    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }1782    #[inline]1783    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }1784    #[inline]1785    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }1786    #[inline]1787    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }1788}1789pub struct TokenTreeMeta {1790    pub(crate) syntax: SyntaxNode,1791}1792impl TokenTreeMeta {1793    #[inline]1794    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }1795    #[inline]1796    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }1797}1798pub struct Trait {1799    pub(crate) syntax: SyntaxNode,1800}1801impl ast::HasAttrs for Trait {}1802impl ast::HasGenericParams for Trait {}1803impl ast::HasName for Trait {}1804impl ast::HasTypeBounds for Trait {}1805impl ast::HasVisibility for Trait {}1806impl Trait {1807    #[inline]1808    pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }1809    #[inline]1810    pub fn impl_restriction(&self) -> Option<ImplRestriction> { support::child(&self.syntax) }1811    #[inline]1812    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }1813    #[inline]1814    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }1815    #[inline]1816    pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }1817    #[inline]1818    pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }1819    #[inline]1820    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }1821}1822pub struct TryBlockModifier {1823    pub(crate) syntax: SyntaxNode,1824}1825impl TryBlockModifier {1826    #[inline]1827    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1828    #[inline]1829    pub fn bikeshed_token(&self) -> Option<SyntaxToken> {1830        support::token(&self.syntax, T![bikeshed])1831    }1832    #[inline]1833    pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) }1834}1835pub struct TryExpr {1836    pub(crate) syntax: SyntaxNode,1837}1838impl ast::HasAttrs for TryExpr {}1839impl TryExpr {1840    #[inline]1841    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }1842    #[inline]1843    pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }1844}1845pub struct TupleExpr {1846    pub(crate) syntax: SyntaxNode,1847}1848impl ast::HasAttrs for TupleExpr {}1849impl TupleExpr {1850    #[inline]1851    pub fn fields(&self) -> AstChildren<Expr> { support::children(&self.syntax) }1852    #[inline]1853    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1854    #[inline]1855    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1856}1857pub struct TupleField {1858    pub(crate) syntax: SyntaxNode,1859}1860impl ast::HasAttrs for TupleField {}1861impl ast::HasVisibility for TupleField {}1862impl TupleField {1863    #[inline]1864    pub fn mut_restriction(&self) -> Option<MutRestriction> { support::child(&self.syntax) }1865    #[inline]1866    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1867}1868pub struct TupleFieldList {1869    pub(crate) syntax: SyntaxNode,1870}1871impl TupleFieldList {1872    #[inline]1873    pub fn fields(&self) -> AstChildren<TupleField> { support::children(&self.syntax) }1874    #[inline]1875    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1876    #[inline]1877    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1878}1879pub struct TuplePat {1880    pub(crate) syntax: SyntaxNode,1881}1882impl TuplePat {1883    #[inline]1884    pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }1885    #[inline]1886    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1887    #[inline]1888    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1889}1890pub struct TupleStructPat {1891    pub(crate) syntax: SyntaxNode,1892}1893impl TupleStructPat {1894    #[inline]1895    pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) }1896    #[inline]1897    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }1898    #[inline]1899    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1900    #[inline]1901    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1902}1903pub struct TupleType {1904    pub(crate) syntax: SyntaxNode,1905}1906impl TupleType {1907    #[inline]1908    pub fn fields(&self) -> AstChildren<Type> { support::children(&self.syntax) }1909    #[inline]1910    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }1911    #[inline]1912    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }1913}1914pub struct TypeAlias {1915    pub(crate) syntax: SyntaxNode,1916}1917impl ast::HasAttrs for TypeAlias {}1918impl ast::HasGenericParams for TypeAlias {}1919impl ast::HasName for TypeAlias {}1920impl ast::HasTypeBounds for TypeAlias {}1921impl ast::HasVisibility for TypeAlias {}1922impl TypeAlias {1923    #[inline]1924    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1925    #[inline]1926    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }1927    #[inline]1928    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }1929    #[inline]1930    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }1931    #[inline]1932    pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }1933}1934pub struct TypeAnchor {1935    pub(crate) syntax: SyntaxNode,1936}1937impl TypeAnchor {1938    #[inline]1939    pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }1940    #[inline]1941    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1942    #[inline]1943    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }1944    #[inline]1945    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }1946    #[inline]1947    pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }1948}1949pub struct TypeArg {1950    pub(crate) syntax: SyntaxNode,1951}1952impl TypeArg {1953    #[inline]1954    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1955}1956pub struct TypeBound {1957    pub(crate) syntax: SyntaxNode,1958}1959impl TypeBound {1960    #[inline]1961    pub fn for_binder(&self) -> Option<ForBinder> { support::child(&self.syntax) }1962    #[inline]1963    pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }1964    #[inline]1965    pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }1966    #[inline]1967    pub fn use_bound_generic_args(&self) -> Option<UseBoundGenericArgs> {1968        support::child(&self.syntax)1969    }1970    #[inline]1971    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }1972    #[inline]1973    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }1974    #[inline]1975    pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }1976    #[inline]1977    pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }1978    #[inline]1979    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }1980    #[inline]1981    pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }1982    #[inline]1983    pub fn tilde_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![~]) }1984}1985pub struct TypeBoundList {1986    pub(crate) syntax: SyntaxNode,1987}1988impl TypeBoundList {1989    #[inline]1990    pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) }1991}1992pub struct TypeParam {1993    pub(crate) syntax: SyntaxNode,1994}1995impl ast::HasAttrs for TypeParam {}1996impl ast::HasName for TypeParam {}1997impl ast::HasTypeBounds for TypeParam {}1998impl TypeParam {1999    #[inline]2000    pub fn default_type(&self) -> Option<Type> { support::child(&self.syntax) }