diff options
| -rw-r--r-- | src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs | 1019 | ||||
| -rw-r--r-- | src/tools/rust-analyzer/xtask/src/codegen/grammar.rs | 13 |
2 files changed, 1032 insertions, 0 deletions
diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs index 0d01e0e73cd..0373e7c5529 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs @@ -12,6 +12,7 @@ pub struct Abi { pub(crate) syntax: SyntaxNode, } impl Abi { + #[inline] pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) } } @@ -20,7 +21,9 @@ pub struct ArgList { pub(crate) syntax: SyntaxNode, } impl ArgList { + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -30,10 +33,15 @@ pub struct ArrayExpr { } impl ast::HasAttrs for ArrayExpr {} impl ArrayExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } } @@ -42,10 +50,15 @@ pub struct ArrayType { pub(crate) syntax: SyntaxNode, } impl ArrayType { + #[inline] pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } } @@ -55,11 +68,17 @@ pub struct AsmExpr { } impl ast::HasAttrs for AsmExpr {} impl AsmExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn asm_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![asm]) } + #[inline] pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) } } @@ -69,8 +88,11 @@ pub struct AssocItemList { } impl ast::HasAttrs for AssocItemList {} impl AssocItemList { + #[inline] pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -81,11 +103,17 @@ pub struct AssocTypeArg { impl ast::HasGenericArgs for AssocTypeArg {} impl ast::HasTypeBounds for AssocTypeArg {} impl AssocTypeArg { + #[inline] pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) } + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + #[inline] pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } } @@ -94,10 +122,15 @@ pub struct Attr { pub(crate) syntax: SyntaxNode, } impl Attr { + #[inline] pub fn meta(&self) -> Option<Meta> { support::child(&self.syntax) } + #[inline] pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } + #[inline] pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } } @@ -107,8 +140,11 @@ pub struct AwaitExpr { } impl ast::HasAttrs for AwaitExpr {} impl AwaitExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } + #[inline] pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) } } @@ -118,7 +154,9 @@ pub struct BecomeExpr { } impl ast::HasAttrs for BecomeExpr {} impl BecomeExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn become_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![become]) } } @@ -135,11 +173,17 @@ pub struct BlockExpr { } impl ast::HasAttrs for BlockExpr {} impl BlockExpr { + #[inline] pub fn label(&self) -> Option<Label> { support::child(&self.syntax) } + #[inline] pub fn stmt_list(&self) -> Option<StmtList> { support::child(&self.syntax) } + #[inline] pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -148,7 +192,9 @@ pub struct BoxPat { pub(crate) syntax: SyntaxNode, } impl BoxPat { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) } } @@ -158,8 +204,11 @@ pub struct BreakExpr { } impl ast::HasAttrs for BreakExpr {} impl BreakExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn break_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![break]) } } @@ -170,6 +219,7 @@ pub struct CallExpr { impl ast::HasArgList for CallExpr {} impl ast::HasAttrs for CallExpr {} impl CallExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } } @@ -179,8 +229,11 @@ pub struct CastExpr { } impl ast::HasAttrs for CastExpr {} impl CastExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } } @@ -190,13 +243,21 @@ pub struct ClosureExpr { } impl ast::HasAttrs for ClosureExpr {} impl ClosureExpr { + #[inline] pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) } + #[inline] pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + #[inline] pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + #[inline] pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } + #[inline] pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) } + #[inline] pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) } } @@ -209,12 +270,19 @@ impl ast::HasDocComments for Const {} impl ast::HasName for Const {} impl ast::HasVisibility for Const {} impl Const { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) } } @@ -223,6 +291,7 @@ pub struct ConstArg { pub(crate) syntax: SyntaxNode, } impl ConstArg { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } } @@ -231,7 +300,9 @@ pub struct ConstBlockPat { pub(crate) syntax: SyntaxNode, } impl ConstBlockPat { + #[inline] pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } } @@ -242,10 +313,15 @@ pub struct ConstParam { impl ast::HasAttrs for ConstParam {} impl ast::HasName for ConstParam {} impl ConstParam { + #[inline] pub fn default_val(&self) -> Option<ConstArg> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } } @@ -255,7 +331,9 @@ pub struct ContinueExpr { } impl ast::HasAttrs for ContinueExpr {} impl ContinueExpr { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn continue_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![continue]) } @@ -266,7 +344,9 @@ pub struct DynTraitType { pub(crate) syntax: SyntaxNode, } impl DynTraitType { + #[inline] pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) } + #[inline] pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) } } @@ -280,7 +360,9 @@ impl ast::HasGenericParams for Enum {} impl ast::HasName for Enum {} impl ast::HasVisibility for Enum {} impl Enum { + #[inline] pub fn variant_list(&self) -> Option<VariantList> { support::child(&self.syntax) } + #[inline] pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) } } @@ -289,7 +371,9 @@ pub struct ExprStmt { pub(crate) syntax: SyntaxNode, } impl ExprStmt { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } } @@ -300,8 +384,11 @@ pub struct ExternBlock { impl ast::HasAttrs for ExternBlock {} impl ast::HasDocComments for ExternBlock {} impl ExternBlock { + #[inline] pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } + #[inline] pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -313,10 +400,15 @@ impl ast::HasAttrs for ExternCrate {} impl ast::HasDocComments for ExternCrate {} impl ast::HasVisibility for ExternCrate {} impl ExternCrate { + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) } + #[inline] pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) } } @@ -326,8 +418,11 @@ pub struct ExternItemList { } impl ast::HasAttrs for ExternItemList {} impl ExternItemList { + #[inline] pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -337,8 +432,11 @@ pub struct FieldExpr { } impl ast::HasAttrs for FieldExpr {} impl FieldExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } } @@ -352,14 +450,23 @@ impl ast::HasGenericParams for Fn {} impl ast::HasName for Fn {} impl ast::HasVisibility for Fn {} impl Fn { + #[inline] pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } + #[inline] pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + #[inline] pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) } + #[inline] pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -368,12 +475,19 @@ pub struct FnPtrType { pub(crate) syntax: SyntaxNode, } impl FnPtrType { + #[inline] pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } + #[inline] pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + #[inline] pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + #[inline] pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -383,8 +497,11 @@ pub struct ForExpr { } impl ast::HasAttrs for ForExpr {} impl ForExpr { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } + #[inline] pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) } } @@ -393,8 +510,11 @@ pub struct ForType { pub(crate) syntax: SyntaxNode, } impl ForType { + #[inline] pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } } @@ -404,7 +524,9 @@ pub struct FormatArgsArg { } impl ast::HasName for FormatArgsArg {} impl FormatArgsArg { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } } @@ -414,12 +536,19 @@ pub struct FormatArgsExpr { } impl ast::HasAttrs for FormatArgsExpr {} impl FormatArgsExpr { + #[inline] pub fn template(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) } + #[inline] pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) } + #[inline] pub fn format_args_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![format_args]) } @@ -430,9 +559,13 @@ pub struct GenericArgList { pub(crate) syntax: SyntaxNode, } impl GenericArgList { + #[inline] pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) } + #[inline] pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } + #[inline] pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } + #[inline] pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } } @@ -441,8 +574,11 @@ pub struct GenericParamList { pub(crate) syntax: SyntaxNode, } impl GenericParamList { + #[inline] pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) } + #[inline] pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } + #[inline] pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } } @@ -453,9 +589,13 @@ pub struct IdentPat { impl ast::HasAttrs for IdentPat {} impl ast::HasName for IdentPat {} impl IdentPat { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + #[inline] pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) } } @@ -465,7 +605,9 @@ pub struct IfExpr { } impl ast::HasAttrs for IfExpr {} impl IfExpr { + #[inline] pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) } + #[inline] pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) } } @@ -478,12 +620,19 @@ impl ast::HasDocComments for Impl {} impl ast::HasGenericParams for Impl {} impl ast::HasVisibility for Impl {} impl Impl { + #[inline] pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) } + #[inline] pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) } + #[inline] pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } + #[inline] pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -492,7 +641,9 @@ pub struct ImplTraitType { pub(crate) syntax: SyntaxNode, } impl ImplTraitType { + #[inline] pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) } + #[inline] pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) } } @@ -502,7 +653,9 @@ pub struct IndexExpr { } impl ast::HasAttrs for IndexExpr {} impl IndexExpr { + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } } @@ -511,6 +664,7 @@ pub struct InferType { pub(crate) syntax: SyntaxNode, } impl InferType { + #[inline] pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } } @@ -521,7 +675,9 @@ pub struct ItemList { impl ast::HasAttrs for ItemList {} impl ast::HasModuleItem for ItemList {} impl ItemList { + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -530,7 +686,9 @@ pub struct Label { pub(crate) syntax: SyntaxNode, } impl Label { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } } @@ -539,7 +697,9 @@ pub struct LetElse { pub(crate) syntax: SyntaxNode, } impl LetElse { + #[inline] pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) } + #[inline] pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) } } @@ -549,9 +709,13 @@ pub struct LetExpr { } impl ast::HasAttrs for LetExpr {} impl LetExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) } } @@ -561,13 +725,21 @@ pub struct LetStmt { } impl ast::HasAttrs for LetStmt {} impl LetStmt { + #[inline] pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn let_else(&self) -> Option<LetElse> { support::child(&self.syntax) } + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) } } @@ -576,6 +748,7 @@ pub struct Lifetime { pub(crate) syntax: SyntaxNode, } impl Lifetime { + #[inline] pub fn lifetime_ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![lifetime_ident]) } @@ -586,6 +759,7 @@ pub struct LifetimeArg { pub(crate) syntax: SyntaxNode, } impl LifetimeArg { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } } @@ -596,6 +770,7 @@ pub struct LifetimeParam { impl ast::HasAttrs for LifetimeParam {} impl ast::HasTypeBounds for LifetimeParam {} impl LifetimeParam { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } } @@ -611,7 +786,9 @@ pub struct LiteralPat { pub(crate) syntax: SyntaxNode, } impl LiteralPat { + #[inline] pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) } + #[inline] pub fn minus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![-]) } } @@ -622,6 +799,7 @@ pub struct LoopExpr { impl ast::HasAttrs for LoopExpr {} impl ast::HasLoopBody for LoopExpr {} impl LoopExpr { + #[inline] pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) } } @@ -632,9 +810,13 @@ pub struct MacroCall { impl ast::HasAttrs for MacroCall {} impl ast::HasDocComments for MacroCall {} impl MacroCall { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } + #[inline] pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } } @@ -647,6 +829,7 @@ impl ast::HasDocComments for MacroDef {} impl ast::HasName for MacroDef {} impl ast::HasVisibility for MacroDef {} impl MacroDef { + #[inline] pub fn macro_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![macro]) } } @@ -655,12 +838,19 @@ pub struct MacroEagerInput { pub(crate) syntax: SyntaxNode, } impl MacroEagerInput { + #[inline] pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -669,6 +859,7 @@ pub struct MacroExpr { pub(crate) syntax: SyntaxNode, } impl MacroExpr { + #[inline] pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) } } @@ -684,6 +875,7 @@ pub struct MacroPat { pub(crate) syntax: SyntaxNode, } impl MacroPat { + #[inline] pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) } } @@ -696,8 +888,11 @@ impl ast::HasDocComments for MacroRules {} impl ast::HasName for MacroRules {} impl ast::HasVisibility for MacroRules {} impl MacroRules { + #[inline] pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } + #[inline] pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } + #[inline] pub fn macro_rules_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![macro_rules]) } @@ -708,7 +903,9 @@ pub struct MacroStmts { pub(crate) syntax: SyntaxNode, } impl MacroStmts { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) } } @@ -717,6 +914,7 @@ pub struct MacroType { pub(crate) syntax: SyntaxNode, } impl MacroType { + #[inline] pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) } } @@ -726,10 +924,15 @@ pub struct MatchArm { } impl ast::HasAttrs for MatchArm {} impl MatchArm { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) } + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) } + #[inline] pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) } } @@ -739,8 +942,11 @@ pub struct MatchArmList { } impl ast::HasAttrs for MatchArmList {} impl MatchArmList { + #[inline] pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -750,8 +956,11 @@ pub struct MatchExpr { } impl ast::HasAttrs for MatchExpr {} impl MatchExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) } + #[inline] pub fn match_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![match]) } } @@ -760,6 +969,7 @@ pub struct MatchGuard { pub(crate) syntax: SyntaxNode, } impl MatchGuard { + #[inline] pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) } } @@ -768,12 +978,19 @@ pub struct Meta { pub(crate) syntax: SyntaxNode, } impl Meta { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -785,8 +1002,11 @@ impl ast::HasArgList for MethodCallExpr {} impl ast::HasAttrs for MethodCallExpr {} impl ast::HasGenericArgs for MethodCallExpr {} impl MethodCallExpr { + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn receiver(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } } @@ -799,8 +1019,11 @@ impl ast::HasDocComments for Module {} impl ast::HasName for Module {} impl ast::HasVisibility for Module {} impl Module { + #[inline] pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn mod_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mod]) } } @@ -809,7 +1032,9 @@ pub struct Name { pub(crate) syntax: SyntaxNode, } impl Name { + #[inline] pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) } + #[inline] pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) } } @@ -818,10 +1043,15 @@ pub struct NameRef { pub(crate) syntax: SyntaxNode, } impl NameRef { + #[inline] pub fn Self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![Self]) } + #[inline] pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) } + #[inline] pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) } + #[inline] pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) } + #[inline] pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) } } @@ -830,6 +1060,7 @@ pub struct NeverType { pub(crate) syntax: SyntaxNode, } impl NeverType { + #[inline] pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } } @@ -839,13 +1070,21 @@ pub struct OffsetOfExpr { } impl ast::HasAttrs for OffsetOfExpr {} impl OffsetOfExpr { + #[inline] pub fn fields(&self) -> AstChildren<NameRef> { support::children(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) } + #[inline] pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) } + #[inline] pub fn offset_of_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![offset_of]) } @@ -856,6 +1095,7 @@ pub struct OrPat { pub(crate) syntax: SyntaxNode, } impl OrPat { + #[inline] pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) } } @@ -865,9 +1105,13 @@ pub struct Param { } impl ast::HasAttrs for Param {} impl Param { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } } @@ -876,11 +1120,17 @@ pub struct ParamList { pub(crate) syntax: SyntaxNode, } impl ParamList { + #[inline] pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) } + #[inline] pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) } + #[inline] pub fn pipe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) } } @@ -890,8 +1140,11 @@ pub struct ParenExpr { } impl ast::HasAttrs for ParenExpr {} impl ParenExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -900,8 +1153,11 @@ pub struct ParenPat { pub(crate) syntax: SyntaxNode, } impl ParenPat { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -910,8 +1166,11 @@ pub struct ParenType { pub(crate) syntax: SyntaxNode, } impl ParenType { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -920,8 +1179,11 @@ pub struct Path { pub(crate) syntax: SyntaxNode, } impl Path { + #[inline] pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) } + #[inline] pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } } @@ -931,6 +1193,7 @@ pub struct PathExpr { } impl ast::HasAttrs for PathExpr {} impl PathExpr { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } } @@ -939,6 +1202,7 @@ pub struct PathPat { pub(crate) syntax: SyntaxNode, } impl PathPat { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } } @@ -948,14 +1212,23 @@ pub struct PathSegment { } impl ast::HasGenericArgs for PathSegment {} impl PathSegment { + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + #[inline] pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) } + #[inline] pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } + #[inline] pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } + #[inline] pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } + #[inline] pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } } @@ -964,6 +1237,7 @@ pub struct PathType { pub(crate) syntax: SyntaxNode, } impl PathType { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } } @@ -973,6 +1247,7 @@ pub struct PrefixExpr { } impl ast::HasAttrs for PrefixExpr {} impl PrefixExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } } @@ -981,9 +1256,13 @@ pub struct PtrType { pub(crate) syntax: SyntaxNode, } impl PtrType { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } } @@ -1005,7 +1284,9 @@ pub struct RecordExpr { pub(crate) syntax: SyntaxNode, } impl RecordExpr { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn record_expr_field_list(&self) -> Option<RecordExprFieldList> { support::child(&self.syntax) } @@ -1017,8 +1298,11 @@ pub struct RecordExprField { } impl ast::HasAttrs for RecordExprField {} impl RecordExprField { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } } @@ -1028,10 +1312,15 @@ pub struct RecordExprFieldList { } impl ast::HasAttrs for RecordExprFieldList {} impl RecordExprFieldList { + #[inline] pub fn fields(&self) -> AstChildren<RecordExprField> { support::children(&self.syntax) } + #[inline] pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } + #[inline] pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } } @@ -1044,7 +1333,9 @@ impl ast::HasDocComments for RecordField {} impl ast::HasName for RecordField {} impl ast::HasVisibility for RecordField {} impl RecordField { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } } @@ -1053,8 +1344,11 @@ pub struct RecordFieldList { pub(crate) syntax: SyntaxNode, } impl RecordFieldList { + #[inline] pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1063,7 +1357,9 @@ pub struct RecordPat { pub(crate) syntax: SyntaxNode, } impl RecordPat { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn record_pat_field_list(&self) -> Option<RecordPatFieldList> { support::child(&self.syntax) } @@ -1075,8 +1371,11 @@ pub struct RecordPatField { } impl ast::HasAttrs for RecordPatField {} impl RecordPatField { + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } } @@ -1085,9 +1384,13 @@ pub struct RecordPatFieldList { pub(crate) syntax: SyntaxNode, } impl RecordPatFieldList { + #[inline] pub fn fields(&self) -> AstChildren<RecordPatField> { support::children(&self.syntax) } + #[inline] pub fn rest_pat(&self) -> Option<RestPat> { support::child(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1097,10 +1400,15 @@ pub struct RefExpr { } impl ast::HasAttrs for RefExpr {} impl RefExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + #[inline] pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) } } @@ -1109,8 +1417,11 @@ pub struct RefPat { pub(crate) syntax: SyntaxNode, } impl RefPat { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } } @@ -1119,9 +1430,13 @@ pub struct RefType { pub(crate) syntax: SyntaxNode, } impl RefType { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } } @@ -1131,7 +1446,9 @@ pub struct Rename { } impl ast::HasName for Rename {} impl Rename { + #[inline] pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } + #[inline] pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } } @@ -1141,6 +1458,7 @@ pub struct RestPat { } impl ast::HasAttrs for RestPat {} impl RestPat { + #[inline] pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } } @@ -1149,7 +1467,9 @@ pub struct RetType { pub(crate) syntax: SyntaxNode, } impl RetType { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) } } @@ -1159,7 +1479,9 @@ pub struct ReturnExpr { } impl ast::HasAttrs for ReturnExpr {} impl ReturnExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn return_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![return]) } } @@ -1170,10 +1492,15 @@ pub struct SelfParam { impl ast::HasAttrs for SelfParam {} impl ast::HasName for SelfParam {} impl SelfParam { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } } @@ -1182,8 +1509,11 @@ pub struct SlicePat { pub(crate) syntax: SyntaxNode, } impl SlicePat { + #[inline] pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } } @@ -1192,8 +1522,11 @@ pub struct SliceType { pub(crate) syntax: SyntaxNode, } impl SliceType { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } } @@ -1205,6 +1538,7 @@ impl ast::HasAttrs for SourceFile {} impl ast::HasDocComments for SourceFile {} impl ast::HasModuleItem for SourceFile {} impl SourceFile { + #[inline] pub fn shebang_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![shebang]) } } @@ -1217,11 +1551,17 @@ impl ast::HasDocComments for Static {} impl ast::HasName for Static {} impl ast::HasVisibility for Static {} impl Static { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + #[inline] pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) } } @@ -1231,9 +1571,13 @@ pub struct StmtList { } impl ast::HasAttrs for StmtList {} impl StmtList { + #[inline] pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) } + #[inline] pub fn tail_expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1247,8 +1591,11 @@ impl ast::HasGenericParams for Struct {} impl ast::HasName for Struct {} impl ast::HasVisibility for Struct {} impl Struct { + #[inline] pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn struct_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![struct]) } } @@ -1257,11 +1604,17 @@ pub struct TokenTree { pub(crate) syntax: SyntaxNode, } impl TokenTree { + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1276,9 +1629,13 @@ impl ast::HasName for Trait {} impl ast::HasTypeBounds for Trait {} impl ast::HasVisibility for Trait {} impl Trait { + #[inline] pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) } + #[inline] pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) } + #[inline] pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -1292,9 +1649,13 @@ impl ast::HasGenericParams for TraitAlias {} impl ast::HasName for TraitAlias {} impl ast::HasVisibility for TraitAlias {} impl TraitAlias { + #[inline] pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) } } @@ -1304,7 +1665,9 @@ pub struct TryExpr { } impl ast::HasAttrs for TryExpr {} impl TryExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) } } @@ -1314,8 +1677,11 @@ pub struct TupleExpr { } impl ast::HasAttrs for TupleExpr {} impl TupleExpr { + #[inline] pub fn fields(&self) -> AstChildren<Expr> { support::children(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -1327,6 +1693,7 @@ impl ast::HasAttrs for TupleField {} impl ast::HasDocComments for TupleField {} impl ast::HasVisibility for TupleField {} impl TupleField { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } } @@ -1335,8 +1702,11 @@ pub struct TupleFieldList { pub(crate) syntax: SyntaxNode, } impl TupleFieldList { + #[inline] pub fn fields(&self) -> AstChildren<TupleField> { support::children(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -1345,8 +1715,11 @@ pub struct TuplePat { pub(crate) syntax: SyntaxNode, } impl TuplePat { + #[inline] pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -1355,9 +1728,13 @@ pub struct TupleStructPat { pub(crate) syntax: SyntaxNode, } impl TupleStructPat { + #[inline] pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) } + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -1366,8 +1743,11 @@ pub struct TupleType { pub(crate) syntax: SyntaxNode, } impl TupleType { + #[inline] pub fn fields(&self) -> AstChildren<Type> { support::children(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -1382,10 +1762,15 @@ impl ast::HasName for TypeAlias {} impl ast::HasTypeBounds for TypeAlias {} impl ast::HasVisibility for TypeAlias {} impl TypeAlias { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) } + #[inline] pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) } } @@ -1394,6 +1779,7 @@ pub struct TypeArg { pub(crate) syntax: SyntaxNode, } impl TypeArg { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } } @@ -1402,11 +1788,17 @@ pub struct TypeBound { pub(crate) syntax: SyntaxNode, } impl TypeBound { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) } + #[inline] pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn tilde_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![~]) } } @@ -1415,6 +1807,7 @@ pub struct TypeBoundList { pub(crate) syntax: SyntaxNode, } impl TypeBoundList { + #[inline] pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) } } @@ -1426,7 +1819,9 @@ impl ast::HasAttrs for TypeParam {} impl ast::HasName for TypeParam {} impl ast::HasTypeBounds for TypeParam {} impl TypeParam { + #[inline] pub fn default_type(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } } @@ -1436,6 +1831,7 @@ pub struct UnderscoreExpr { } impl ast::HasAttrs for UnderscoreExpr {} impl UnderscoreExpr { + #[inline] pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } } @@ -1449,7 +1845,9 @@ impl ast::HasGenericParams for Union {} impl ast::HasName for Union {} impl ast::HasVisibility for Union {} impl Union { + #[inline] pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) } + #[inline] pub fn union_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![union]) } } @@ -1461,8 +1859,11 @@ impl ast::HasAttrs for Use {} impl ast::HasDocComments for Use {} impl ast::HasVisibility for Use {} impl Use { + #[inline] pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) } } @@ -1471,10 +1872,15 @@ pub struct UseTree { pub(crate) syntax: SyntaxNode, } impl UseTree { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) } + #[inline] pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) } + #[inline] pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) } + #[inline] pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } } @@ -1483,8 +1889,11 @@ pub struct UseTreeList { pub(crate) syntax: SyntaxNode, } impl UseTreeList { + #[inline] pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1497,8 +1906,11 @@ impl ast::HasDocComments for Variant {} impl ast::HasName for Variant {} impl ast::HasVisibility for Variant {} impl Variant { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } } @@ -1507,8 +1919,11 @@ pub struct VariantList { pub(crate) syntax: SyntaxNode, } impl VariantList { + #[inline] pub fn variants(&self) -> AstChildren<Variant> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1517,10 +1932,15 @@ pub struct Visibility { pub(crate) syntax: SyntaxNode, } impl Visibility { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) } + #[inline] pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) } } @@ -1529,7 +1949,9 @@ pub struct WhereClause { pub(crate) syntax: SyntaxNode, } impl WhereClause { + #[inline] pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) } + #[inline] pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) } } @@ -1539,9 +1961,13 @@ pub struct WherePred { } impl ast::HasTypeBounds for WherePred {} impl WherePred { + #[inline] pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) } + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } } @@ -1551,6 +1977,7 @@ pub struct WhileExpr { } impl ast::HasAttrs for WhileExpr {} impl WhileExpr { + #[inline] pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) } } @@ -1559,6 +1986,7 @@ pub struct WildcardPat { pub(crate) syntax: SyntaxNode, } impl WildcardPat { + #[inline] pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } } @@ -1568,8 +1996,11 @@ pub struct YeetExpr { } impl ast::HasAttrs for YeetExpr {} impl YeetExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn do_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![do]) } + #[inline] pub fn yeet_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yeet]) } } @@ -1579,7 +2010,9 @@ pub struct YieldExpr { } impl ast::HasAttrs for YieldExpr {} impl YieldExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn yield_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yield]) } } @@ -1805,7 +2238,9 @@ pub struct AnyHasVisibility { } impl ast::HasVisibility for AnyHasVisibility {} impl AstNode for Abi { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ABI } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1813,10 +2248,13 @@ impl AstNode for Abi { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ArgList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1824,10 +2262,13 @@ impl AstNode for ArgList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ArrayExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1835,10 +2276,13 @@ impl AstNode for ArrayExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ArrayType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1846,10 +2290,13 @@ impl AstNode for ArrayType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for AsmExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1857,10 +2304,13 @@ impl AstNode for AsmExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for AssocItemList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_ITEM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1868,10 +2318,13 @@ impl AstNode for AssocItemList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for AssocTypeArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1879,10 +2332,13 @@ impl AstNode for AssocTypeArg { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Attr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1890,10 +2346,13 @@ impl AstNode for Attr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for AwaitExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1901,10 +2360,13 @@ impl AstNode for AwaitExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for BecomeExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BECOME_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1912,10 +2374,13 @@ impl AstNode for BecomeExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for BinExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1923,10 +2388,13 @@ impl AstNode for BinExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for BlockExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1934,10 +2402,13 @@ impl AstNode for BlockExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for BoxPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1945,10 +2416,13 @@ impl AstNode for BoxPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for BreakExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1956,10 +2430,13 @@ impl AstNode for BreakExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for CallExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1967,10 +2444,13 @@ impl AstNode for CallExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for CastExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1978,10 +2458,13 @@ impl AstNode for CastExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ClosureExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CLOSURE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1989,10 +2472,13 @@ impl AstNode for ClosureExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Const { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2000,10 +2486,13 @@ impl AstNode for Const { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ConstArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2011,10 +2500,13 @@ impl AstNode for ConstArg { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ConstBlockPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_BLOCK_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2022,10 +2514,13 @@ impl AstNode for ConstBlockPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ConstParam { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2033,10 +2528,13 @@ impl AstNode for ConstParam { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ContinueExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2044,10 +2542,13 @@ impl AstNode for ContinueExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for DynTraitType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2055,10 +2556,13 @@ impl AstNode for DynTraitType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Enum { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2066,10 +2570,13 @@ impl AstNode for Enum { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ExprStmt { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2077,10 +2584,13 @@ impl AstNode for ExprStmt { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ExternBlock { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2088,10 +2598,13 @@ impl AstNode for ExternBlock { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ExternCrate { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2099,10 +2612,13 @@ impl AstNode for ExternCrate { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ExternItemList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2110,10 +2626,13 @@ impl AstNode for ExternItemList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for FieldExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2121,10 +2640,13 @@ impl AstNode for FieldExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Fn { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FN } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2132,10 +2654,13 @@ impl AstNode for Fn { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for FnPtrType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FN_PTR_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2143,10 +2668,13 @@ impl AstNode for FnPtrType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ForExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2154,10 +2682,13 @@ impl AstNode for ForExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ForType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2165,10 +2696,13 @@ impl AstNode for ForType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for FormatArgsArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_ARG } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2176,10 +2710,13 @@ impl AstNode for FormatArgsArg { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for FormatArgsExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2187,10 +2724,13 @@ impl AstNode for FormatArgsExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for GenericArgList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_ARG_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2198,10 +2738,13 @@ impl AstNode for GenericArgList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for GenericParamList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_PARAM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2209,10 +2752,13 @@ impl AstNode for GenericParamList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for IdentPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IDENT_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2220,10 +2766,13 @@ impl AstNode for IdentPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for IfExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2231,10 +2780,13 @@ impl AstNode for IfExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Impl { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2242,10 +2794,13 @@ impl AstNode for Impl { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ImplTraitType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2253,10 +2808,13 @@ impl AstNode for ImplTraitType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for IndexExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2264,10 +2822,13 @@ impl AstNode for IndexExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for InferType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == INFER_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2275,10 +2836,13 @@ impl AstNode for InferType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ItemList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2286,10 +2850,13 @@ impl AstNode for ItemList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Label { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2297,10 +2864,13 @@ impl AstNode for Label { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LetElse { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LET_ELSE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2308,10 +2878,13 @@ impl AstNode for LetElse { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LetExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LET_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2319,10 +2892,13 @@ impl AstNode for LetExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LetStmt { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2330,10 +2906,13 @@ impl AstNode for LetStmt { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Lifetime { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2341,10 +2920,13 @@ impl AstNode for Lifetime { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LifetimeArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2352,10 +2934,13 @@ impl AstNode for LifetimeArg { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LifetimeParam { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2363,10 +2948,13 @@ impl AstNode for LifetimeParam { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Literal { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2374,10 +2962,13 @@ impl AstNode for Literal { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LiteralPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2385,10 +2976,13 @@ impl AstNode for LiteralPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LoopExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2396,10 +2990,13 @@ impl AstNode for LoopExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroCall { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2407,10 +3004,13 @@ impl AstNode for MacroCall { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroDef { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_DEF } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2418,10 +3018,13 @@ impl AstNode for MacroDef { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroEagerInput { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_EAGER_INPUT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2429,10 +3032,13 @@ impl AstNode for MacroEagerInput { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2440,10 +3046,13 @@ impl AstNode for MacroExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroItems { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2451,10 +3060,13 @@ impl AstNode for MacroItems { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2462,10 +3074,13 @@ impl AstNode for MacroPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroRules { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_RULES } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2473,10 +3088,13 @@ impl AstNode for MacroRules { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroStmts { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2484,10 +3102,13 @@ impl AstNode for MacroStmts { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2495,10 +3116,13 @@ impl AstNode for MacroType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MatchArm { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2506,10 +3130,13 @@ impl AstNode for MatchArm { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MatchArmList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2517,10 +3144,13 @@ impl AstNode for MatchArmList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MatchExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2528,10 +3158,13 @@ impl AstNode for MatchExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MatchGuard { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2539,10 +3172,13 @@ impl AstNode for MatchGuard { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Meta { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == META } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2550,10 +3186,13 @@ impl AstNode for Meta { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MethodCallExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2561,10 +3200,13 @@ impl AstNode for MethodCallExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Module { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2572,10 +3214,13 @@ impl AstNode for Module { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Name { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == NAME } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2583,10 +3228,13 @@ impl AstNode for Name { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for NameRef { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2594,10 +3242,13 @@ impl AstNode for NameRef { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for NeverType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2605,10 +3256,13 @@ impl AstNode for NeverType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for OffsetOfExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == OFFSET_OF_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2616,10 +3270,13 @@ impl AstNode for OffsetOfExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for OrPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2627,10 +3284,13 @@ impl AstNode for OrPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Param { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2638,10 +3298,13 @@ impl AstNode for Param { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ParamList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2649,10 +3312,13 @@ impl AstNode for ParamList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ParenExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2660,10 +3326,13 @@ impl AstNode for ParenExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ParenPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2671,10 +3340,13 @@ impl AstNode for ParenPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ParenType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2682,10 +3354,13 @@ impl AstNode for ParenType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Path { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2693,10 +3368,13 @@ impl AstNode for Path { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PathExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2704,10 +3382,13 @@ impl AstNode for PathExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PathPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2715,10 +3396,13 @@ impl AstNode for PathPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PathSegment { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2726,10 +3410,13 @@ impl AstNode for PathSegment { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PathType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2737,10 +3424,13 @@ impl AstNode for PathType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PrefixExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2748,10 +3438,13 @@ impl AstNode for PrefixExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PtrType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PTR_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2759,10 +3452,13 @@ impl AstNode for PtrType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RangeExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2770,10 +3466,13 @@ impl AstNode for RangeExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RangePat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2781,10 +3480,13 @@ impl AstNode for RangePat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2792,10 +3494,13 @@ impl AstNode for RecordExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordExprField { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2803,10 +3508,13 @@ impl AstNode for RecordExprField { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordExprFieldList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2814,10 +3522,13 @@ impl AstNode for RecordExprFieldList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordField { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2825,10 +3536,13 @@ impl AstNode for RecordField { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordFieldList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2836,10 +3550,13 @@ impl AstNode for RecordFieldList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2847,10 +3564,13 @@ impl AstNode for RecordPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordPatField { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2858,10 +3578,13 @@ impl AstNode for RecordPatField { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordPatFieldList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2869,10 +3592,13 @@ impl AstNode for RecordPatFieldList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RefExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2880,10 +3606,13 @@ impl AstNode for RefExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RefPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2891,10 +3620,13 @@ impl AstNode for RefPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RefType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REF_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2902,10 +3634,13 @@ impl AstNode for RefType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Rename { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RENAME } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2913,10 +3648,13 @@ impl AstNode for Rename { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RestPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REST_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2924,10 +3662,13 @@ impl AstNode for RestPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RetType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2935,10 +3676,13 @@ impl AstNode for RetType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ReturnExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2946,10 +3690,13 @@ impl AstNode for ReturnExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for SelfParam { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2957,10 +3704,13 @@ impl AstNode for SelfParam { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for SlicePat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2968,10 +3718,13 @@ impl AstNode for SlicePat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for SliceType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2979,10 +3732,13 @@ impl AstNode for SliceType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for SourceFile { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2990,10 +3746,13 @@ impl AstNode for SourceFile { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Static { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3001,10 +3760,13 @@ impl AstNode for Static { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for StmtList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == STMT_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3012,10 +3774,13 @@ impl AstNode for StmtList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Struct { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3023,10 +3788,13 @@ impl AstNode for Struct { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TokenTree { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3034,10 +3802,13 @@ impl AstNode for TokenTree { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Trait { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3045,10 +3816,13 @@ impl AstNode for Trait { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TraitAlias { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT_ALIAS } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3056,10 +3830,13 @@ impl AstNode for TraitAlias { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TryExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3067,10 +3844,13 @@ impl AstNode for TryExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TupleExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3078,10 +3858,13 @@ impl AstNode for TupleExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TupleField { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3089,10 +3872,13 @@ impl AstNode for TupleField { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TupleFieldList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3100,10 +3886,13 @@ impl AstNode for TupleFieldList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TuplePat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3111,10 +3900,13 @@ impl AstNode for TuplePat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TupleStructPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3122,10 +3914,13 @@ impl AstNode for TupleStructPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TupleType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3133,10 +3928,13 @@ impl AstNode for TupleType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TypeAlias { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3144,10 +3942,13 @@ impl AstNode for TypeAlias { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TypeArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3155,10 +3956,13 @@ impl AstNode for TypeArg { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TypeBound { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3166,10 +3970,13 @@ impl AstNode for TypeBound { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TypeBoundList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3177,10 +3984,13 @@ impl AstNode for TypeBoundList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TypeParam { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3188,10 +3998,13 @@ impl AstNode for TypeParam { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for UnderscoreExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == UNDERSCORE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3199,10 +4012,13 @@ impl AstNode for UnderscoreExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Union { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == UNION } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3210,10 +4026,13 @@ impl AstNode for Union { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Use { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == USE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3221,10 +4040,13 @@ impl AstNode for Use { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for UseTree { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3232,10 +4054,13 @@ impl AstNode for UseTree { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for UseTreeList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3243,10 +4068,13 @@ impl AstNode for UseTreeList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Variant { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3254,10 +4082,13 @@ impl AstNode for Variant { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for VariantList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3265,10 +4096,13 @@ impl AstNode for VariantList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Visibility { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3276,10 +4110,13 @@ impl AstNode for Visibility { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for WhereClause { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3287,10 +4124,13 @@ impl AstNode for WhereClause { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for WherePred { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3298,10 +4138,13 @@ impl AstNode for WherePred { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for WhileExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3309,10 +4152,13 @@ impl AstNode for WhileExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for WildcardPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WILDCARD_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3320,10 +4166,13 @@ impl AstNode for WildcardPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for YeetExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == YEET_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3331,10 +4180,13 @@ impl AstNode for YeetExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for YieldExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == YIELD_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3342,19 +4194,25 @@ impl AstNode for YieldExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl From<Enum> for Adt { + #[inline] fn from(node: Enum) -> Adt { Adt::Enum(node) } } impl From<Struct> for Adt { + #[inline] fn from(node: Struct) -> Adt { Adt::Struct(node) } } impl From<Union> for Adt { + #[inline] fn from(node: Union) -> Adt { Adt::Union(node) } } impl AstNode for Adt { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ENUM | STRUCT | UNION) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { ENUM => Adt::Enum(Enum { syntax }), @@ -3364,6 +4222,7 @@ impl AstNode for Adt { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { Adt::Enum(it) => &it.syntax, @@ -3373,19 +4232,25 @@ impl AstNode for Adt { } } impl From<Const> for AssocItem { + #[inline] fn from(node: Const) -> AssocItem { AssocItem::Const(node) } } impl From<Fn> for AssocItem { + #[inline] fn from(node: Fn) -> AssocItem { AssocItem::Fn(node) } } impl From<MacroCall> for AssocItem { + #[inline] fn from(node: MacroCall) -> AssocItem { AssocItem::MacroCall(node) } } impl From<TypeAlias> for AssocItem { + #[inline] fn from(node: TypeAlias) -> AssocItem { AssocItem::TypeAlias(node) } } impl AstNode for AssocItem { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CONST | FN | MACRO_CALL | TYPE_ALIAS) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { CONST => AssocItem::Const(Const { syntax }), @@ -3396,6 +4261,7 @@ impl AstNode for AssocItem { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { AssocItem::Const(it) => &it.syntax, @@ -3406,114 +4272,151 @@ impl AstNode for AssocItem { } } impl From<ArrayExpr> for Expr { + #[inline] fn from(node: ArrayExpr) -> Expr { Expr::ArrayExpr(node) } } impl From<AsmExpr> for Expr { + #[inline] fn from(node: AsmExpr) -> Expr { Expr::AsmExpr(node) } } impl From<AwaitExpr> for Expr { + #[inline] fn from(node: AwaitExpr) -> Expr { Expr::AwaitExpr(node) } } impl From<BecomeExpr> for Expr { + #[inline] fn from(node: BecomeExpr) -> Expr { Expr::BecomeExpr(node) } } impl From<BinExpr> for Expr { + #[inline] fn from(node: BinExpr) -> Expr { Expr::BinExpr(node) } } impl From<BlockExpr> for Expr { + #[inline] fn from(node: BlockExpr) -> Expr { Expr::BlockExpr(node) } } impl From<BreakExpr> for Expr { + #[inline] fn from(node: BreakExpr) -> Expr { Expr::BreakExpr(node) } } impl From<CallExpr> for Expr { + #[inline] fn from(node: CallExpr) -> Expr { Expr::CallExpr(node) } } impl From<CastExpr> for Expr { + #[inline] fn from(node: CastExpr) -> Expr { Expr::CastExpr(node) } } impl From<ClosureExpr> for Expr { + #[inline] fn from(node: ClosureExpr) -> Expr { Expr::ClosureExpr(node) } } impl From<ContinueExpr> for Expr { + #[inline] fn from(node: ContinueExpr) -> Expr { Expr::ContinueExpr(node) } } impl From<FieldExpr> for Expr { + #[inline] fn from(node: FieldExpr) -> Expr { Expr::FieldExpr(node) } } impl From<ForExpr> for Expr { + #[inline] fn from(node: ForExpr) -> Expr { Expr::ForExpr(node) } } impl From<FormatArgsExpr> for Expr { + #[inline] fn from(node: FormatArgsExpr) -> Expr { Expr::FormatArgsExpr(node) } } impl From<IfExpr> for Expr { + #[inline] fn from(node: IfExpr) -> Expr { Expr::IfExpr(node) } } impl From<IndexExpr> for Expr { + #[inline] fn from(node: IndexExpr) -> Expr { Expr::IndexExpr(node) } } impl From<LetExpr> for Expr { + #[inline] fn from(node: LetExpr) -> Expr { Expr::LetExpr(node) } } impl From<Literal> for Expr { + #[inline] fn from(node: Literal) -> Expr { Expr::Literal(node) } } impl From<LoopExpr> for Expr { + #[inline] fn from(node: LoopExpr) -> Expr { Expr::LoopExpr(node) } } impl From<MacroExpr> for Expr { + #[inline] fn from(node: MacroExpr) -> Expr { Expr::MacroExpr(node) } } impl From<MatchExpr> for Expr { + #[inline] fn from(node: MatchExpr) -> Expr { Expr::MatchExpr(node) } } impl From<MethodCallExpr> for Expr { + #[inline] fn from(node: MethodCallExpr) -> Expr { Expr::MethodCallExpr(node) } } impl From<OffsetOfExpr> for Expr { + #[inline] fn from(node: OffsetOfExpr) -> Expr { Expr::OffsetOfExpr(node) } } impl From<ParenExpr> for Expr { + #[inline] fn from(node: ParenExpr) -> Expr { Expr::ParenExpr(node) } } impl From<PathExpr> for Expr { + #[inline] fn from(node: PathExpr) -> Expr { Expr::PathExpr(node) } } impl From<PrefixExpr> for Expr { + #[inline] fn from(node: PrefixExpr) -> Expr { Expr::PrefixExpr(node) } } impl From<RangeExpr> for Expr { + #[inline] fn from(node: RangeExpr) -> Expr { Expr::RangeExpr(node) } } impl From<RecordExpr> for Expr { + #[inline] fn from(node: RecordExpr) -> Expr { Expr::RecordExpr(node) } } impl From<RefExpr> for Expr { + #[inline] fn from(node: RefExpr) -> Expr { Expr::RefExpr(node) } } impl From<ReturnExpr> for Expr { + #[inline] fn from(node: ReturnExpr) -> Expr { Expr::ReturnExpr(node) } } impl From<TryExpr> for Expr { + #[inline] fn from(node: TryExpr) -> Expr { Expr::TryExpr(node) } } impl From<TupleExpr> for Expr { + #[inline] fn from(node: TupleExpr) -> Expr { Expr::TupleExpr(node) } } impl From<UnderscoreExpr> for Expr { + #[inline] fn from(node: UnderscoreExpr) -> Expr { Expr::UnderscoreExpr(node) } } impl From<WhileExpr> for Expr { + #[inline] fn from(node: WhileExpr) -> Expr { Expr::WhileExpr(node) } } impl From<YeetExpr> for Expr { + #[inline] fn from(node: YeetExpr) -> Expr { Expr::YeetExpr(node) } } impl From<YieldExpr> for Expr { + #[inline] fn from(node: YieldExpr) -> Expr { Expr::YieldExpr(node) } } impl AstNode for Expr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -3555,6 +4458,7 @@ impl AstNode for Expr { | YIELD_EXPR ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }), @@ -3597,6 +4501,7 @@ impl AstNode for Expr { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { Expr::ArrayExpr(it) => &it.syntax, @@ -3639,19 +4544,25 @@ impl AstNode for Expr { } } impl From<Fn> for ExternItem { + #[inline] fn from(node: Fn) -> ExternItem { ExternItem::Fn(node) } } impl From<MacroCall> for ExternItem { + #[inline] fn from(node: MacroCall) -> ExternItem { ExternItem::MacroCall(node) } } impl From<Static> for ExternItem { + #[inline] fn from(node: Static) -> ExternItem { ExternItem::Static(node) } } impl From<TypeAlias> for ExternItem { + #[inline] fn from(node: TypeAlias) -> ExternItem { ExternItem::TypeAlias(node) } } impl AstNode for ExternItem { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, FN | MACRO_CALL | STATIC | TYPE_ALIAS) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { FN => ExternItem::Fn(Fn { syntax }), @@ -3662,6 +4573,7 @@ impl AstNode for ExternItem { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { ExternItem::Fn(it) => &it.syntax, @@ -3672,13 +4584,17 @@ impl AstNode for ExternItem { } } impl From<RecordFieldList> for FieldList { + #[inline] fn from(node: RecordFieldList) -> FieldList { FieldList::RecordFieldList(node) } } impl From<TupleFieldList> for FieldList { + #[inline] fn from(node: TupleFieldList) -> FieldList { FieldList::TupleFieldList(node) } } impl AstNode for FieldList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, RECORD_FIELD_LIST | TUPLE_FIELD_LIST) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { RECORD_FIELD_LIST => FieldList::RecordFieldList(RecordFieldList { syntax }), @@ -3687,6 +4603,7 @@ impl AstNode for FieldList { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { FieldList::RecordFieldList(it) => &it.syntax, @@ -3695,21 +4612,27 @@ impl AstNode for FieldList { } } impl From<AssocTypeArg> for GenericArg { + #[inline] fn from(node: AssocTypeArg) -> GenericArg { GenericArg::AssocTypeArg(node) } } impl From<ConstArg> for GenericArg { + #[inline] fn from(node: ConstArg) -> GenericArg { GenericArg::ConstArg(node) } } impl From<LifetimeArg> for GenericArg { + #[inline] fn from(node: LifetimeArg) -> GenericArg { GenericArg::LifetimeArg(node) } } impl From<TypeArg> for GenericArg { + #[inline] fn from(node: TypeArg) -> GenericArg { GenericArg::TypeArg(node) } } impl AstNode for GenericArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ASSOC_TYPE_ARG | CONST_ARG | LIFETIME_ARG | TYPE_ARG) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { ASSOC_TYPE_ARG => GenericArg::AssocTypeArg(AssocTypeArg { syntax }), @@ -3720,6 +4643,7 @@ impl AstNode for GenericArg { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { GenericArg::AssocTypeArg(it) => &it.syntax, @@ -3730,18 +4654,23 @@ impl AstNode for GenericArg { } } impl From<ConstParam> for GenericParam { + #[inline] fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) } } impl From<LifetimeParam> for GenericParam { + #[inline] fn from(node: LifetimeParam) -> GenericParam { GenericParam::LifetimeParam(node) } } impl From<TypeParam> for GenericParam { + #[inline] fn from(node: TypeParam) -> GenericParam { GenericParam::TypeParam(node) } } impl AstNode for GenericParam { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CONST_PARAM | LIFETIME_PARAM | TYPE_PARAM) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { CONST_PARAM => GenericParam::ConstParam(ConstParam { syntax }), @@ -3751,6 +4680,7 @@ impl AstNode for GenericParam { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { GenericParam::ConstParam(it) => &it.syntax, @@ -3760,57 +4690,75 @@ impl AstNode for GenericParam { } } impl From<Const> for Item { + #[inline] fn from(node: Const) -> Item { Item::Const(node) } } impl From<Enum> for Item { + #[inline] fn from(node: Enum) -> Item { Item::Enum(node) } } impl From<ExternBlock> for Item { + #[inline] fn from(node: ExternBlock) -> Item { Item::ExternBlock(node) } } impl From<ExternCrate> for Item { + #[inline] fn from(node: ExternCrate) -> Item { Item::ExternCrate(node) } } impl From<Fn> for Item { + #[inline] fn from(node: Fn) -> Item { Item::Fn(node) } } impl From<Impl> for Item { + #[inline] fn from(node: Impl) -> Item { Item::Impl(node) } } impl From<MacroCall> for Item { + #[inline] fn from(node: MacroCall) -> Item { Item::MacroCall(node) } } impl From<MacroDef> for Item { + #[inline] fn from(node: MacroDef) -> Item { Item::MacroDef(node) } } impl From<MacroRules> for Item { + #[inline] fn from(node: MacroRules) -> Item { Item::MacroRules(node) } } impl From<Module> for Item { + #[inline] fn from(node: Module) -> Item { Item::Module(node) } } impl From<Static> for Item { + #[inline] fn from(node: Static) -> Item { Item::Static(node) } } impl From<Struct> for Item { + #[inline] fn from(node: Struct) -> Item { Item::Struct(node) } } impl From<Trait> for Item { + #[inline] fn from(node: Trait) -> Item { Item::Trait(node) } } impl From<TraitAlias> for Item { + #[inline] fn from(node: TraitAlias) -> Item { Item::TraitAlias(node) } } impl From<TypeAlias> for Item { + #[inline] fn from(node: TypeAlias) -> Item { Item::TypeAlias(node) } } impl From<Union> for Item { + #[inline] fn from(node: Union) -> Item { Item::Union(node) } } impl From<Use> for Item { + #[inline] fn from(node: Use) -> Item { Item::Use(node) } } impl AstNode for Item { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -3833,6 +4781,7 @@ impl AstNode for Item { | USE ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { CONST => Item::Const(Const { syntax }), @@ -3856,6 +4805,7 @@ impl AstNode for Item { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { Item::Const(it) => &it.syntax, @@ -3879,54 +4829,71 @@ impl AstNode for Item { } } impl From<BoxPat> for Pat { + #[inline] fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) } } impl From<ConstBlockPat> for Pat { + #[inline] fn from(node: ConstBlockPat) -> Pat { Pat::ConstBlockPat(node) } } impl From<IdentPat> for Pat { + #[inline] fn from(node: IdentPat) -> Pat { Pat::IdentPat(node) } } impl From<LiteralPat> for Pat { + #[inline] fn from(node: LiteralPat) -> Pat { Pat::LiteralPat(node) } } impl From<MacroPat> for Pat { + #[inline] fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) } } impl From<OrPat> for Pat { + #[inline] fn from(node: OrPat) -> Pat { Pat::OrPat(node) } } impl From<ParenPat> for Pat { + #[inline] fn from(node: ParenPat) -> Pat { Pat::ParenPat(node) } } impl From<PathPat> for Pat { + #[inline] fn from(node: PathPat) -> Pat { Pat::PathPat(node) } } impl From<RangePat> for Pat { + #[inline] fn from(node: RangePat) -> Pat { Pat::RangePat(node) } } impl From<RecordPat> for Pat { + #[inline] fn from(node: RecordPat) -> Pat { Pat::RecordPat(node) } } impl From<RefPat> for Pat { + #[inline] fn from(node: RefPat) -> Pat { Pat::RefPat(node) } } impl From<RestPat> for Pat { + #[inline] fn from(node: RestPat) -> Pat { Pat::RestPat(node) } } impl From<SlicePat> for Pat { + #[inline] fn from(node: SlicePat) -> Pat { Pat::SlicePat(node) } } impl From<TuplePat> for Pat { + #[inline] fn from(node: TuplePat) -> Pat { Pat::TuplePat(node) } } impl From<TupleStructPat> for Pat { + #[inline] fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) } } impl From<WildcardPat> for Pat { + #[inline] fn from(node: WildcardPat) -> Pat { Pat::WildcardPat(node) } } impl AstNode for Pat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -3948,6 +4915,7 @@ impl AstNode for Pat { | WILDCARD_PAT ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { BOX_PAT => Pat::BoxPat(BoxPat { syntax }), @@ -3970,6 +4938,7 @@ impl AstNode for Pat { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { Pat::BoxPat(it) => &it.syntax, @@ -3992,57 +4961,75 @@ impl AstNode for Pat { } } impl From<ExprStmt> for Stmt { + #[inline] fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) } } impl From<Item> for Stmt { + #[inline] fn from(node: Item) -> Stmt { Stmt::Item(node) } } impl From<LetStmt> for Stmt { + #[inline] fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) } } impl From<ArrayType> for Type { + #[inline] fn from(node: ArrayType) -> Type { Type::ArrayType(node) } } impl From<DynTraitType> for Type { + #[inline] fn from(node: DynTraitType) -> Type { Type::DynTraitType(node) } } impl From<FnPtrType> for Type { + #[inline] fn from(node: FnPtrType) -> Type { Type::FnPtrType(node) } } impl From<ForType> for Type { + #[inline] fn from(node: ForType) -> Type { Type::ForType(node) } } impl From<ImplTraitType> for Type { + #[inline] fn from(node: ImplTraitType) -> Type { Type::ImplTraitType(node) } } impl From<InferType> for Type { + #[inline] fn from(node: InferType) -> Type { Type::InferType(node) } } impl From<MacroType> for Type { + #[inline] fn from(node: MacroType) -> Type { Type::MacroType(node) } } impl From<NeverType> for Type { + #[inline] fn from(node: NeverType) -> Type { Type::NeverType(node) } } impl From<ParenType> for Type { + #[inline] fn from(node: ParenType) -> Type { Type::ParenType(node) } } impl From<PathType> for Type { + #[inline] fn from(node: PathType) -> Type { Type::PathType(node) } } impl From<PtrType> for Type { + #[inline] fn from(node: PtrType) -> Type { Type::PtrType(node) } } impl From<RefType> for Type { + #[inline] fn from(node: RefType) -> Type { Type::RefType(node) } } impl From<SliceType> for Type { + #[inline] fn from(node: SliceType) -> Type { Type::SliceType(node) } } impl From<TupleType> for Type { + #[inline] fn from(node: TupleType) -> Type { Type::TupleType(node) } } impl AstNode for Type { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -4062,6 +5049,7 @@ impl AstNode for Type { | TUPLE_TYPE ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { ARRAY_TYPE => Type::ArrayType(ArrayType { syntax }), @@ -4082,6 +5070,7 @@ impl AstNode for Type { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { Type::ArrayType(it) => &it.syntax, @@ -4108,10 +5097,13 @@ impl AnyHasArgList { } } impl AstNode for AnyHasArgList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CALL_EXPR | METHOD_CALL_EXPR) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasArgList { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasAttrs { @@ -4121,6 +5113,7 @@ impl AnyHasAttrs { } } impl AstNode for AnyHasAttrs { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -4198,9 +5191,11 @@ impl AstNode for AnyHasAttrs { | YIELD_EXPR ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasAttrs { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasDocComments { @@ -4210,6 +5205,7 @@ impl AnyHasDocComments { } } impl AstNode for AnyHasDocComments { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -4236,9 +5232,11 @@ impl AstNode for AnyHasDocComments { | VARIANT ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasDocComments { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasGenericArgs { @@ -4248,12 +5246,15 @@ impl AnyHasGenericArgs { } } impl AstNode for AnyHasGenericArgs { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ASSOC_TYPE_ARG | METHOD_CALL_EXPR | PATH_SEGMENT) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasGenericArgs { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasGenericParams { @@ -4263,12 +5264,15 @@ impl AnyHasGenericParams { } } impl AstNode for AnyHasGenericParams { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ENUM | FN | IMPL | STRUCT | TRAIT | TRAIT_ALIAS | TYPE_ALIAS | UNION) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasGenericParams { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasLoopBody { @@ -4278,10 +5282,13 @@ impl AnyHasLoopBody { } } impl AstNode for AnyHasLoopBody { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, FOR_EXPR | LOOP_EXPR | WHILE_EXPR) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasLoopBody { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasModuleItem { @@ -4291,10 +5298,13 @@ impl AnyHasModuleItem { } } impl AstNode for AnyHasModuleItem { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ITEM_LIST | MACRO_ITEMS | SOURCE_FILE) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasModuleItem { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasName { @@ -4304,6 +5314,7 @@ impl AnyHasName { } } impl AstNode for AnyHasName { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -4329,9 +5340,11 @@ impl AstNode for AnyHasName { | VARIANT ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasName { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasTypeBounds { @@ -4341,15 +5354,18 @@ impl AnyHasTypeBounds { } } impl AstNode for AnyHasTypeBounds { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, ASSOC_TYPE_ARG | LIFETIME_PARAM | TRAIT | TYPE_ALIAS | TYPE_PARAM | WHERE_PRED ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasTypeBounds { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasVisibility { @@ -4359,6 +5375,7 @@ impl AnyHasVisibility { } } impl AstNode for AnyHasVisibility { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -4382,9 +5399,11 @@ impl AstNode for AnyHasVisibility { | VARIANT ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasVisibility { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl std::fmt::Display for Adt { diff --git a/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs b/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs index 201c4cc45d9..45fa2d37c8f 100644 --- a/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs +++ b/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs @@ -122,18 +122,21 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { if field.is_many() { quote! { + #[inline] pub fn #method_name(&self) -> AstChildren<#ty> { support::children(&self.syntax) } } } else if let Some(token_kind) = field.token_kind() { quote! { + #[inline] pub fn #method_name(&self) -> Option<#ty> { support::token(&self.syntax, #token_kind) } } } else { quote! { + #[inline] pub fn #method_name(&self) -> Option<#ty> { support::child(&self.syntax) } @@ -156,12 +159,15 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { }, quote! { impl AstNode for #name { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == #kind } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } }, @@ -190,9 +196,11 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { } else { quote! { impl AstNode for #name { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, #(#kinds)|*) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { #( @@ -202,6 +210,7 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { #( @@ -226,6 +235,7 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { quote! { #( impl From<#variants> for #name { + #[inline] fn from(node: #variants) -> #name { #name::#variants(node) } @@ -270,12 +280,15 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { } } impl AstNode for #name { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, #(#kinds)|*) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(#name { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } |