diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index 0d01e0e73c..0373e7c552 100644
--- a/crates/syntax/src/ast/generated/nodes.rs
+++ b/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/xtask/src/codegen/grammar.rs b/xtask/src/codegen/grammar.rs
index 201c4cc45d..45fa2d37c8 100644
--- a/xtask/src/codegen/grammar.rs
+++ b/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
                         }