Repository: rust-lang/rust-analyzer
Pull request #17555 (2024-07-07 09:19:36)

internal: Inline generated syntax methods


Patch:
diff --git a/crates/hir-def/src/body/lower.rs b/crates/hir-def/src/body/lower.rs
index faba9050fc..be7068c807 100644
--- a/crates/hir-def/src/body/lower.rs
+++ b/crates/hir-def/src/body/lower.rs
@@ -15,8 +15,8 @@ use span::AstIdMap;
 use stdx::never;
 use syntax::{
     ast::{
-        self, ArrayExprKind, AstChildren, BlockExpr, HasArgList, HasAttrs, HasLoopBody, HasName,
-        RangeItem, SlicePatComponents,
+        self, ArrayExprKind, AstChildren, BlockExpr, HasArgList, HasAttrs, HasGenericArgs,
+        HasLoopBody, HasName, RangeItem, SlicePatComponents,
     },
     AstNode, AstPtr, AstToken as _, SyntaxNodePtr,
 };
diff --git a/crates/hir-def/src/find_path.rs b/crates/hir-def/src/find_path.rs
index 9a3c049541..58a1872ef2 100644
--- a/crates/hir-def/src/find_path.rs
+++ b/crates/hir-def/src/find_path.rs
@@ -183,8 +183,6 @@ fn find_path_for_module(
             let kind = if name_already_occupied_in_type_ns {
                 cov_mark::hit!(ambiguous_crate_start);
                 PathKind::Abs
-            } else if ctx.cfg.prefer_absolute {
-                PathKind::Abs
             } else {
                 PathKind::Plain
             };
@@ -566,13 +564,7 @@ mod tests {
     /// item the `path` refers to returns that same path when called from the
     /// module the cursor is in.
     #[track_caller]
-    fn check_found_path_(
-        ra_fixture: &str,
-        path: &str,
-        prefer_prelude: bool,
-        prefer_absolute: bool,
-        expect: Expect,
-    ) {
+    fn check_found_path_(ra_fixture: &str, path: &str, prefer_prelude: bool, expect: Expect) {
         let (db, pos) = TestDB::with_position(ra_fixture);
         let module = db.module_at_position(pos);
         let parsed_path_file =
@@ -612,7 +604,7 @@ mod tests {
                 module,
                 prefix,
                 ignore_local_imports,
-                ImportPathConfig { prefer_no_std: false, prefer_prelude, prefer_absolute },
+                ImportPathConfig { prefer_no_std: false, prefer_prelude },
             );
             format_to!(
                 res,
@@ -627,15 +619,11 @@ mod tests {
     }
 
     fn check_found_path(ra_fixture: &str, path: &str, expect: Expect) {
-        check_found_path_(ra_fixture, path, false, false, expect);
+        check_found_path_(ra_fixture, path, false, expect);
     }
 
     fn check_found_path_prelude(ra_fixture: &str, path: &str, expect: Expect) {
-        check_found_path_(ra_fixture, path, true, false, expect);
-    }
-
-    fn check_found_path_absolute(ra_fixture: &str, path: &str, expect: Expect) {
-        check_found_path_(ra_fixture, path, false, true, expect);
+        check_found_path_(ra_fixture, path, true, expect);
     }
 
     #[test]
@@ -882,39 +870,6 @@ pub mod ast {
         );
     }
 
-    #[test]
-    fn partially_imported_with_prefer_absolute() {
-        cov_mark::check!(partially_imported);
-        // Similar to partially_imported test case above, but with prefer_absolute enabled.
-        // Even if the actual imported item is in external crate, if the path to that item
-        // is starting from the imported name, then the path should not start from "::".
-        // i.e. The first line in the expected output should not start from "::".
-        check_found_path_absolute(
-            r#"
-//- /main.rs crate:main deps:syntax
-
-use syntax::ast;
-$0
-
-//- /lib.rs crate:syntax
-pub mod ast {
-    pub enum ModuleItem {
-        A, B, C,
-    }
-}
-        "#,
-            "syntax::ast::ModuleItem",
-            expect![[r#"
-                Plain  (imports ✔): ast::ModuleItem
-                Plain  (imports ✖): ::syntax::ast::ModuleItem
-                ByCrate(imports ✔): crate::ast::ModuleItem
-                ByCrate(imports ✖): ::syntax::ast::ModuleItem
-                BySelf (imports ✔): self::ast::ModuleItem
-                BySelf (imports ✖): ::syntax::ast::ModuleItem
-            "#]],
-        );
-    }
-
     #[test]
     fn same_crate_reexport() {
         check_found_path(
@@ -1814,43 +1769,6 @@ pub mod foo {
         );
     }
 
-    #[test]
-    fn respects_absolute_setting() {
-        let ra_fixture = r#"
-//- /main.rs crate:main deps:krate
-$0
-//- /krate.rs crate:krate
-pub mod foo {
-    pub struct Foo;
-}
-"#;
-        check_found_path(
-            ra_fixture,
-            "krate::foo::Foo",
-            expect![[r#"
-            Plain  (imports ✔): krate::foo::Foo
-            Plain  (imports ✖): krate::foo::Foo
-            ByCrate(imports ✔): krate::foo::Foo
-            ByCrate(imports ✖): krate::foo::Foo
-            BySelf (imports ✔): krate::foo::Foo
-            BySelf (imports ✖): krate::foo::Foo
-        "#]],
-        );
-
-        check_found_path_absolute(
-            ra_fixture,
-            "krate::foo::Foo",
-            expect![[r#"
-            Plain  (imports ✔): ::krate::foo::Foo
-            Plain  (imports ✖): ::krate::foo::Foo
-            ByCrate(imports ✔): ::krate::foo::Foo
-            ByCrate(imports ✖): ::krate::foo::Foo
-            BySelf (imports ✔): ::krate::foo::Foo
-            BySelf (imports ✖): ::krate::foo::Foo
-        "#]],
-        );
-    }
-
     #[test]
     fn respect_segment_length() {
         check_found_path(
diff --git a/crates/hir-def/src/hir/type_ref.rs b/crates/hir-def/src/hir/type_ref.rs
index 741ae41c74..7272ed98ce 100644
--- a/crates/hir-def/src/hir/type_ref.rs
+++ b/crates/hir-def/src/hir/type_ref.rs
@@ -10,7 +10,7 @@ use hir_expand::{
     AstId,
 };
 use intern::Interned;
-use syntax::ast::{self, HasName, IsString};
+use syntax::ast::{self, HasGenericArgs, HasName, IsString};
 
 use crate::{
     builtin_type::{BuiltinInt, BuiltinType, BuiltinUint},
diff --git a/crates/hir-def/src/lib.rs b/crates/hir-def/src/lib.rs
index fc026a14d4..211cdd35fd 100644
--- a/crates/hir-def/src/lib.rs
+++ b/crates/hir-def/src/lib.rs
@@ -116,8 +116,6 @@ pub struct ImportPathConfig {
     pub prefer_no_std: bool,
     /// If true, prefer import paths containing a prelude module.
     pub prefer_prelude: bool,
-    /// If true, prefer abs path (starting with `::`) where it is available.
-    pub prefer_absolute: bool,
 }
 
 #[derive(Debug)]
diff --git a/crates/hir-def/src/path/lower.rs b/crates/hir-def/src/path/lower.rs
index a710c2daca..cee9e05545 100644
--- a/crates/hir-def/src/path/lower.rs
+++ b/crates/hir-def/src/path/lower.rs
@@ -9,7 +9,7 @@ use hir_expand::{
     name::{name, AsName},
 };
 use intern::Interned;
-use syntax::ast::{self, AstNode, HasTypeBounds};
+use syntax::ast::{self, AstNode, HasGenericArgs, HasTypeBounds};
 
 use crate::{
     path::{AssociatedTypeBinding, GenericArg, GenericArgs, ModPath, Path, PathKind},
diff --git a/crates/hir-ty/src/display.rs b/crates/hir-ty/src/display.rs
index 75508707e9..458970aa70 100644
--- a/crates/hir-ty/src/display.rs
+++ b/crates/hir-ty/src/display.rs
@@ -1043,11 +1043,7 @@ impl HirDisplay for Ty {
                             module_id,
                             PrefixKind::Plain,
                             false,
-                            ImportPathConfig {
-                                prefer_no_std: false,
-                                prefer_prelude: true,
-                                prefer_absolute: false,
-                            },
+                            ImportPathConfig { prefer_no_std: false, prefer_prelude: true },
                         ) {
                             write!(f, "{}", path.display(f.db.upcast()))?;
                         } else {
diff --git a/crates/ide-assists/src/assist_config.rs b/crates/ide-assists/src/assist_config.rs
index f1de6aba05..410237f9ca 100644
--- a/crates/ide-assists/src/assist_config.rs
+++ b/crates/ide-assists/src/assist_config.rs
@@ -15,7 +15,6 @@ pub struct AssistConfig {
     pub insert_use: InsertUseConfig,
     pub prefer_no_std: bool,
     pub prefer_prelude: bool,
-    pub prefer_absolute: bool,
     pub assist_emit_must_use: bool,
     pub term_search_fuel: u64,
     pub term_search_borrowck: bool,
diff --git a/crates/ide-assists/src/handlers/add_missing_match_arms.rs b/crates/ide-assists/src/handlers/add_missing_match_arms.rs
index 4eb29a2378..22a4674fd4 100644
--- a/crates/ide-assists/src/handlers/add_missing_match_arms.rs
+++ b/crates/ide-assists/src/handlers/add_missing_match_arms.rs
@@ -74,7 +74,6 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
     let cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     let module = ctx.sema.scope(expr.syntax())?.module();
diff --git a/crates/ide-assists/src/handlers/add_turbo_fish.rs b/crates/ide-assists/src/handlers/add_turbo_fish.rs
index 363aa142b2..327709b28a 100644
--- a/crates/ide-assists/src/handlers/add_turbo_fish.rs
+++ b/crates/ide-assists/src/handlers/add_turbo_fish.rs
@@ -1,7 +1,7 @@
 use either::Either;
 use ide_db::defs::{Definition, NameRefClass};
 use syntax::{
-    ast::{self, make, HasArgList},
+    ast::{self, make, HasArgList, HasGenericArgs},
     ted, AstNode,
 };
 
diff --git a/crates/ide-assists/src/handlers/auto_import.rs b/crates/ide-assists/src/handlers/auto_import.rs
index f17635972b..fe895eb259 100644
--- a/crates/ide-assists/src/handlers/auto_import.rs
+++ b/crates/ide-assists/src/handlers/auto_import.rs
@@ -93,7 +93,6 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<
     let cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     let (import_assets, syntax_under_caret) = find_importable_node(ctx)?;
diff --git a/crates/ide-assists/src/handlers/bool_to_enum.rs b/crates/ide-assists/src/handlers/bool_to_enum.rs
index f094c5c09f..0aa23ccc84 100644
--- a/crates/ide-assists/src/handlers/bool_to_enum.rs
+++ b/crates/ide-assists/src/handlers/bool_to_enum.rs
@@ -340,7 +340,6 @@ fn augment_references_with_imports(
     let cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     references
diff --git a/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs b/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
index 5459bd334c..67c72a93da 100644
--- a/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
+++ b/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs
@@ -1,7 +1,7 @@
 use ide_db::{famous_defs::FamousDefs, traits::resolve_target_trait};
 use itertools::Itertools;
 use syntax::{
-    ast::{self, make, AstNode, HasName},
+    ast::{self, make, AstNode, HasGenericArgs, HasName},
     ted,
 };
 
diff --git a/crates/ide-assists/src/handlers/convert_into_to_from.rs b/crates/ide-assists/src/handlers/convert_into_to_from.rs
index 92da2678f9..7a3055b90a 100644
--- a/crates/ide-assists/src/handlers/convert_into_to_from.rs
+++ b/crates/ide-assists/src/handlers/convert_into_to_from.rs
@@ -1,6 +1,6 @@
 use hir::ImportPathConfig;
 use ide_db::{famous_defs::FamousDefs, helpers::mod_path_to_ast, traits::resolve_target_trait};
-use syntax::ast::{self, AstNode, HasName};
+use syntax::ast::{self, AstNode, HasGenericArgs, HasName};
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
 
@@ -47,7 +47,6 @@ pub(crate) fn convert_into_to_from(acc: &mut Assists, ctx: &AssistContext<'_>) -
     let cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     let src_type_path = {
diff --git a/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs b/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs
index c55ff24ae3..241fc3b7a3 100644
--- a/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs
+++ b/crates/ide-assists/src/handlers/convert_tuple_return_type_to_struct.rs
@@ -186,7 +186,6 @@ fn augment_references_with_imports(
     let cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     references
diff --git a/crates/ide-assists/src/handlers/destructure_struct_binding.rs b/crates/ide-assists/src/handlers/destructure_struct_binding.rs
index 666e1a1496..7618871552 100644
--- a/crates/ide-assists/src/handlers/destructure_struct_binding.rs
+++ b/crates/ide-assists/src/handlers/destructure_struct_binding.rs
@@ -90,7 +90,6 @@ fn collect_data(ident_pat: ast::IdentPat, ctx: &AssistContext<'_>) -> Option<Str
     let cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     let module = ctx.sema.scope(ident_pat.syntax())?.module();
diff --git a/crates/ide-assists/src/handlers/extract_function.rs b/crates/ide-assists/src/handlers/extract_function.rs
index 20c37f9233..de447c1e33 100644
--- a/crates/ide-assists/src/handlers/extract_function.rs
+++ b/crates/ide-assists/src/handlers/extract_function.rs
@@ -216,7 +216,6 @@ pub(crate) fn extract_function(acc: &mut Assists, ctx: &AssistContext<'_>) -> Op
                         ImportPathConfig {
                             prefer_no_std: ctx.config.prefer_no_std,
                             prefer_prelude: ctx.config.prefer_prelude,
-                            prefer_absolute: ctx.config.prefer_absolute,
                         },
                     );
 
diff --git a/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
index 54323e2928..3c6d73b62e 100644
--- a/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/ide-assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -393,7 +393,6 @@ fn process_references(
                     ImportPathConfig {
                         prefer_no_std: ctx.config.prefer_no_std,
                         prefer_prelude: ctx.config.prefer_prelude,
-                        prefer_absolute: ctx.config.prefer_absolute,
                     },
                 );
                 if let Some(mut mod_path) = mod_path {
diff --git a/crates/ide-assists/src/handlers/extract_type_alias.rs b/crates/ide-assists/src/handlers/extract_type_alias.rs
index 3612eda784..dcf16e89b2 100644
--- a/crates/ide-assists/src/handlers/extract_type_alias.rs
+++ b/crates/ide-assists/src/handlers/extract_type_alias.rs
@@ -1,7 +1,7 @@
 use either::Either;
 use ide_db::syntax_helpers::node_ext::walk_ty;
 use syntax::{
-    ast::{self, edit::IndentLevel, make, AstNode, HasGenericParams, HasName},
+    ast::{self, edit::IndentLevel, make, AstNode, HasGenericArgs, HasGenericParams, HasName},
     ted,
 };
 
diff --git a/crates/ide-assists/src/handlers/generate_delegate_trait.rs b/crates/ide-assists/src/handlers/generate_delegate_trait.rs
index 19521b8a4b..78def51a4a 100644
--- a/crates/ide-assists/src/handlers/generate_delegate_trait.rs
+++ b/crates/ide-assists/src/handlers/generate_delegate_trait.rs
@@ -17,8 +17,9 @@ use syntax::{
         self,
         edit::{self, AstNodeEdit},
         edit_in_place::AttrsOwnerEdit,
-        make, AssocItem, GenericArgList, GenericParamList, HasAttrs, HasGenericParams, HasName,
-        HasTypeBounds, HasVisibility as astHasVisibility, Path, WherePred,
+        make, AssocItem, GenericArgList, GenericParamList, HasAttrs, HasGenericArgs,
+        HasGenericParams, HasName, HasTypeBounds, HasVisibility as astHasVisibility, Path,
+        WherePred,
     },
     ted::{self, Position},
     AstNode, NodeOrToken, SmolStr, SyntaxKind,
diff --git a/crates/ide-assists/src/handlers/generate_deref.rs b/crates/ide-assists/src/handlers/generate_deref.rs
index cc33439dd5..9a441fc5eb 100644
--- a/crates/ide-assists/src/handlers/generate_deref.rs
+++ b/crates/ide-assists/src/handlers/generate_deref.rs
@@ -64,7 +64,6 @@ fn generate_record_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
         ImportPathConfig {
             prefer_no_std: ctx.config.prefer_no_std,
             prefer_prelude: ctx.config.prefer_prelude,
-            prefer_absolute: ctx.config.prefer_absolute,
         },
     )?;
 
@@ -112,7 +111,6 @@ fn generate_tuple_deref(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()
         ImportPathConfig {
             prefer_no_std: ctx.config.prefer_no_std,
             prefer_prelude: ctx.config.prefer_prelude,
-            prefer_absolute: ctx.config.prefer_absolute,
         },
     )?;
 
diff --git a/crates/ide-assists/src/handlers/generate_documentation_template.rs b/crates/ide-assists/src/handlers/generate_documentation_template.rs
index 38b24fd19c..51dd488454 100644
--- a/crates/ide-assists/src/handlers/generate_documentation_template.rs
+++ b/crates/ide-assists/src/handlers/generate_documentation_template.rs
@@ -4,7 +4,7 @@ use itertools::Itertools;
 use stdx::{format_to, to_lower_snake_case};
 use syntax::{
     algo::skip_whitespace_token,
-    ast::{self, edit::IndentLevel, HasDocComments, HasName},
+    ast::{self, edit::IndentLevel, HasDocComments, HasGenericArgs, HasName},
     match_ast, AstNode, AstToken,
 };
 
diff --git a/crates/ide-assists/src/handlers/generate_new.rs b/crates/ide-assists/src/handlers/generate_new.rs
index 6056c80888..52007e0e29 100644
--- a/crates/ide-assists/src/handlers/generate_new.rs
+++ b/crates/ide-assists/src/handlers/generate_new.rs
@@ -65,7 +65,6 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
                     ImportPathConfig {
                         prefer_no_std: ctx.config.prefer_no_std,
                         prefer_prelude: ctx.config.prefer_prelude,
-                        prefer_absolute: ctx.config.prefer_absolute,
                     },
                 )?;
 
diff --git a/crates/ide-assists/src/handlers/inline_call.rs b/crates/ide-assists/src/handlers/inline_call.rs
index 88fa6dc745..8c9fe23bb0 100644
--- a/crates/ide-assists/src/handlers/inline_call.rs
+++ b/crates/ide-assists/src/handlers/inline_call.rs
@@ -15,7 +15,9 @@ use ide_db::{
 };
 use itertools::{izip, Itertools};
 use syntax::{
-    ast::{self, edit::IndentLevel, edit_in_place::Indent, HasArgList, Pat, PathExpr},
+    ast::{
+        self, edit::IndentLevel, edit_in_place::Indent, HasArgList, HasGenericArgs, Pat, PathExpr,
+    },
     ted, AstNode, NodeOrToken, SyntaxKind,
 };
 
diff --git a/crates/ide-assists/src/handlers/qualify_method_call.rs b/crates/ide-assists/src/handlers/qualify_method_call.rs
index 89e24fafc5..5d1140d57a 100644
--- a/crates/ide-assists/src/handlers/qualify_method_call.rs
+++ b/crates/ide-assists/src/handlers/qualify_method_call.rs
@@ -53,7 +53,6 @@ pub(crate) fn qualify_method_call(acc: &mut Assists, ctx: &AssistContext<'_>) ->
         ImportPathConfig {
             prefer_no_std: ctx.config.prefer_no_std,
             prefer_prelude: ctx.config.prefer_prelude,
-            prefer_absolute: ctx.config.prefer_absolute,
         },
     )?;
 
diff --git a/crates/ide-assists/src/handlers/qualify_path.rs b/crates/ide-assists/src/handlers/qualify_path.rs
index ca6c7c58b7..f64a68f384 100644
--- a/crates/ide-assists/src/handlers/qualify_path.rs
+++ b/crates/ide-assists/src/handlers/qualify_path.rs
@@ -6,6 +6,7 @@ use ide_db::{
     helpers::mod_path_to_ast,
     imports::import_assets::{ImportCandidate, LocatedImport},
 };
+use syntax::ast::HasGenericArgs;
 use syntax::{
     ast,
     ast::{make, HasArgList},
@@ -40,7 +41,6 @@ pub(crate) fn qualify_path(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
     let cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     let mut proposed_imports: Vec<_> =
diff --git a/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
index 5582256a17..e792debaa5 100644
--- a/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/ide-assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -89,7 +89,6 @@ pub(crate) fn replace_derive_with_manual_impl(
                 ImportPathConfig {
                     prefer_no_std: ctx.config.prefer_no_std,
                     prefer_prelude: ctx.config.prefer_prelude,
-                    prefer_absolute: ctx.config.prefer_absolute,
                 },
             )
             .as_ref()
diff --git a/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
index f1467837dd..a3ffdc9c53 100644
--- a/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs
@@ -4,7 +4,7 @@ use ide_db::{
     imports::insert_use::{insert_use, ImportScope},
 };
 use syntax::{
-    ast::{self, make},
+    ast::{self, make, HasGenericArgs},
     match_ast, ted, AstNode, SyntaxNode,
 };
 
@@ -70,7 +70,6 @@ pub(crate) fn replace_qualified_name_with_use(
                 ImportPathConfig {
                     prefer_no_std: ctx.config.prefer_no_std,
                     prefer_prelude: ctx.config.prefer_prelude,
-                    prefer_absolute: ctx.config.prefer_absolute,
                 },
             )
         })
diff --git a/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs b/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs
index 1794c88743..3a6391cd38 100644
--- a/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs
+++ b/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs
@@ -1,7 +1,6 @@
 use hir::HirDisplay;
 use syntax::{
-    ast::{Expr, GenericArg, GenericArgList},
-    ast::{LetStmt, Type::InferType},
+    ast::{Expr, GenericArg, GenericArgList, HasGenericArgs, LetStmt, Type::InferType},
     AstNode, TextRange,
 };
 
diff --git a/crates/ide-assists/src/handlers/term_search.rs b/crates/ide-assists/src/handlers/term_search.rs
index 7a91179975..874b42f51b 100644
--- a/crates/ide-assists/src/handlers/term_search.rs
+++ b/crates/ide-assists/src/handlers/term_search.rs
@@ -60,7 +60,6 @@ pub(crate) fn term_search(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<
                 ImportPathConfig {
                     prefer_no_std: ctx.config.prefer_no_std,
                     prefer_prelude: ctx.config.prefer_prelude,
-                    prefer_absolute: ctx.config.prefer_absolute,
                 },
             )
             .ok()
diff --git a/crates/ide-assists/src/handlers/toggle_async_sugar.rs b/crates/ide-assists/src/handlers/toggle_async_sugar.rs
index f79f87db9a..f8adb2ea08 100644
--- a/crates/ide-assists/src/handlers/toggle_async_sugar.rs
+++ b/crates/ide-assists/src/handlers/toggle_async_sugar.rs
@@ -4,7 +4,7 @@ use ide_db::{
     famous_defs::FamousDefs,
 };
 use syntax::{
-    ast::{self, HasVisibility},
+    ast::{self, HasGenericArgs, HasVisibility},
     AstNode, NodeOrToken, SyntaxKind, SyntaxNode, SyntaxToken, TextRange,
 };
 
@@ -142,7 +142,6 @@ pub(crate) fn desugar_async_into_impl_future(
         ImportPathConfig {
             prefer_no_std: ctx.config.prefer_no_std,
             prefer_prelude: ctx.config.prefer_prelude,
-            prefer_absolute: ctx.config.prefer_absolute,
         },
     )?;
     let trait_path = trait_path.display(ctx.db());
diff --git a/crates/ide-assists/src/handlers/unwrap_result_return_type.rs b/crates/ide-assists/src/handlers/unwrap_result_return_type.rs
index 8a9e669630..a1987247cb 100644
--- a/crates/ide-assists/src/handlers/unwrap_result_return_type.rs
+++ b/crates/ide-assists/src/handlers/unwrap_result_return_type.rs
@@ -4,7 +4,7 @@ use ide_db::{
 };
 use itertools::Itertools;
 use syntax::{
-    ast::{self, Expr},
+    ast::{self, Expr, HasGenericArgs},
     match_ast, AstNode, NodeOrToken, SyntaxKind, TextRange,
 };
 
diff --git a/crates/ide-completion/src/completions.rs b/crates/ide-completion/src/completions.rs
index 995a4443ed..11ffc8bc44 100644
--- a/crates/ide-completion/src/completions.rs
+++ b/crates/ide-completion/src/completions.rs
@@ -639,7 +639,6 @@ fn enum_variants_with_paths(
             ImportPathConfig {
                 prefer_no_std: ctx.config.prefer_no_std,
                 prefer_prelude: ctx.config.prefer_prelude,
-                prefer_absolute: ctx.config.prefer_absolute,
             },
         ) {
             // Variants with trivial paths are already added by the existing completion logic,
diff --git a/crates/ide-completion/src/completions/expr.rs b/crates/ide-completion/src/completions/expr.rs
index 01f9368aa4..7281c607da 100644
--- a/crates/ide-completion/src/completions/expr.rs
+++ b/crates/ide-completion/src/completions/expr.rs
@@ -177,7 +177,6 @@ pub(crate) fn complete_expr_path(
                                 ImportPathConfig {
                                     prefer_no_std: ctx.config.prefer_no_std,
                                     prefer_prelude: ctx.config.prefer_prelude,
-                                    prefer_absolute: ctx.config.prefer_absolute,
                                 },
                             )
                             .filter(|it| it.len() > 1);
@@ -203,7 +202,6 @@ pub(crate) fn complete_expr_path(
                                 ImportPathConfig {
                                     prefer_no_std: ctx.config.prefer_no_std,
                                     prefer_prelude: ctx.config.prefer_prelude,
-                                    prefer_absolute: ctx.config.prefer_absolute,
                                 },
                             )
                             .filter(|it| it.len() > 1);
diff --git a/crates/ide-completion/src/completions/flyimport.rs b/crates/ide-completion/src/completions/flyimport.rs
index 3a8b9c0cb9..71d44a57cb 100644
--- a/crates/ide-completion/src/completions/flyimport.rs
+++ b/crates/ide-completion/src/completions/flyimport.rs
@@ -259,7 +259,6 @@ fn import_on_the_fly(
     let import_cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     import_assets
@@ -310,7 +309,6 @@ fn import_on_the_fly_pat_(
     let cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     import_assets
@@ -356,7 +354,6 @@ fn import_on_the_fly_method(
     let cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     import_assets
diff --git a/crates/ide-completion/src/completions/postfix.rs b/crates/ide-completion/src/completions/postfix.rs
index d919609237..5041ef8d8a 100644
--- a/crates/ide-completion/src/completions/postfix.rs
+++ b/crates/ide-completion/src/completions/postfix.rs
@@ -63,7 +63,6 @@ pub(crate) fn complete_postfix(
     let cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     if let Some(drop_trait) = ctx.famous_defs().core_ops_Drop() {
diff --git a/crates/ide-completion/src/config.rs b/crates/ide-completion/src/config.rs
index 7d062cb23e..809c305ed8 100644
--- a/crates/ide-completion/src/config.rs
+++ b/crates/ide-completion/src/config.rs
@@ -22,7 +22,6 @@ pub struct CompletionConfig {
     pub insert_use: InsertUseConfig,
     pub prefer_no_std: bool,
     pub prefer_prelude: bool,
-    pub prefer_absolute: bool,
     pub snippets: Vec<Snippet>,
     pub limit: Option<usize>,
 }
diff --git a/crates/ide-completion/src/context/analysis.rs b/crates/ide-completion/src/context/analysis.rs
index 80dcfd2f52..a14fe24fa7 100644
--- a/crates/ide-completion/src/context/analysis.rs
+++ b/crates/ide-completion/src/context/analysis.rs
@@ -6,7 +6,10 @@ use ide_db::{active_parameter::ActiveParameter, RootDatabase};
 use itertools::Either;
 use syntax::{
     algo::{ancestors_at_offset, find_node_at_offset, non_trivia_sibling},
-    ast::{self, AttrKind, HasArgList, HasGenericParams, HasLoopBody, HasName, NameOrNameRef},
+    ast::{
+        self, AttrKind, HasArgList, HasGenericArgs, HasGenericParams, HasLoopBody, HasName,
+        NameOrNameRef,
+    },
     match_ast, AstNode, AstToken, Direction, NodeOrToken, SyntaxElement, SyntaxKind, SyntaxNode,
     SyntaxToken, TextRange, TextSize, T,
 };
diff --git a/crates/ide-completion/src/lib.rs b/crates/ide-completion/src/lib.rs
index 7d9c2c7c60..7150fe3f01 100644
--- a/crates/ide-completion/src/lib.rs
+++ b/crates/ide-completion/src/lib.rs
@@ -253,7 +253,6 @@ pub fn resolve_completion_edits(
     let cfg = ImportPathConfig {
         prefer_no_std: config.prefer_no_std,
         prefer_prelude: config.prefer_prelude,
-        prefer_absolute: config.prefer_absolute,
     };
 
     imports.into_iter().for_each(|(full_import_path, imported_name)| {
diff --git a/crates/ide-completion/src/render.rs b/crates/ide-completion/src/render.rs
index fe9e2e5268..b98f745f17 100644
--- a/crates/ide-completion/src/render.rs
+++ b/crates/ide-completion/src/render.rs
@@ -298,7 +298,6 @@ pub(crate) fn render_expr(
     let cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     let label = expr.gen_source_code(&ctx.scope, &mut label_formatter, cfg).ok()?;
diff --git a/crates/ide-completion/src/snippet.rs b/crates/ide-completion/src/snippet.rs
index 5885b74e09..07836040b4 100644
--- a/crates/ide-completion/src/snippet.rs
+++ b/crates/ide-completion/src/snippet.rs
@@ -172,7 +172,6 @@ fn import_edits(ctx: &CompletionContext<'_>, requires: &[GreenNode]) -> Option<V
     let import_cfg = ImportPathConfig {
         prefer_no_std: ctx.config.prefer_no_std,
         prefer_prelude: ctx.config.prefer_prelude,
-        prefer_absolute: ctx.config.prefer_absolute,
     };
 
     let resolve = |import: &GreenNode| {
diff --git a/crates/ide-db/src/path_transform.rs b/crates/ide-db/src/path_transform.rs
index 90c691ed6c..a36f30a645 100644
--- a/crates/ide-db/src/path_transform.rs
+++ b/crates/ide-db/src/path_transform.rs
@@ -6,7 +6,7 @@ use hir::{AsAssocItem, HirDisplay, ImportPathConfig, ModuleDef, SemanticsScope};
 use itertools::Itertools;
 use rustc_hash::FxHashMap;
 use syntax::{
-    ast::{self, make, AstNode},
+    ast::{self, make, AstNode, HasGenericArgs},
     ted, SyntaxNode,
 };
 
@@ -308,11 +308,8 @@ impl Ctx<'_> {
                             parent.segment()?.name_ref()?,
                         )
                         .and_then(|trait_ref| {
-                            let cfg = ImportPathConfig {
-                                prefer_no_std: false,
-                                prefer_prelude: true,
-                                prefer_absolute: false,
-                            };
+                            let cfg =
+                                ImportPathConfig { prefer_no_std: false, prefer_prelude: true };
                             let found_path = self.target_module.find_path(
                                 self.source_scope.db.upcast(),
                                 hir::ModuleDef::Trait(trait_ref),
@@ -351,11 +348,7 @@ impl Ctx<'_> {
                     }
                 }
 
-                let cfg = ImportPathConfig {
-                    prefer_no_std: false,
-                    prefer_prelude: true,
-                    prefer_absolute: false,
-                };
+                let cfg = ImportPathConfig { prefer_no_std: false, prefer_prelude: true };
                 let found_path =
                     self.target_module.find_path(self.source_scope.db.upcast(), def, cfg)?;
                 let res = mod_path_to_ast(&found_path).clone_for_update();
@@ -390,11 +383,7 @@ impl Ctx<'_> {
 
                 if let Some(adt) = ty.as_adt() {
                     if let ast::Type::PathType(path_ty) = &ast_ty {
-                        let cfg = ImportPathConfig {
-                            prefer_no_std: false,
-                            prefer_prelude: true,
-                            prefer_absolute: false,
-                        };
+                        let cfg = ImportPathConfig { prefer_no_std: false, prefer_prelude: true };
                         let found_path = self.target_module.find_path(
                             self.source_scope.db.upcast(),
                             ModuleDef::from(adt),
diff --git a/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs b/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs
index a9c0e3b731..2b8779044f 100644
--- a/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs
+++ b/crates/ide-diagnostics/src/handlers/json_is_not_rust.rs
@@ -146,7 +146,6 @@ pub(crate) fn json_in_items(
                         let cfg = ImportPathConfig {
                             prefer_no_std: config.prefer_no_std,
                             prefer_prelude: config.prefer_prelude,
-                            prefer_absolute: config.prefer_absolute,
                         };
 
                         if !scope_has("Serialize") {
diff --git a/crates/ide-diagnostics/src/handlers/missing_fields.rs b/crates/ide-diagnostics/src/handlers/missing_fields.rs
index 6a809cb0ce..9eff84b898 100644
--- a/crates/ide-diagnostics/src/handlers/missing_fields.rs
+++ b/crates/ide-diagnostics/src/handlers/missing_fields.rs
@@ -128,7 +128,6 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::MissingFields) -> Option<Vec<Ass
                             ImportPathConfig {
                                 prefer_no_std: ctx.config.prefer_no_std,
                                 prefer_prelude: ctx.config.prefer_prelude,
-                                prefer_absolute: ctx.config.prefer_absolute,
                             },
                         )?;
 
diff --git a/crates/ide-diagnostics/src/handlers/typed_hole.rs b/crates/ide-diagnostics/src/handlers/typed_hole.rs
index 4f04267adb..a64bac2949 100644
--- a/crates/ide-diagnostics/src/handlers/typed_hole.rs
+++ b/crates/ide-diagnostics/src/handlers/typed_hole.rs
@@ -67,7 +67,6 @@ fn fixes(ctx: &DiagnosticsContext<'_>, d: &hir::TypedHole) -> Option<Vec<Assist>
                 ImportPathConfig {
                     prefer_no_std: ctx.config.prefer_no_std,
                     prefer_prelude: ctx.config.prefer_prelude,
-                    prefer_absolute: ctx.config.prefer_absolute,
                 },
             )
             .ok()
diff --git a/crates/ide-diagnostics/src/lib.rs b/crates/ide-diagnostics/src/lib.rs
index 6d1226d65c..eb8e8e91d0 100644
--- a/crates/ide-diagnostics/src/lib.rs
+++ b/crates/ide-diagnostics/src/lib.rs
@@ -231,7 +231,6 @@ pub struct DiagnosticsConfig {
     pub insert_use: InsertUseConfig,
     pub prefer_no_std: bool,
     pub prefer_prelude: bool,
-    pub prefer_absolute: bool,
     pub term_search_fuel: u64,
     pub term_search_borrowck: bool,
 }
@@ -259,7 +258,6 @@ impl DiagnosticsConfig {
             },
             prefer_no_std: false,
             prefer_prelude: true,
-            prefer_absolute: false,
             term_search_fuel: 400,
             term_search_borrowck: true,
         }
diff --git a/crates/ide-ssr/src/matching.rs b/crates/ide-ssr/src/matching.rs
index 0d22bc94c6..9fa2ee84fd 100644
--- a/crates/ide-ssr/src/matching.rs
+++ b/crates/ide-ssr/src/matching.rs
@@ -10,7 +10,7 @@ use hir::{ImportPathConfig, Semantics};
 use ide_db::{base_db::FileRange, FxHashMap};
 use std::{cell::Cell, iter::Peekable};
 use syntax::{
-    ast::{self, AstNode, AstToken},
+    ast::{self, AstNode, AstToken, HasGenericArgs},
     SmolStr, SyntaxElement, SyntaxElementChildren, SyntaxKind, SyntaxNode, SyntaxToken,
 };
 
@@ -663,11 +663,7 @@ impl Match {
             .module();
         for (path, resolved_path) in &template.resolved_paths {
             if let hir::PathResolution::Def(module_def) = resolved_path.resolution {
-                let cfg = ImportPathConfig {
-                    prefer_no_std: false,
-                    prefer_prelude: true,
-                    prefer_absolute: false,
-                };
+                let cfg = ImportPathConfig { prefer_no_std: false, prefer_prelude: true };
                 let mod_path = module.find_path(sema.db, module_def, cfg).ok_or_else(|| {
                     match_error!("Failed to render template path `{}` at match location")
                 })?;
diff --git a/crates/ide-ssr/src/resolving.rs b/crates/ide-ssr/src/resolving.rs
index 4731f14f4e..d3c1af1f31 100644
--- a/crates/ide-ssr/src/resolving.rs
+++ b/crates/ide-ssr/src/resolving.rs
@@ -3,7 +3,10 @@
 use hir::AsAssocItem;
 use ide_db::{base_db::FilePosition, FxHashMap};
 use parsing::Placeholder;
-use syntax::{ast, SmolStr, SyntaxKind, SyntaxNode, SyntaxToken};
+use syntax::{
+    ast::{self, HasGenericArgs},
+    SmolStr, SyntaxKind, SyntaxNode, SyntaxToken,
+};
 
 use crate::{errors::error, parsing, SsrError};
 
diff --git a/crates/ide/src/inlay_hints/bind_pat.rs b/crates/ide/src/inlay_hints/bind_pat.rs
index 3311bb48ad..1118f11d99 100644
--- a/crates/ide/src/inlay_hints/bind_pat.rs
+++ b/crates/ide/src/inlay_hints/bind_pat.rs
@@ -8,7 +8,7 @@ use ide_db::{base_db::FileId, famous_defs::FamousDefs, RootDatabase};
 
 use itertools::Itertools;
 use syntax::{
-    ast::{self, AstNode, HasName},
+    ast::{self, AstNode, HasGenericArgs, HasName},
     match_ast,
 };
 
diff --git a/crates/rust-analyzer/src/cli/analysis_stats.rs b/crates/rust-analyzer/src/cli/analysis_stats.rs
index 16a880e18b..c9c19806be 100644
--- a/crates/rust-analyzer/src/cli/analysis_stats.rs
+++ b/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -439,11 +439,7 @@ impl flags::AnalysisStats {
                         .gen_source_code(
                             &scope,
                             &mut formatter,
-                            ImportPathConfig {
-                                prefer_no_std: false,
-                                prefer_prelude: true,
-                                prefer_absolute: false,
-                            },
+                            ImportPathConfig { prefer_no_std: false, prefer_prelude: true },
                         )
                         .unwrap();
                     syntax_hit_found |= trim(&original_text) == trim(&generated);
@@ -992,7 +988,6 @@ impl flags::AnalysisStats {
                     },
                     prefer_no_std: false,
                     prefer_prelude: true,
-                    prefer_absolute: false,
                     style_lints: false,
                     term_search_fuel: 400,
                     term_search_borrowck: true,
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index 94e0115862..948bc2c6c7 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -357,8 +357,6 @@ config_data! {
         imports_preferPrelude: bool                       = false,
         /// The path structure for newly inserted paths to use.
         imports_prefix: ImportPrefixDef               = ImportPrefixDef::Plain,
-        /// Whether to prefix external (including std, core) crate imports with `::`. e.g. "use ::std::io::Read;".
-        imports_prefixExternPrelude: bool = false,
     }
 }
 
@@ -1272,7 +1270,6 @@ impl Config {
             prefer_no_std: self.imports_preferNoStd(source_root).to_owned(),
             assist_emit_must_use: self.assist_emitMustUse(source_root).to_owned(),
             prefer_prelude: self.imports_preferPrelude(source_root).to_owned(),
-            prefer_absolute: self.imports_prefixExternPrelude(source_root).to_owned(),
             term_search_fuel: self.assist_termSearch_fuel(source_root).to_owned() as u64,
             term_search_borrowck: self.assist_termSearch_borrowcheck(source_root).to_owned(),
         }
@@ -1295,7 +1292,6 @@ impl Config {
             insert_use: self.insert_use_config(source_root),
             prefer_no_std: self.imports_preferNoStd(source_root).to_owned(),
             prefer_prelude: self.imports_preferPrelude(source_root).to_owned(),
-            prefer_absolute: self.imports_prefixExternPrelude(source_root).to_owned(),
             snippets: self.snippets.clone().to_vec(),
             limit: self.completion_limit().to_owned(),
             enable_term_search: self.completion_termSearch_enable().to_owned(),
@@ -1324,7 +1320,6 @@ impl Config {
             insert_use: self.insert_use_config(source_root),
             prefer_no_std: self.imports_preferNoStd(source_root).to_owned(),
             prefer_prelude: self.imports_preferPrelude(source_root).to_owned(),
-            prefer_absolute: self.imports_prefixExternPrelude(source_root).to_owned(),
             style_lints: self.diagnostics_styleLints_enable().to_owned(),
             term_search_fuel: self.assist_termSearch_fuel(source_root).to_owned() as u64,
             term_search_borrowck: self.assist_termSearch_borrowcheck(source_root).to_owned(),
diff --git a/crates/rust-analyzer/src/integrated_benchmarks.rs b/crates/rust-analyzer/src/integrated_benchmarks.rs
index ff8eb6c861..65fbc96dad 100644
--- a/crates/rust-analyzer/src/integrated_benchmarks.rs
+++ b/crates/rust-analyzer/src/integrated_benchmarks.rs
@@ -152,7 +152,6 @@ fn integrated_completion_benchmark() {
             },
             prefer_no_std: false,
             prefer_prelude: true,
-            prefer_absolute: false,
             snippets: Vec::new(),
             limit: None,
         };
@@ -198,7 +197,6 @@ fn integrated_completion_benchmark() {
             },
             prefer_no_std: false,
             prefer_prelude: true,
-            prefer_absolute: false,
             snippets: Vec::new(),
             limit: None,
         };
@@ -242,7 +240,6 @@ fn integrated_completion_benchmark() {
             },
             prefer_no_std: false,
             prefer_prelude: true,
-            prefer_absolute: false,
             snippets: Vec::new(),
             limit: None,
         };
@@ -302,7 +299,6 @@ fn integrated_diagnostics_benchmark() {
         },
         prefer_no_std: false,
         prefer_prelude: false,
-        prefer_absolute: false,
         term_search_fuel: 400,
         term_search_borrowck: true,
     };
diff --git a/crates/syntax/src/ast.rs b/crates/syntax/src/ast.rs
index 168ca9f132..3282bd6eff 100644
--- a/crates/syntax/src/ast.rs
+++ b/crates/syntax/src/ast.rs
@@ -31,8 +31,8 @@ pub use self::{
     operators::{ArithOp, BinaryOp, CmpOp, LogicOp, Ordering, RangeOp, UnaryOp},
     token_ext::{CommentKind, CommentPlacement, CommentShape, IsString, QuoteOffsets, Radix},
     traits::{
-        AttrDocCommentIter, DocCommentIter, HasArgList, HasAttrs, HasDocComments, HasGenericParams,
-        HasLoopBody, HasModuleItem, HasName, HasTypeBounds, HasVisibility,
+        AttrDocCommentIter, DocCommentIter, HasArgList, HasAttrs, HasDocComments, HasGenericArgs,
+        HasGenericParams, HasLoopBody, HasModuleItem, HasName, HasTypeBounds, HasVisibility,
     },
 };
 
@@ -149,14 +149,17 @@ pub trait RangeItem {
 mod support {
     use super::{AstChildren, AstNode, SyntaxKind, SyntaxNode, SyntaxToken};
 
+    #[inline]
     pub(super) fn child<N: AstNode>(parent: &SyntaxNode) -> Option<N> {
         parent.children().find_map(N::cast)
     }
 
+    #[inline]
     pub(super) fn children<N: AstNode>(parent: &SyntaxNode) -> AstChildren<N> {
         AstChildren::new(parent)
     }
 
+    #[inline]
     pub(super) fn token(parent: &SyntaxNode, kind: SyntaxKind) -> Option<SyntaxToken> {
         parent.children_with_tokens().filter_map(|it| it.into_token()).find(|it| it.kind() == kind)
     }
diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
index 2445e4f1a3..f1286e7aa2 100644
--- a/crates/syntax/src/ast/edit_in_place.rs
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -6,7 +6,7 @@ use parser::{SyntaxKind, T};
 
 use crate::{
     algo::{self, neighbor},
-    ast::{self, edit::IndentLevel, make, HasGenericParams},
+    ast::{self, edit::IndentLevel, make, HasGenericArgs, HasGenericParams},
     ted::{self, Position},
     AstNode, AstToken, Direction, SyntaxElement,
     SyntaxKind::{ATTR, COMMENT, WHITESPACE},
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index ce189acd68..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!['}']) }
 }
 
@@ -78,14 +100,20 @@ impl AssocItemList {
 pub struct AssocTypeArg {
     pub(crate) syntax: SyntaxNode,
 }
+impl ast::HasGenericArgs for AssocTypeArg {}
 impl ast::HasTypeBounds for AssocTypeArg {}
 impl AssocTypeArg {
+    #[inline]
     pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) }
-    pub fn generic_arg_list(&self) -> Option<GenericArgList> { 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]) }
 }
 
@@ -783,10 +1000,13 @@ pub struct MethodCallExpr {
 }
 impl ast::HasArgList for MethodCallExpr {}
 impl ast::HasAttrs for MethodCallExpr {}
+impl ast::HasGenericArgs for MethodCallExpr {}
 impl MethodCallExpr {
-    pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) }
+    #[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) }
 }
 
@@ -946,16 +1210,25 @@ impl PathPat {
 pub struct PathSegment {
     pub(crate) syntax: SyntaxNode,
 }
+impl ast::HasGenericArgs for PathSegment {}
 impl PathSegment {
-    pub fn generic_arg_list(&self) -> Option<GenericArgList> { 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 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]) }
 }
 
@@ -1763,6 +2196,12 @@ pub struct AnyHasDocComments {
 }
 impl ast::HasDocComments for AnyHasDocComments {}
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AnyHasGenericArgs {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::HasGenericArgs for AnyHasGenericArgs {}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AnyHasGenericParams {
     pub(crate) syntax: SyntaxNode,
@@ -1799,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 })
@@ -1807,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 })
@@ -1818,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 })
@@ -1829,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 })
@@ -1840,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 })
@@ -1851,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 })
@@ -1862,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 })
@@ -1873,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 })
@@ -1884,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 })
@@ -1895,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 })
@@ -1906,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 })
@@ -1917,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 })
@@ -1928,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 })
@@ -1939,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 })
@@ -1950,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 })
@@ -1961,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 })
@@ -1972,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 })
@@ -1983,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 })
@@ -1994,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 })
@@ -2005,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 })
@@ -2016,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 })
@@ -2027,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 })
@@ -2038,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 })
@@ -2049,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 })
@@ -2060,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 })
@@ -2071,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 })
@@ -2082,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 })
@@ -2093,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 })
@@ -2104,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 })
@@ -2115,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 })
@@ -2126,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 })
@@ -2137,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 })
@@ -2148,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 })
@@ -2159,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 })
@@ -2170,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 })
@@ -2181,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 })
@@ -2192,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 })
@@ -2203,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 })
@@ -2214,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 })
@@ -2225,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 })
@@ -2236,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 })
@@ -2247,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 })
@@ -2258,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 })
@@ -2269,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 })
@@ -2280,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 })
@@ -2291,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 })
@@ -2302,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 })
@@ -2313,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 })
@@ -2324,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 })
@@ -2335,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 })
@@ -2346,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 })
@@ -2357,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 })
@@ -2368,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 })
@@ -2379,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 })
@@ -2390,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 })
@@ -2401,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 })
@@ -2412,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 })
@@ -2423,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 })
@@ -2434,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 })
@@ -2445,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 })
@@ -2456,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 })
@@ -2467,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 })
@@ -2478,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 })
@@ -2489,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 })
@@ -2500,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 })
@@ -2511,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 })
@@ -2522,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 })
@@ -2533,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 })
@@ -2544,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 })
@@ -2555,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 })
@@ -2566,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 })
@@ -2577,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 })
@@ -2588,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 })
@@ -2599,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 })
@@ -2610,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 })
@@ -2621,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 })
@@ -2632,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 })
@@ -2643,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 })
@@ -2654,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 })
@@ -2665,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 })
@@ -2676,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 })
@@ -2687,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 })
@@ -2698,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 })
@@ -2709,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 })
@@ -2720,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 })
@@ -2731,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 })
@@ -2742,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 })
@@ -2753,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 })
@@ -2764,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 })
@@ -2775,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 })
@@ -2786,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 })
@@ -2797,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 })
@@ -2808,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 })
@@ -2819,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 })
@@ -2830,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 })
@@ -2841,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 })
@@ -2852,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 })
@@ -2863,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 })
@@ -2874,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 })
@@ -2885,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 })
@@ -2896,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 })
@@ -2907,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 })
@@ -2918,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 })
@@ -2929,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 })
@@ -2940,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 })
@@ -2951,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 })
@@ -2962,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 })
@@ -2973,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 })
@@ -2984,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 })
@@ -2995,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 })
@@ -3006,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 })
@@ -3017,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 })
@@ -3028,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 })
@@ -3039,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 })
@@ -3050,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 })
@@ -3061,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 })
@@ -3072,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 })
@@ -3083,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 })
@@ -3094,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 })
@@ -3105,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 })
@@ -3116,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 })
@@ -3127,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 })
@@ -3138,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 })
@@ -3149,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 })
@@ -3160,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 })
@@ -3171,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 })
@@ -3182,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 })
@@ -3193,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 })
@@ -3204,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 })
@@ -3215,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 })
@@ -3226,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 })
@@ -3237,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 })
@@ -3248,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 })
@@ -3259,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 })
@@ -3270,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 })
@@ -3281,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 })
@@ -3292,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 })
@@ -3303,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 })
@@ -3314,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 })
@@ -3325,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 })
@@ -3336,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 }),
@@ -3358,6 +4222,7 @@ impl AstNode for Adt {
         };
         Some(res)
     }
+    #[inline]
     fn syntax(&self) -> &SyntaxNode {
         match self {
             Adt::Enum(it) => &it.syntax,
@@ -3367,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 }),
@@ -3390,6 +4261,7 @@ impl AstNode for AssocItem {
         };
         Some(res)
     }
+    #[inline]
     fn syntax(&self) -> &SyntaxNode {
         match self {
             AssocItem::Const(it) => &it.syntax,
@@ -3400,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,
@@ -3549,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 }),
@@ -3591,6 +4501,7 @@ impl AstNode for Expr {
         };
         Some(res)
     }
+    #[inline]
     fn syntax(&self) -> &SyntaxNode {
         match self {
             Expr::ArrayExpr(it) => &it.syntax,
@@ -3633,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 }),
@@ -3656,6 +4573,7 @@ impl AstNode for ExternItem {
         };
         Some(res)
     }
+    #[inline]
     fn syntax(&self) -> &SyntaxNode {
         match self {
             ExternItem::Fn(it) => &it.syntax,
@@ -3666,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 }),
@@ -3681,6 +4603,7 @@ impl AstNode for FieldList {
         };
         Some(res)
     }
+    #[inline]
     fn syntax(&self) -> &SyntaxNode {
         match self {
             FieldList::RecordFieldList(it) => &it.syntax,
@@ -3689,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 }),
@@ -3714,6 +4643,7 @@ impl AstNode for GenericArg {
         };
         Some(res)
     }
+    #[inline]
     fn syntax(&self) -> &SyntaxNode {
         match self {
             GenericArg::AssocTypeArg(it) => &it.syntax,
@@ -3724,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 }),
@@ -3745,6 +4680,7 @@ impl AstNode for GenericParam {
         };
         Some(res)
     }
+    #[inline]
     fn syntax(&self) -> &SyntaxNode {
         match self {
             GenericParam::ConstParam(it) => &it.syntax,
@@ -3754,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,
@@ -3827,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 }),
@@ -3850,6 +4805,7 @@ impl AstNode for Item {
         };
         Some(res)
     }
+    #[inline]
     fn syntax(&self) -> &SyntaxNode {
         match self {
             Item::Const(it) => &it.syntax,
@@ -3873,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,
@@ -3942,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 }),
@@ -3964,6 +4938,7 @@ impl AstNode for Pat {
         };
         Some(res)
     }
+    #[inline]
     fn syntax(&self) -> &SyntaxNode {
         match self {
             Pat::BoxPat(it) => &it.syntax,
@@ -3986,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,
@@ -4056,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 }),
@@ -4076,6 +5070,7 @@ impl AstNode for Type {
         };
         Some(res)
     }
+    #[inline]
     fn syntax(&self) -> &SyntaxNode {
         match self {
             Type::ArrayType(it) => &it.syntax,
@@ -4102,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 {
@@ -4115,6 +5113,7 @@ impl AnyHasAttrs {
     }
 }
 impl AstNode for AnyHasAttrs {
+    #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
         matches!(
             kind,
@@ -4192,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 {
@@ -4204,6 +5205,7 @@ impl AnyHasDocComments {
     }
 }
 impl AstNode for AnyHasDocComments {
+    #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
         matches!(
             kind,
@@ -4230,9 +5232,29 @@ 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 {
+    #[inline]
+    pub fn new<T: ast::HasGenericArgs>(node: T) -> AnyHasGenericArgs {
+        AnyHasGenericArgs { syntax: node.syntax().clone() }
+    }
+}
+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 {
@@ -4242,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 {
@@ -4257,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 {
@@ -4270,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 {
@@ -4283,6 +5314,7 @@ impl AnyHasName {
     }
 }
 impl AstNode for AnyHasName {
+    #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
         matches!(
             kind,
@@ -4308,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 {
@@ -4320,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 {
@@ -4338,6 +5375,7 @@ impl AnyHasVisibility {
     }
 }
 impl AstNode for AnyHasVisibility {
+    #[inline]
     fn can_cast(kind: SyntaxKind) -> bool {
         matches!(
             kind,
@@ -4361,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/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index b0fbe7101c..911e3d823d 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -10,7 +10,10 @@ use parser::SyntaxKind;
 use rowan::{GreenNodeData, GreenTokenData};
 
 use crate::{
-    ast::{self, support, AstNode, AstToken, HasAttrs, HasGenericParams, HasName, SyntaxNode},
+    ast::{
+        self, support, AstNode, AstToken, HasAttrs, HasGenericArgs, HasGenericParams, HasName,
+        SyntaxNode,
+    },
     ted, NodeOrToken, SmolStr, SyntaxElement, SyntaxToken, TokenText, T,
 };
 
diff --git a/crates/syntax/src/ast/traits.rs b/crates/syntax/src/ast/traits.rs
index 16f7356b1e..152b0cb98c 100644
--- a/crates/syntax/src/ast/traits.rs
+++ b/crates/syntax/src/ast/traits.rs
@@ -52,6 +52,11 @@ pub trait HasGenericParams: AstNode {
         support::child(self.syntax())
     }
 }
+pub trait HasGenericArgs: AstNode {
+    fn generic_arg_list(&self) -> Option<ast::GenericArgList> {
+        support::child(self.syntax())
+    }
+}
 
 pub trait HasTypeBounds: AstNode {
     fn type_bound_list(&self) -> Option<ast::TypeBoundList> {
diff --git a/docs/user/generated_config.adoc b/docs/user/generated_config.adoc
index a95c897991..ea86d21e47 100644
--- a/docs/user/generated_config.adoc
+++ b/docs/user/generated_config.adoc
@@ -594,11 +594,6 @@ Whether to prefer import paths containing a `prelude` module.
 --
 The path structure for newly inserted paths to use.
 --
-[[rust-analyzer.imports.prefixExternPrelude]]rust-analyzer.imports.prefixExternPrelude (default: `false`)::
-+
---
-Whether to prefix external (including std, core) crate imports with `::`. e.g. "use ::std::io::Read;".
---
 [[rust-analyzer.inlayHints.bindingModeHints.enable]]rust-analyzer.inlayHints.bindingModeHints.enable (default: `false`)::
 +
 --
diff --git a/editors/code/package.json b/editors/code/package.json
index 1fec6f621d..8d272246f0 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -1734,16 +1734,6 @@
                     }
                 }
             },
-            {
-                "title": "imports",
-                "properties": {
-                    "rust-analyzer.imports.prefixExternPrelude": {
-                        "markdownDescription": "Whether to prefix external (including std, core) crate imports with `::`. e.g. \"use ::std::io::Read;\".",
-                        "default": false,
-                        "type": "boolean"
-                    }
-                }
-            },
             {
                 "title": "inlayHints",
                 "properties": {
diff --git a/xtask/src/codegen/grammar.rs b/xtask/src/codegen/grammar.rs
index 2d492f79f1..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
                         }
@@ -797,20 +810,21 @@ fn extract_enums(ast: &mut AstSrc) {
     }
 }
 
-fn extract_struct_traits(ast: &mut AstSrc) {
-    let traits: &[(&str, &[&str])] = &[
-        ("HasAttrs", &["attrs"]),
-        ("HasName", &["name"]),
-        ("HasVisibility", &["visibility"]),
-        ("HasGenericParams", &["generic_param_list", "where_clause"]),
-        ("HasTypeBounds", &["type_bound_list", "colon_token"]),
-        ("HasModuleItem", &["items"]),
-        ("HasLoopBody", &["label", "loop_body"]),
-        ("HasArgList", &["arg_list"]),
-    ];
+const TRAITS: &[(&str, &[&str])] = &[
+    ("HasAttrs", &["attrs"]),
+    ("HasName", &["name"]),
+    ("HasVisibility", &["visibility"]),
+    ("HasGenericParams", &["generic_param_list", "where_clause"]),
+    ("HasGenericArgs", &["generic_arg_list"]),
+    ("HasTypeBounds", &["type_bound_list", "colon_token"]),
+    ("HasModuleItem", &["items"]),
+    ("HasLoopBody", &["label", "loop_body"]),
+    ("HasArgList", &["arg_list"]),
+];
 
+fn extract_struct_traits(ast: &mut AstSrc) {
     for node in &mut ast.nodes {
-        for (name, methods) in traits {
+        for (name, methods) in TRAITS {
             extract_struct_trait(node, name, methods);
         }
     }


Test patch:
diff --git a/crates/ide-assists/src/tests.rs b/crates/ide-assists/src/tests.rs
index 2dcfda334b..bd10b5481b 100644
--- a/crates/ide-assists/src/tests.rs
+++ b/crates/ide-assists/src/tests.rs
@@ -30,7 +30,6 @@ pub(crate) const TEST_CONFIG: AssistConfig = AssistConfig {
     },
     prefer_no_std: false,
     prefer_prelude: true,
-    prefer_absolute: false,
     assist_emit_must_use: false,
     term_search_fuel: 400,
     term_search_borrowck: true,
@@ -48,7 +47,6 @@ pub(crate) const TEST_CONFIG_NO_SNIPPET_CAP: AssistConfig = AssistConfig {
     },
     prefer_no_std: false,
     prefer_prelude: true,
-    prefer_absolute: false,
     assist_emit_must_use: false,
     term_search_fuel: 400,
     term_search_borrowck: true,
@@ -66,7 +64,6 @@ pub(crate) const TEST_CONFIG_IMPORT_ONE: AssistConfig = AssistConfig {
     },
     prefer_no_std: false,
     prefer_prelude: true,
-    prefer_absolute: false,
     assist_emit_must_use: false,
     term_search_fuel: 400,
     term_search_borrowck: true,
diff --git a/crates/ide-completion/src/tests.rs b/crates/ide-completion/src/tests.rs
index fcac6c7ce7..c1a67315b7 100644
--- a/crates/ide-completion/src/tests.rs
+++ b/crates/ide-completion/src/tests.rs
@@ -79,7 +79,6 @@ pub(crate) const TEST_CONFIG: CompletionConfig = CompletionConfig {
     },
     prefer_no_std: false,
     prefer_prelude: true,
-    prefer_absolute: false,
     snippets: Vec::new(),
     limit: None,
 };
diff --git a/crates/ide-completion/src/tests/flyimport.rs b/crates/ide-completion/src/tests/flyimport.rs
index 7d9c1ed98a..abffa73c3b 100644
--- a/crates/ide-completion/src/tests/flyimport.rs
+++ b/crates/ide-completion/src/tests/flyimport.rs
@@ -870,38 +870,6 @@ fn main() {
     );
 }
 
-#[test]
-fn config_prefer_absolute() {
-    let fixture = r#"
-//- /lib.rs crate:dep
-pub mod foo {
-    pub mod bar {
-        pub struct Item;
-    }
-}
-
-//- /main.rs crate:main deps:dep
-use ::dep::foo::bar;
-
-fn main() {
-    Ite$0
-}"#;
-    let mut config = TEST_CONFIG;
-    config.prefer_absolute = true;
-
-    check_edit_with_config(
-        config.clone(),
-        "Item",
-        fixture,
-        r#"
-use ::dep::foo::bar::{self, Item};
-
-fn main() {
-    Item
-}"#,
-    );
-}
-
 #[test]
 fn unresolved_qualifier() {
     let fixture = r#"
diff --git a/crates/ide-db/src/imports/insert_use/tests.rs b/crates/ide-db/src/imports/insert_use/tests.rs
index 81604b5527..9d1f1cc09c 100644
--- a/crates/ide-db/src/imports/insert_use/tests.rs
+++ b/crates/ide-db/src/imports/insert_use/tests.rs
@@ -1222,26 +1222,6 @@ use self::foo::{self, Bar, Foo};
     );
 }
 
-#[test]
-fn insert_with_double_colon_prefixed_import_merge() {
-    check_with_config(
-        "use ::ext::foo::Foo",
-        r#"
-use ::ext::foo::Foo as _;
-"#,
-        r#"
-use ::ext::foo::Foo;
-"#,
-        &InsertUseConfig {
-            granularity: ImportGranularity::Crate,
-            prefix_kind: hir::PrefixKind::BySelf,
-            enforce_granularity: true,
-            group: true,
-            skip_glob_imports: true,
-        },
-    );
-}
-
 fn check_with_config(
     path: &str,
     ra_fixture_before: &str,