Merge remote-tracking branch 'upstream/master' into 503-hover-doc-links

Hasn't fixed tests yet.

300 files changed, 2258 insertions, 3592 deletions

diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index 49696ce75..fc4d7aa04 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 [dependencies]
 itertools = "0.9.0"
 rowan = "0.10.0"
-rustc_lexer = { version = "666.0.0", package = "rustc-ap-rustc_lexer" }
+rustc_lexer = { version = "671.0.0", package = "rustc-ap-rustc_lexer" }
 rustc-hash = "1.1.0"
 arrayvec = "0.5.1"
 once_cell = "1.3.1"
@@ -31,4 +31,6 @@ serde = { version = "1.0.106", features = ["derive"] }
 
 [dev-dependencies]
 test_utils = { path = "../test_utils" }
+expect = { path = "../expect" }
 walkdir = "2.3.1"
+rayon = "1"
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 9d02aeef3..fd426ece9 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -2,9 +2,9 @@
 
 mod generated;
 mod traits;
-mod tokens;
-mod extensions;
-mod expr_extensions;
+mod token_ext;
+mod node_ext;
+mod expr_ext;
 pub mod edit;
 pub mod make;
 
@@ -16,13 +16,13 @@ use crate::{
 };
 
 pub use self::{
-    expr_extensions::{ArrayExprKind, BinOp, Effect, ElseBranch, LiteralKind, PrefixOp, RangeOp},
-    extensions::{
+    expr_ext::{ArrayExprKind, BinOp, Effect, ElseBranch, LiteralKind, PrefixOp, RangeOp},
+    generated::{nodes::*, tokens::*},
+    node_ext::{
         AttrKind, FieldKind, NameOrNameRef, PathSegmentKind, SelfParamKind, SlicePatComponents,
         StructKind, TypeBoundKind, VisibilityKind,
     },
-    generated::{nodes::*, tokens::*},
-    tokens::*,
+    token_ext::*,
     traits::*,
 };
 
@@ -139,7 +139,7 @@ fn test_doc_comment_of_statics() {
     )
     .ok()
     .unwrap();
-    let st = file.syntax().descendants().find_map(StaticDef::cast).unwrap();
+    let st = file.syntax().descendants().find_map(Static::cast).unwrap();
     assert_eq!("Number of levels", st.doc_comment_text().unwrap());
 }
 
@@ -235,7 +235,7 @@ fn test_comments_preserve_trailing_whitespace() {
     )
     .ok()
     .unwrap();
-    let def = file.syntax().descendants().find_map(StructDef::cast).unwrap();
+    let def = file.syntax().descendants().find_map(Struct::cast).unwrap();
     assert_eq!(
         "Representation of a Realm.   \nIn the specification these are called Realm Records.",
         def.doc_comment_text().unwrap()
@@ -286,7 +286,7 @@ where
     let mut bounds = pred.type_bound_list().unwrap().bounds();
 
     assert!(pred.for_token().is_none());
-    assert!(pred.type_param_list().is_none());
+    assert!(pred.generic_param_list().is_none());
     assert_eq!("T", pred.type_ref().unwrap().syntax().text().to_string());
     assert_bound("Clone", bounds.next());
     assert_bound("Copy", bounds.next());
@@ -325,7 +325,7 @@ where
     let mut bounds = pred.type_bound_list().unwrap().bounds();
 
     assert!(pred.for_token().is_some());
-    assert_eq!("<'a>", pred.type_param_list().unwrap().syntax().text().to_string());
+    assert_eq!("<'a>", pred.generic_param_list().unwrap().syntax().text().to_string());
     assert_eq!("F", pred.type_ref().unwrap().syntax().text().to_string());
     assert_bound("Fn(&'a str)", bounds.next());
 }
diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs
index 2ef173a03..8d3e42f25 100644
--- a/crates/ra_syntax/src/ast/edit.rs
+++ b/crates/ra_syntax/src/ast/edit.rs
@@ -29,9 +29,9 @@ impl ast::BinExpr {
     }
 }
 
-impl ast::FnDef {
+impl ast::Fn {
     #[must_use]
-    pub fn with_body(&self, body: ast::BlockExpr) -> ast::FnDef {
+    pub fn with_body(&self, body: ast::BlockExpr) -> ast::Fn {
         let mut to_insert: ArrayVec<[SyntaxElement; 2]> = ArrayVec::new();
         let old_body_or_semi: SyntaxElement = if let Some(old_body) = self.body() {
             old_body.syntax().clone().into()
@@ -80,9 +80,12 @@ where
     }
 }
 
-impl ast::ItemList {
+impl ast::AssocItemList {
     #[must_use]
-    pub fn append_items(&self, items: impl IntoIterator<Item = ast::AssocItem>) -> ast::ItemList {
+    pub fn append_items(
+        &self,
+        items: impl IntoIterator<Item = ast::AssocItem>,
+    ) -> ast::AssocItemList {
         let mut res = self.clone();
         if !self.syntax().text().contains_char('\n') {
             res = make_multiline(res);
@@ -92,7 +95,7 @@ impl ast::ItemList {
     }
 
     #[must_use]
-    pub fn append_item(&self, item: ast::AssocItem) -> ast::ItemList {
+    pub fn append_item(&self, item: ast::AssocItem) -> ast::AssocItemList {
         let (indent, position) = match self.assoc_items().last() {
             Some(it) => (
                 leading_indent(it.syntax()).unwrap_or_default().to_string(),
@@ -113,18 +116,18 @@ impl ast::ItemList {
     }
 }
 
-impl ast::RecordFieldList {
+impl ast::RecordExprFieldList {
     #[must_use]
-    pub fn append_field(&self, field: &ast::RecordField) -> ast::RecordFieldList {
+    pub fn append_field(&self, field: &ast::RecordExprField) -> ast::RecordExprFieldList {
         self.insert_field(InsertPosition::Last, field)
     }
 
     #[must_use]
     pub fn insert_field(
         &self,
-        position: InsertPosition<&'_ ast::RecordField>,
-        field: &ast::RecordField,
-    ) -> ast::RecordFieldList {
+        position: InsertPosition<&'_ ast::RecordExprField>,
+        field: &ast::RecordExprField,
+    ) -> ast::RecordExprFieldList {
         let is_multiline = self.syntax().text().contains_char('\n');
         let ws;
         let space = if is_multiline {
@@ -189,6 +192,21 @@ impl ast::RecordFieldList {
     }
 }
 
+impl ast::TypeAlias {
+    #[must_use]
+    pub fn remove_bounds(&self) -> ast::TypeAlias {
+        let colon = match self.colon_token() {
+            Some(it) => it,
+            None => return self.clone(),
+        };
+        let end = match self.type_bound_list() {
+            Some(it) => it.syntax().clone().into(),
+            None => colon.clone().into(),
+        };
+        self.replace_children(colon.into()..=end, iter::empty())
+    }
+}
+
 impl ast::TypeParam {
     #[must_use]
     pub fn remove_bounds(&self) -> ast::TypeParam {
@@ -244,9 +262,9 @@ impl ast::PathSegment {
     }
 }
 
-impl ast::UseItem {
+impl ast::Use {
     #[must_use]
-    pub fn with_use_tree(&self, use_tree: ast::UseTree) -> ast::UseItem {
+    pub fn with_use_tree(&self, use_tree: ast::UseTree) -> ast::Use {
         if let Some(old) = self.use_tree() {
             return self.replace_descendant(old, use_tree);
         }
@@ -300,9 +318,9 @@ impl ast::UseTree {
             None => return self.clone(),
         };
         let use_tree = make::use_tree(
-            suffix.clone(),
+            suffix,
             self.use_tree_list(),
-            self.alias(),
+            self.rename(),
             self.star_token().is_some(),
         );
         let nested = make::use_tree_list(iter::once(use_tree));
diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_ext.rs
index db5438d68..f5ba87223 100644
--- a/crates/ra_syntax/src/ast/expr_extensions.rs
+++ b/crates/ra_syntax/src/ast/expr_ext.rs
@@ -7,6 +7,8 @@ use crate::{
     SyntaxToken, T,
 };
 
+impl ast::AttrsOwner for ast::Expr {}
+
 impl ast::Expr {
     pub fn is_block_like(&self) -> bool {
         match self {
@@ -331,13 +333,12 @@ impl ast::Literal {
 
         match token.kind() {
             INT_NUMBER => {
-                // FYI: there was a bug here previously, thus an if statement bellow is necessary.
+                // FYI: there was a bug here previously, thus the if statement below is necessary.
                 // The lexer treats e.g. `1f64` as an integer literal. See
                 // https://github.com/rust-analyzer/rust-analyzer/issues/1592
                 // and the comments on the linked PR.
 
                 let text = token.text();
-
                 if let suffix @ Some(_) = Self::find_suffix(&text, &FLOAT_SUFFIXES) {
                     LiteralKind::FloatNumber { suffix }
                 } else {
@@ -399,7 +400,7 @@ impl ast::BlockExpr {
             Some(it) => it,
             None => return true,
         };
-        !matches!(parent.kind(), FN_DEF | IF_EXPR | WHILE_EXPR | LOOP_EXPR | EFFECT_EXPR)
+        !matches!(parent.kind(), FN | IF_EXPR | WHILE_EXPR | LOOP_EXPR | EFFECT_EXPR)
     }
 }
 
@@ -410,8 +411,8 @@ fn test_literal_with_attr() {
     assert_eq!(lit.token().text(), r#""Hello""#);
 }
 
-impl ast::RecordField {
-    pub fn parent_record_lit(&self) -> ast::RecordLit {
-        self.syntax().ancestors().find_map(ast::RecordLit::cast).unwrap()
+impl ast::RecordExprField {
+    pub fn parent_record_lit(&self) -> ast::RecordExpr {
+        self.syntax().ancestors().find_map(ast::RecordExpr::cast).unwrap()
     }
 }
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 58141da11..4306efe13 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -5,557 +5,529 @@ use crate::{
     SyntaxKind::{self, *},
     SyntaxNode, SyntaxToken, T,
 };
-/// The entire Rust source file. Includes all top-level inner attributes and module items.
-///
-/// [Reference](https://doc.rust-lang.org/reference/crates-and-source-files.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SourceFile {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::ModuleItemOwner for SourceFile {}
 impl ast::AttrsOwner for SourceFile {}
-impl ast::DocCommentsOwner for SourceFile {}
+impl ast::ModuleItemOwner for SourceFile {}
 impl SourceFile {
-    pub fn modules(&self) -> AstChildren<Module> { support::children(&self.syntax) }
-}
-/// Function definition either with body or not.
-/// Includes all of its attributes and doc comments.
-///
-/// ```
-/// ❰
-///     /// Docs
-///     #[attr]
-///     pub extern "C" fn foo<T>(#[attr] Patern {p}: Pattern) -> u32
-///     where
-///         T: Debug
-///     {
-///         42
-///     }
-/// ❱
-///
-/// extern "C" {
-///     ❰ fn fn_decl(also_variadic_ffi: u32, ...) -> u32; ❱
-/// }
-/// ```
-///
-/// - [Reference](https://doc.rust-lang.org/reference/items/functions.html)
-/// - [Nomicon](https://doc.rust-lang.org/nomicon/ffi.html#variadic-functions)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct FnDef {
+    pub fn shebang_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![shebang]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Attr {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for FnDef {}
-impl ast::NameOwner for FnDef {}
-impl ast::TypeParamsOwner for FnDef {}
-impl ast::DocCommentsOwner for FnDef {}
-impl ast::AttrsOwner for FnDef {}
-impl FnDef {
-    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
+impl Attr {
+    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
+    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
+    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
+    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
+    pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
+    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
+    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Const {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for Const {}
+impl ast::NameOwner for Const {}
+impl ast::VisibilityOwner for Const {}
+impl Const {
+    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
+    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
+    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
+    pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Enum {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for Enum {}
+impl ast::NameOwner for Enum {}
+impl ast::VisibilityOwner for Enum {}
+impl ast::GenericParamsOwner for Enum {}
+impl Enum {
+    pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) }
+    pub fn variant_list(&self) -> Option<VariantList> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExternBlock {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for ExternBlock {}
+impl ExternBlock {
+    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
+    pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExternCrate {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for ExternCrate {}
+impl ast::VisibilityOwner for ExternCrate {}
+impl ExternCrate {
+    pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
+    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
+    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
+    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
+    pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
+    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Fn {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for Fn {}
+impl ast::NameOwner for Fn {}
+impl ast::VisibilityOwner for Fn {}
+impl ast::GenericParamsOwner for Fn {}
+impl Fn {
     pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
     pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
+    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
     pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
+    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
     pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) }
     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
     pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
-/// Return type annotation.
-///
-/// ```
-/// fn foo(a: u32) ❰ -> Option<u32> ❱ { Some(a) }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RetType {
+pub struct Impl {
     pub(crate) syntax: SyntaxNode,
 }
-impl RetType {
-    pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
+impl ast::AttrsOwner for Impl {}
+impl ast::VisibilityOwner for Impl {}
+impl ast::GenericParamsOwner for Impl {}
+impl Impl {
+    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
+    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
+    pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
+    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
+    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
+    pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MacroCall {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for MacroCall {}
+impl ast::NameOwner for MacroCall {}
+impl MacroCall {
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
+    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
+    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
+    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Module {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for Module {}
+impl ast::NameOwner for Module {}
+impl ast::VisibilityOwner for Module {}
+impl Module {
+    pub fn mod_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mod]) }
+    pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
+    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Static {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for Static {}
+impl ast::NameOwner for Static {}
+impl ast::VisibilityOwner for Static {}
+impl Static {
+    pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
+    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
+    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
+    pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
-/// Struct definition.
-/// Includes all of its attributes and doc comments.
-///
-/// ```
-/// ❰
-///     /// Docs
-///     #[attr]
-///     struct Foo<T> where T: Debug {
-///         /// Docs
-///         #[attr]
-///         pub a: u32,
-///         b: T,
-///     }
-/// ❱
-///
-/// ❰ struct Foo; ❱
-/// ❰ struct Foo<T>(#[attr] T) where T: Debug; ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct StructDef {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Struct {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for StructDef {}
-impl ast::NameOwner for StructDef {}
-impl ast::TypeParamsOwner for StructDef {}
-impl ast::AttrsOwner for StructDef {}
-impl ast::DocCommentsOwner for StructDef {}
-impl StructDef {
+impl ast::AttrsOwner for Struct {}
+impl ast::NameOwner for Struct {}
+impl ast::VisibilityOwner for Struct {}
+impl ast::GenericParamsOwner for Struct {}
+impl Struct {
     pub fn struct_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![struct]) }
-    pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+    pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
 }
-/// Union definition.
-/// Includes all of its attributes and doc comments.
-///
-/// ```
-/// ❰
-///     /// Docs
-///     #[attr]
-///     pub union Foo<T> where T: Debug {
-///         /// Docs
-///         #[attr]
-///         a: T,
-///         b: u32,
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/unions.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UnionDef {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Trait {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for Trait {}
+impl ast::NameOwner for Trait {}
+impl ast::VisibilityOwner for Trait {}
+impl ast::GenericParamsOwner for Trait {}
+impl ast::TypeBoundsOwner for Trait {}
+impl Trait {
+    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
+    pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }
+    pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
+    pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TypeAlias {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for UnionDef {}
-impl ast::NameOwner for UnionDef {}
-impl ast::TypeParamsOwner for UnionDef {}
-impl ast::AttrsOwner for UnionDef {}
-impl ast::DocCommentsOwner for UnionDef {}
-impl UnionDef {
+impl ast::AttrsOwner for TypeAlias {}
+impl ast::NameOwner for TypeAlias {}
+impl ast::VisibilityOwner for TypeAlias {}
+impl ast::GenericParamsOwner for TypeAlias {}
+impl ast::TypeBoundsOwner for TypeAlias {}
+impl TypeAlias {
+    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
+    pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }
+    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Union {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for Union {}
+impl ast::NameOwner for Union {}
+impl ast::VisibilityOwner for Union {}
+impl ast::GenericParamsOwner for Union {}
+impl Union {
     pub fn union_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![union]) }
-    pub fn record_field_def_list(&self) -> Option<RecordFieldDefList> {
-        support::child(&self.syntax)
-    }
+    pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Use {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for Use {}
+impl ast::VisibilityOwner for Use {}
+impl Use {
+    pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }
+    pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
+    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Visibility {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Visibility {
+    pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) }
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
+    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
+    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
+    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
+    pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Name {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Name {
+    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ItemList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for ItemList {}
+impl ast::ModuleItemOwner for ItemList {}
+impl ItemList {
+    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
+    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NameRef {
+    pub(crate) syntax: SyntaxNode,
 }
-/// Record field definition list including enclosing curly braces.
-///
-/// ```
-/// struct Foo // same for union
-/// ❰
-///     {
-///         a: u32,
-///         b: bool,
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordFieldDefList {
+impl NameRef {
+    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Rename {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::NameOwner for Rename {}
+impl Rename {
+    pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
+    pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct UseTree {
+    pub(crate) syntax: SyntaxNode,
+}
+impl UseTree {
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
+    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
+    pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
+    pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
+    pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Path {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Path {
+    pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) }
+    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
+    pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct UseTreeList {
     pub(crate) syntax: SyntaxNode,
 }
-impl RecordFieldDefList {
+impl UseTreeList {
     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
-    pub fn fields(&self) -> AstChildren<RecordFieldDef> { support::children(&self.syntax) }
+    pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) }
     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 }
-/// Record field definition including its attributes and doc comments.
-///
-/// ` ``
-/// same for union
-/// struct Foo {
-///      ❰
-///          /// Docs
-///          #[attr]
-///          pub a: u32
-///      ❱
-///
-///      ❰ b: bool ❱
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordFieldDef {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Abi {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for RecordFieldDef {}
-impl ast::NameOwner for RecordFieldDef {}
-impl ast::AttrsOwner for RecordFieldDef {}
-impl ast::DocCommentsOwner for RecordFieldDef {}
-impl ast::TypeAscriptionOwner for RecordFieldDef {}
-impl RecordFieldDef {}
-/// Tuple field definition list including enclosing parens.
-///
-/// ```
-/// struct Foo ❰ (u32, String, Vec<u32>) ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TupleFieldDefList {
+impl Abi {
+    pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct GenericParamList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl GenericParamList {
+    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
+    pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
+    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParamList {
     pub(crate) syntax: SyntaxNode,
 }
-impl TupleFieldDefList {
+impl ParamList {
     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
-    pub fn fields(&self) -> AstChildren<TupleFieldDef> { support::children(&self.syntax) }
+    pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) }
+    pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) }
+    pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
-/// Tuple field definition including its attributes.
-///
-/// ```
-/// struct Foo(❰ #[attr] u32 ❱);
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TupleFieldDef {
+pub struct RetType {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for TupleFieldDef {}
-impl ast::AttrsOwner for TupleFieldDef {}
-impl TupleFieldDef {
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+impl RetType {
+    pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Enum definition.
-/// Includes all of its attributes and doc comments.
-///
-/// ```
-/// ❰
-///     /// Docs
-///     #[attr]
-///     pub enum Foo<T> where T: Debug {
-///         /// Docs
-///         #[attr]
-///         Bar,
-///         Baz(#[attr] u32),
-///         Bruh {
-///             a: u32,
-///             /// Docs
-///             #[attr]
-///             b: T,
-///         }
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct EnumDef {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct WhereClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for EnumDef {}
-impl ast::NameOwner for EnumDef {}
-impl ast::TypeParamsOwner for EnumDef {}
-impl ast::AttrsOwner for EnumDef {}
-impl ast::DocCommentsOwner for EnumDef {}
-impl EnumDef {
-    pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) }
-    pub fn variant_list(&self) -> Option<EnumVariantList> { support::child(&self.syntax) }
-}
-/// Enum variant definition list including enclosing curly braces.
-///
-/// ```
-/// enum Foo
-/// ❰
-///     {
-///         Bar,
-///         Baz(u32),
-///         Bruh {
-///             a: u32
-///         }
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct EnumVariantList {
+impl WhereClause {
+    pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) }
+    pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct BlockExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl EnumVariantList {
+impl ast::AttrsOwner for BlockExpr {}
+impl ast::ModuleItemOwner for BlockExpr {}
+impl BlockExpr {
+    pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
-    pub fn variants(&self) -> AstChildren<EnumVariant> { support::children(&self.syntax) }
+    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 }
-/// Enum variant definition including its attributes and discriminant value definition.
-///
-/// ```
-/// enum Foo {
-///     ❰
-///         /// Docs
-///         #[attr]
-///         Bar
-///     ❱
-///
-///     // same for tuple and record variants
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct EnumVariant {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SelfParam {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for EnumVariant {}
-impl ast::NameOwner for EnumVariant {}
-impl ast::DocCommentsOwner for EnumVariant {}
-impl ast::AttrsOwner for EnumVariant {}
-impl EnumVariant {
-    pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
-    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
-    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+impl ast::AttrsOwner for SelfParam {}
+impl SelfParam {
+    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
+    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, T![lifetime])
+    }
+    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
+    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
+    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Trait definition.
-/// Includes all of its attributes and doc comments.
-///
-/// ```
-/// ❰
-///     /// Docs
-///     #[attr]
-///     pub unsafe trait Foo<T>: Debug where T: Debug {
-///         // ...
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/traits.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TraitDef {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Param {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for TraitDef {}
-impl ast::NameOwner for TraitDef {}
-impl ast::AttrsOwner for TraitDef {}
-impl ast::DocCommentsOwner for TraitDef {}
-impl ast::TypeParamsOwner for TraitDef {}
-impl ast::TypeBoundsOwner for TraitDef {}
-impl TraitDef {
-    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
-    pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }
-    pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
-    pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
+impl ast::AttrsOwner for Param {}
+impl Param {
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
+    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }
 }
-/// Module definition either with body or not.
-/// Includes all of its inner and outer attributes, module items, doc comments.
-///
-/// ```
-/// ❰
-///     /// Docs
-///     #[attr]
-///     pub mod foo;
-/// ❱
-///
-/// ❰
-///     /// Docs
-///     #[attr]
-///     pub mod bar {
-///        //! Inner docs
-///        #![inner_attr]
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/modules.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Module {
+pub struct TypeBoundList {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for Module {}
-impl ast::NameOwner for Module {}
-impl ast::AttrsOwner for Module {}
-impl ast::DocCommentsOwner for Module {}
-impl Module {
-    pub fn mod_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mod]) }
-    pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
-    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+impl TypeBoundList {
+    pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) }
 }
-/// Item defintion list.
-/// This is used for both top-level items and impl block items.
-///
-/// ```
-/// ❰
-///     fn foo {}
-///     struct Bar;
-///     enum Baz;
-///     trait Bruh;
-///     const BRUUH: u32 = 42;
-/// ❱
-///
-/// impl Foo
-/// ❰
-///     {
-///         fn bar() {}
-///         const BAZ: u32 = 42;
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ItemList {
+pub struct RecordFieldList {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::ModuleItemOwner for ItemList {}
-impl ItemList {
+impl RecordFieldList {
     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
-    pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) }
+    pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }
     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 }
-/// Constant variable definition.
-/// Includes all of its attributes and doc comments.
-///
-/// ```
-/// ❰
-///     /// Docs
-///     #[attr]
-///     pub const FOO: u32 = 42;
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/constant-items.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstDef {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TupleFieldList {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for ConstDef {}
-impl ast::NameOwner for ConstDef {}
-impl ast::TypeParamsOwner for ConstDef {}
-impl ast::AttrsOwner for ConstDef {}
-impl ast::DocCommentsOwner for ConstDef {}
-impl ast::TypeAscriptionOwner for ConstDef {}
-impl ConstDef {
-    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
-    pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
-    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
-    pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+impl TupleFieldList {
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
+    pub fn fields(&self) -> AstChildren<TupleField> { support::children(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RecordField {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for RecordField {}
+impl ast::NameOwner for RecordField {}
+impl ast::VisibilityOwner for RecordField {}
+impl RecordField {
+    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Static variable definition.
-/// Includes all of its attributes and doc comments.
-///
-/// ```
-/// ❰
-///     /// Docs
-///     #[attr]
-///     pub static mut FOO: u32 = 42;
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/static-items.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct StaticDef {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TupleField {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for StaticDef {}
-impl ast::NameOwner for StaticDef {}
-impl ast::TypeParamsOwner for StaticDef {}
-impl ast::AttrsOwner for StaticDef {}
-impl ast::DocCommentsOwner for StaticDef {}
-impl ast::TypeAscriptionOwner for StaticDef {}
-impl StaticDef {
-    pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
-    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
+impl ast::AttrsOwner for TupleField {}
+impl ast::VisibilityOwner for TupleField {}
+impl TupleField {
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct VariantList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl VariantList {
+    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
+    pub fn variants(&self) -> AstChildren<Variant> { support::children(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Variant {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for Variant {}
+impl ast::NameOwner for Variant {}
+impl ast::VisibilityOwner for Variant {}
+impl Variant {
+    pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) }
     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
-    pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Type alias definition.
-/// Includes associated type clauses with type bounds.
-///
-/// ```
-/// ❰
-///     /// Docs
-///     #[attr]
-///     pub type Foo<T> where T: Debug = T;
-/// ❱
-///
-/// trait Bar {
-///     ❰ type Baz: Debug; ❱
-///     ❰ type Bruh = String; ❱
-///     ❰ type Bruuh: Debug = u32; ❱
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/type-aliases.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeAliasDef {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AssocItemList {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::VisibilityOwner for TypeAliasDef {}
-impl ast::NameOwner for TypeAliasDef {}
-impl ast::TypeParamsOwner for TypeAliasDef {}
-impl ast::AttrsOwner for TypeAliasDef {}
-impl ast::DocCommentsOwner for TypeAliasDef {}
-impl ast::TypeBoundsOwner for TypeAliasDef {}
-impl TypeAliasDef {
-    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
-    pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }
+impl ast::AttrsOwner for AssocItemList {}
+impl AssocItemList {
+    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
+    pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ExternItemList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for ExternItemList {}
+impl ExternItemList {
+    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
+    pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }
+    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct LifetimeParam {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for LifetimeParam {}
+impl LifetimeParam {
+    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, T![lifetime])
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TypeParam {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for TypeParam {}
+impl ast::NameOwner for TypeParam {}
+impl ast::TypeBoundsOwner for TypeParam {}
+impl TypeParam {
     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
-    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+    pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Inherent and trait impl definition.
-/// Includes all of its inner and outer attributes.
-///
-/// ```
-/// ❰
-///     #[attr]
-///     unsafe impl<T> const !Foo for Bar where T: Debug {
-///         #![inner_attr]
-///         // ...
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/implementations.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ImplDef {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ConstParam {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::TypeParamsOwner for ImplDef {}
-impl ast::AttrsOwner for ImplDef {}
-impl ast::DocCommentsOwner for ImplDef {}
-impl ImplDef {
-    pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
+impl ast::AttrsOwner for ConstParam {}
+impl ast::NameOwner for ConstParam {}
+impl ConstParam {
     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
-    pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
-    pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
-    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
-    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
-    pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
+    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
+    pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Literal {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Literal {}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TokenTree {
+    pub(crate) syntax: SyntaxNode,
+}
+impl TokenTree {
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
+    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
+    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
+    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
+    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
 }
-/// Parenthesized type reference.
-/// Note: parens are only used for grouping, this is not a tuple type.
-///
-/// ```
-/// // This is effectively just `u32`.
-/// // Single-item tuple must be defined with a trailing comma: `(u32,)`
-/// type Foo = ❰ (u32) ❱;
-///
-/// let bar: &'static ❰ (dyn Debug) ❱ = "bruh";
-/// ```
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParenType {
     pub(crate) syntax: SyntaxNode,
 }
 impl ParenType {
     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
-/// Unnamed tuple type.
-///
-/// ```
-/// let foo: ❰ (u32, bool) ❱ = (42, true);
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/types/tuple.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleType {
     pub(crate) syntax: SyntaxNode,
@@ -565,17 +537,6 @@ impl TupleType {
     pub fn fields(&self) -> AstChildren<TypeRef> { support::children(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
-/// The never type (i.e. the exclamation point).
-///
-/// ```
-/// type T = ❰ ! ❱;
-///
-/// fn no_return() -> ❰ ! ❱ {
-///     loop {}
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/types/never.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NeverType {
     pub(crate) syntax: SyntaxNode,
@@ -583,17 +544,6 @@ pub struct NeverType {
 impl NeverType {
     pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
 }
-/// Path to a type.
-/// Includes single identifier type names and elaborate paths with
-/// generic parameters.
-///
-/// ```
-/// type Foo = ❰ String ❱;
-/// type Bar = ❰ std::vec::Vec<T> ❱;
-/// type Baz = ❰ ::bruh::<Bruuh as Iterator>::Item ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/paths.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PathType {
     pub(crate) syntax: SyntaxNode,
@@ -601,14 +551,6 @@ pub struct PathType {
 impl PathType {
     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 }
-/// Raw pointer type.
-///
-/// ```
-/// type Foo = ❰ *const u32 ❱;
-/// type Bar = ❰ *mut u32 ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/types/pointer.html#raw-pointers-const-and-mut)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PointerType {
     pub(crate) syntax: SyntaxNode,
@@ -617,49 +559,28 @@ impl PointerType {
     pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Array type.
-///
-/// ```
-/// type Foo = ❰ [u32; 24 - 3] ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/types/array.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ArrayType {
     pub(crate) syntax: SyntaxNode,
 }
 impl ArrayType {
     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
 }
-/// Slice type.
-///
-/// ```
-/// type Foo = ❰ [u8] ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/types/slice.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SliceType {
     pub(crate) syntax: SyntaxNode,
 }
 impl SliceType {
     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
 }
-/// Reference type.
-///
-/// ```
-/// type Foo = ❰ &'static str ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/types/pointer.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ReferenceType {
     pub(crate) syntax: SyntaxNode,
@@ -670,15 +591,8 @@ impl ReferenceType {
         support::token(&self.syntax, T![lifetime])
     }
     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Placeholder type (i.e. the underscore).
-///
-/// ```
-/// let foo: ❰ _ ❱ = 42_u32;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/types/inferred.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PlaceholderType {
     pub(crate) syntax: SyntaxNode,
@@ -686,15 +600,6 @@ pub struct PlaceholderType {
 impl PlaceholderType {
     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
 }
-/// Function pointer type (not to be confused with `Fn*` family of traits).
-///
-/// ```
-/// type Foo = ❰ async fn(#[attr] u32, named: bool) -> u32 ❱;
-///
-/// type Bar = ❰ extern "C" fn(variadic: u32, #[attr] ...) ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/types/function-pointer.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FnPointerType {
     pub(crate) syntax: SyntaxNode,
@@ -706,59 +611,31 @@ impl FnPointerType {
     pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
 }
-/// Higher order type.
-///
-/// ```
-/// type Foo = ❰ for<'a> fn(&'a str) ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/nomicon/hrtb.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ForType {
     pub(crate) syntax: SyntaxNode,
 }
 impl ForType {
     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
-    pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Opaque `impl Trait` type.
-///
-/// ```
-/// fn foo(bar: ❰ impl Debug + Eq ❱) {}
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/types/impl-trait.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ImplTraitType {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::TypeBoundsOwner for ImplTraitType {}
 impl ImplTraitType {
     pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
+    pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
 }
-/// Trait object type.
-///
-/// ```
-/// type Foo = ❰ dyn Debug ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/types/trait-object.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DynTraitType {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::TypeBoundsOwner for DynTraitType {}
 impl DynTraitType {
     pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) }
+    pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
 }
-/// Tuple literal.
-///
-/// ```
-/// ❰ (42, true) ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/tuple-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleExpr {
     pub(crate) syntax: SyntaxNode,
@@ -769,15 +646,6 @@ impl TupleExpr {
     pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
-/// Array literal.
-///
-/// ```
-/// ❰ [#![inner_attr] true, false, true] ❱;
-///
-/// ❰ ["baz"; 24] ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/array-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ArrayExpr {
     pub(crate) syntax: SyntaxNode,
@@ -786,17 +654,10 @@ impl ast::AttrsOwner for ArrayExpr {}
 impl ArrayExpr {
     pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
     pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
 }
-/// Parenthesized expression.
-/// Note: parens are only used for grouping, this is not a tuple literal.
-///
-/// ```
-/// ❰ (#![inner_attr] 2 + 2) ❱ * 2;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/grouped-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParenExpr {
     pub(crate) syntax: SyntaxNode,
@@ -807,19 +668,6 @@ impl ParenExpr {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
-/// Path to a symbol in expression context.
-/// Includes single identifier variable names and elaborate paths with
-/// generic parameters.
-///
-/// ```
-/// ❰ Some::<i32> ❱;
-/// ❰ foo ❱ + 42;
-/// ❰ Vec::<i32>::push ❱;
-/// ❰ <[i32]>::reverse ❱;
-/// ❰ <String as std::borrow::Borrow<str>>::borrow ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/path-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PathExpr {
     pub(crate) syntax: SyntaxNode,
@@ -827,17 +675,6 @@ pub struct PathExpr {
 impl PathExpr {
     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 }
-/// Anonymous callable object literal a.k.a. closure, lambda or functor.
-///
-/// ```
-/// ❰ || 42 ❱;
-/// ❰ |a: u32| val + 1 ❱;
-/// ❰ async |#[attr] Pattern(_): Pattern| { bar } ❱;
-/// ❰ move || baz ❱;
-/// ❰ || -> u32 { closure_with_ret_type_annotation_requires_block_expr } ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/closure-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LambdaExpr {
     pub(crate) syntax: SyntaxNode,
@@ -851,25 +688,6 @@ impl LambdaExpr {
     pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
     pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// If expression. Includes both regular `if` and `if let` forms.
-/// Beware that `else if` is a special case syntax sugar, because in general
-/// there has to be block expression after `else`.
-///
-/// ```
-/// ❰ if bool_cond { 42 } ❱
-/// ❰ if bool_cond { 42 } else { 24 } ❱
-/// ❰ if bool_cond { 42 } else if bool_cond2 { 42 } ❱
-///
-/// ❰
-///     if let Pattern(foo) = bar {
-///         foo
-///     } else {
-///         panic!();
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/if-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct IfExpr {
     pub(crate) syntax: SyntaxNode,
@@ -879,40 +697,16 @@ impl IfExpr {
     pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
     pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
 }
-/// Unconditional loop expression.
-///
-/// ```
-/// ❰
-///     loop {
-///         // yeah, it's that simple...
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LoopExpr {
+pub struct Condition {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::AttrsOwner for LoopExpr {}
-impl ast::LoopBodyOwner for LoopExpr {}
-impl LoopExpr {
-    pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) }
+impl Condition {
+    pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
+    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Block expression with an optional prefix (label, try ketword,
-/// unsafe keyword, async keyword...).
-///
-/// ```
-/// ❰
-///     'label: try {
-///         None?
-///     }
-/// ❱
-/// ```
-///
-/// - [try block](https://doc.rust-lang.org/unstable-book/language-features/try-blocks.html)
-/// - [unsafe block](https://doc.rust-lang.org/reference/expressions/block-expr.html#unsafe-blocks)
-/// - [async block](https://doc.rust-lang.org/reference/expressions/block-expr.html#async-blocks)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EffectExpr {
     pub(crate) syntax: SyntaxNode,
@@ -925,19 +719,24 @@ impl EffectExpr {
     pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
     pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
 }
-/// For loop expression.
-/// Note: record struct literals are not valid as iterable expression
-/// due to ambiguity.
-///
-/// ```
-/// ❰
-/// for i in (0..4) {
-///     dbg!(i);
-/// }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops)
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Label {
+    pub(crate) syntax: SyntaxNode,
+}
+impl Label {
+    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, T![lifetime])
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct LoopExpr {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for LoopExpr {}
+impl ast::LoopBodyOwner for LoopExpr {}
+impl LoopExpr {
+    pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ForExpr {
     pub(crate) syntax: SyntaxNode,
@@ -950,22 +749,6 @@ impl ForExpr {
     pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
     pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// While loop expression. Includes both regular `while` and `while let` forms.
-///
-/// ```
-/// ❰
-///     while bool_cond {
-///         42;
-///     }
-/// ❱
-/// ❰
-///     while let Pattern(foo) = bar {
-///         bar += 1;
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-loops)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct WhileExpr {
     pub(crate) syntax: SyntaxNode,
@@ -976,22 +759,6 @@ impl WhileExpr {
     pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) }
     pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
 }
-/// Continue expression.
-///
-/// ```
-/// while bool_cond {
-///     ❰ continue ❱;
-/// }
-///
-/// 'outer: loop {
-///     loop {
-///         ❰ continue 'outer ❱;
-///     }
-/// }
-///
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#continue-expressions)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ContinueExpr {
     pub(crate) syntax: SyntaxNode,
@@ -1005,25 +772,6 @@ impl ContinueExpr {
         support::token(&self.syntax, T![lifetime])
     }
 }
-/// Break expression.
-///
-/// ```
-/// while bool_cond {
-///     ❰ break ❱;
-/// }
-/// 'outer: loop {
-///     for foo in bar {
-///         ❰ break 'outer ❱;
-///     }
-/// }
-/// 'outer: loop {
-///     loop {
-///         ❰ break 'outer 42 ❱;
-///     }
-/// }
-/// ```
-///
-/// [Refernce](https://doc.rust-lang.org/reference/expressions/loop-expr.html#break-expressions)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BreakExpr {
     pub(crate) syntax: SyntaxNode,
@@ -1036,104 +784,33 @@ impl BreakExpr {
     }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Label.
-///
-/// ```
-/// ❰ 'outer: ❱ loop {}
-///
-/// let foo = ❰ 'bar: ❱ loop {}
-///
-/// ❰ 'baz: ❱ {
-///     break 'baz;
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html?highlight=label#loop-labels)
-/// [Labels for blocks RFC](https://github.com/rust-lang/rfcs/blob/master/text/2046-label-break-value.md)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Label {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Label {
-    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, T![lifetime])
-    }
-}
-/// Block expression. Includes unsafe blocks and block labels.
-///
-/// ```
-///     let foo = ❰
-///         {
-///             #![inner_attr]
-///             ❰ { } ❱
-///
-///             ❰ 'label: { break 'label } ❱
-///         }
-///     ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/block-expr.html)
-/// [Labels for blocks RFC](https://github.com/rust-lang/rfcs/blob/master/text/2046-label-break-value.md)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct BlockExpr {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ast::AttrsOwner for BlockExpr {}
-impl ast::ModuleItemOwner for BlockExpr {}
-impl BlockExpr {
-    pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
-    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
-    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
-    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
-    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
-}
-/// Return expression.
-///
-/// ```
-/// || ❰ return 42 ❱;
-///
-/// fn bar() {
-///     ❰ return ❱;
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/return-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ReturnExpr {
     pub(crate) syntax: SyntaxNode,
 }
 impl ast::AttrsOwner for ReturnExpr {}
 impl ReturnExpr {
+    pub fn return_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![return]) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Call expression (not to be confused with method call expression, it is
-/// a separate ast node).
-///
-/// ```
-/// ❰ foo() ❱;
-/// ❰ &str::len("bar") ❱;
-/// ❰ <&str as PartialEq<&str>>::eq(&"", &"") ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/call-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CallExpr {
     pub(crate) syntax: SyntaxNode,
 }
+impl ast::AttrsOwner for CallExpr {}
 impl ast::ArgListOwner for CallExpr {}
 impl CallExpr {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Method call expression.
-///
-/// ```
-/// ❰ receiver_expr.method() ❱;
-/// ❰ receiver_expr.method::<T>(42, true) ❱;
-///
-/// ❰ ❰ ❰ foo.bar() ❱ .baz() ❱ .bruh() ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/method-call-expr.html)
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ArgList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ArgList {
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
+    pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MethodCallExpr {
     pub(crate) syntax: SyntaxNode,
@@ -1146,31 +823,19 @@ impl MethodCallExpr {
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
     pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) }
 }
-/// Index expression a.k.a. subscript operator call.
-///
-/// ```
-/// ❰ foo[42] ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/array-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct IndexExpr {
+pub struct TypeArgList {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::AttrsOwner for IndexExpr {}
-impl IndexExpr {
-    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
-    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
+impl TypeArgList {
+    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
+    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
+    pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) }
+    pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> { support::children(&self.syntax) }
+    pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> { support::children(&self.syntax) }
+    pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) }
+    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
 }
-/// Field access expression.
-///
-/// ```
-/// ❰ expr.bar ❱;
-///
-/// ❰ ❰ ❰ foo.bar ❱ .baz ❱ .bruh ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/field-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FieldExpr {
     pub(crate) syntax: SyntaxNode,
@@ -1181,13 +846,15 @@ impl FieldExpr {
     pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
 }
-/// Await operator call expression.
-///
-/// ```
-/// ❰ expr.await ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/await-expr.html)
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct IndexExpr {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for IndexExpr {}
+impl IndexExpr {
+    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
+    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AwaitExpr {
     pub(crate) syntax: SyntaxNode,
@@ -1198,13 +865,6 @@ impl AwaitExpr {
     pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
     pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) }
 }
-/// The question mark operator call.
-///
-/// ```
-/// ❰ expr? ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-question-mark-operator)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TryExpr {
     pub(crate) syntax: SyntaxNode,
@@ -1214,13 +874,6 @@ impl TryExpr {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
 }
-/// Type cast expression.
-///
-/// ```
-/// ❰ expr as T ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CastExpr {
     pub(crate) syntax: SyntaxNode,
@@ -1229,18 +882,8 @@ impl ast::AttrsOwner for CastExpr {}
 impl CastExpr {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Borrow operator call.
-///
-/// ```
-/// ❰ &foo ❱;
-/// ❰ &mut bar ❱;
-/// ❰ &raw const bar ❱;
-/// ❰ &raw mut bar ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#borrow-operators)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RefExpr {
     pub(crate) syntax: SyntaxNode,
@@ -1253,15 +896,6 @@ impl RefExpr {
     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Prefix operator call. This is either `!` or `*` or `-`.
-///
-/// ```
-/// ❰ !foo ❱;
-/// ❰ *bar ❱;
-/// ❰ -42 ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PrefixExpr {
     pub(crate) syntax: SyntaxNode,
@@ -1270,13 +904,6 @@ impl ast::AttrsOwner for PrefixExpr {}
 impl PrefixExpr {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Box operator call.
-///
-/// ```
-/// ❰ box 42 ❱;
-/// ```
-///
-/// [RFC](https://github.com/rust-lang/rfcs/blob/0806be4f282144cfcd55b1d20284b43f87cbe1c6/text/0809-box-and-in-for-stdlib.md)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BoxExpr {
     pub(crate) syntax: SyntaxNode,
@@ -1286,69 +913,18 @@ impl BoxExpr {
     pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Range operator call.
-///
-/// ```
-/// ❰ 0..42 ❱;
-/// ❰ ..42 ❱;
-/// ❰ 0.. ❱;
-/// ❰ .. ❱;
-/// ❰ 0..=42 ❱;
-/// ❰ ..=42 ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/range-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RangeExpr {
     pub(crate) syntax: SyntaxNode,
 }
 impl ast::AttrsOwner for RangeExpr {}
 impl RangeExpr {}
-/// Binary operator call.
-/// Includes all arithmetic, logic, bitwise and assignment operators.
-///
-/// ```
-/// ❰ 2 + ❰ 2 * 2 ❱ ❱;
-/// ❰ ❰ true && false ❱ || true ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BinExpr {
     pub(crate) syntax: SyntaxNode,
 }
 impl ast::AttrsOwner for BinExpr {}
 impl BinExpr {}
-/// [Raw] string, [raw] byte string, char, byte, integer, float or bool literal.
-///
-/// ```
-/// ❰ "str" ❱;
-/// ❰ br##"raw byte str"## ❱;
-/// ❰ 'c' ❱;
-/// ❰ b'c' ❱;
-/// ❰ 42 ❱;
-/// ❰ 1e9 ❱;
-/// ❰ true ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/literal-expr.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Literal {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Literal {}
-/// Match expression.
-///
-/// ```
-/// ❰
-///     match expr {
-///         Pat1 => {}
-///         Pat2(_) => 42,
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MatchExpr {
     pub(crate) syntax: SyntaxNode,
@@ -1359,40 +935,15 @@ impl MatchExpr {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }
 }
-/// Match arm list part of match expression. Includes its inner attributes.
-///
-/// ```
-/// match expr
-/// ❰
-///     {
-///         #![inner_attr]
-///         Pat1 => {}
-///         Pat2(_) => 42,
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MatchArmList {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::AttrsOwner for MatchArmList {}
 impl MatchArmList {
     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
     pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }
     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 }
-/// Match arm.
-/// Note: record struct literals are not valid as target match expression
-/// due to ambiguity.
-/// ```
-/// match expr {
-///     ❰ #[attr] Pattern(it) if bool_cond => it ❱,
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MatchArm {
     pub(crate) syntax: SyntaxNode,
@@ -1404,15 +955,6 @@ impl MatchArm {
     pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Match guard.
-///
-/// ```
-/// match expr {
-///     Pattern(it) ❰ if bool_cond ❱ => it,
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html#match-guards)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MatchGuard {
     pub(crate) syntax: SyntaxNode,
@@ -1421,76 +963,37 @@ impl MatchGuard {
     pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Record literal expression. The same syntax is used for structs,
-/// unions and record enum variants.
-///
-/// ```
-/// ❰
-///     foo::Bar {
-///         #![inner_attr]
-///         baz: 42,
-///         bruh: true,
-///         ..spread
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordLit {
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RecordExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl RecordLit {
+impl RecordExpr {
     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
-    pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) }
+    pub fn record_expr_field_list(&self) -> Option<RecordExprFieldList> {
+        support::child(&self.syntax)
+    }
 }
-/// Record field list including enclosing curly braces.
-///
-/// foo::Bar ❰
-///     {
-///         baz: 42,
-///         ..spread
-///     }
-/// ❱
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordFieldList {
+pub struct RecordExprFieldList {
     pub(crate) syntax: SyntaxNode,
 }
-impl RecordFieldList {
+impl RecordExprFieldList {
     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
-    pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }
+    pub fn fields(&self) -> AstChildren<RecordExprField> { support::children(&self.syntax) }
     pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
     pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 }
-/// Record field.
-///
-/// ```
-/// foo::Bar {
-///     ❰ #[attr] baz: 42 ❱
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordField {
+pub struct RecordExprField {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::AttrsOwner for RecordField {}
-impl RecordField {
+impl ast::AttrsOwner for RecordExprField {}
+impl RecordExprField {
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Disjunction of patterns.
-///
-/// ```
-/// let ❰ Foo(it) | Bar(it) | Baz(it) ❱ = bruh;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct OrPat {
     pub(crate) syntax: SyntaxNode,
@@ -1498,14 +1001,6 @@ pub struct OrPat {
 impl OrPat {
     pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
 }
-/// Parenthesized pattern.
-/// Note: parens are only used for grouping, this is not a tuple pattern.
-///
-/// ```
-/// if let ❰ &(0..=42) ❱ = foo {}
-/// ```
-///
-/// https://doc.rust-lang.org/reference/patterns.html#grouped-patterns
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParenPat {
     pub(crate) syntax: SyntaxNode,
@@ -1515,16 +1010,6 @@ impl ParenPat {
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
-/// Reference pattern.
-/// Note: this has nothing to do with `ref` keyword, the latter is used in bind patterns.
-///
-/// ```
-/// let ❰ &mut foo ❱ = bar;
-///
-/// let ❰ & ❰ &mut ❰ &_ ❱ ❱ ❱ = baz;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#reference-patterns)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RefPat {
     pub(crate) syntax: SyntaxNode,
@@ -1534,31 +1019,14 @@ impl RefPat {
     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
-/// Box pattern.
-///
-/// ```
-/// let ❰ box foo ❱ = box 42;
-/// ```
-///
-/// [Unstable book](https://doc.rust-lang.org/unstable-book/language-features/box-patterns.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BoxPat {
     pub(crate) syntax: SyntaxNode,
 }
 impl BoxPat {
     pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
-    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 }
-/// Bind pattern.
-///
-/// ```
-/// match foo {
-///     Some(❰ ref mut bar ❱) => {}
-///     ❰ baz @ None ❱ => {}
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#identifier-patterns)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BindPat {
     pub(crate) syntax: SyntaxNode,
@@ -1571,13 +1039,6 @@ impl BindPat {
     pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
-/// Placeholder pattern a.k.a. the wildcard pattern or the underscore.
-///
-/// ```
-/// let ❰ _ ❱ = foo;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#wildcard-pattern)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PlaceholderPat {
     pub(crate) syntax: SyntaxNode,
@@ -1585,16 +1046,6 @@ pub struct PlaceholderPat {
 impl PlaceholderPat {
     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
 }
-/// Rest-of-the record/tuple pattern.
-/// Note: this is not the unbonded range pattern (even more: it doesn't exist).
-///
-/// ```
-/// let Foo { bar, ❰ .. ❱ } = baz;
-/// let (❰ .. ❱, bruh) = (42, 24, 42);
-/// let Bruuh(❰ .. ❱) = bruuuh;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DotDotPat {
     pub(crate) syntax: SyntaxNode,
@@ -1602,15 +1053,6 @@ pub struct DotDotPat {
 impl DotDotPat {
     pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
 }
-/// Path pattern.
-/// Doesn't include the underscore pattern (it is a special case, namely `PlaceholderPat`).
-///
-/// ```
-/// let ❰ foo::bar::Baz ❱ { .. } = bruh;
-/// if let ❰ CONST ❱ = 42 {}
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#path-patterns)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PathPat {
     pub(crate) syntax: SyntaxNode,
@@ -1618,13 +1060,6 @@ pub struct PathPat {
 impl PathPat {
     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 }
-/// Slice pattern.
-///
-/// ```
-/// let ❰ [foo, bar, baz] ❱ = [1, 2, 3];
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#slice-patterns)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SlicePat {
     pub(crate) syntax: SyntaxNode,
@@ -1634,33 +1069,14 @@ impl SlicePat {
     pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
     pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
 }
-/// Range pattern.
-///
-/// ```
-/// match foo {
-///     ❰ 0..42 ❱ => {}
-///     ❰ 0..=42 ❱ => {}
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#range-patterns)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RangePat {
     pub(crate) syntax: SyntaxNode,
 }
-impl RangePat {}
-/// Literal pattern.
-/// Includes only bool, number, char, and string literals.
-///
-/// ```
-/// match foo {
-///     Number(❰ 42 ❱) => {}
-///     String(❰ "42" ❱) => {}
-///     Bool(❰ true ❱) => {}
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#literal-patterns)
+impl RangePat {
+    pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
+    pub fn dotdoteq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..=]) }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LiteralPat {
     pub(crate) syntax: SyntaxNode,
@@ -1668,13 +1084,6 @@ pub struct LiteralPat {
 impl LiteralPat {
     pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
 }
-/// Macro invocation in pattern position.
-///
-/// ```
-/// let ❰ foo!(my custom syntax) ❱ = baz;
-///
-/// ```
-/// [Reference](https://doc.rust-lang.org/reference/macros.html#macro-invocation)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MacroPat {
     pub(crate) syntax: SyntaxNode,
@@ -1682,37 +1091,22 @@ pub struct MacroPat {
 impl MacroPat {
     pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
 }
-/// Record literal pattern.
-///
-/// ```
-/// let ❰ foo::Bar { baz, .. } ❱ = bruh;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordPat {
     pub(crate) syntax: SyntaxNode,
 }
 impl RecordPat {
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
     pub fn record_field_pat_list(&self) -> Option<RecordFieldPatList> {
         support::child(&self.syntax)
     }
-    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 }
-/// Record literal's field patterns list including enclosing curly braces.
-///
-/// ```
-/// let foo::Bar ❰ { baz, bind @ bruh, .. } ❱ = bruuh;
-/// ``
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordFieldPatList {
     pub(crate) syntax: SyntaxNode,
 }
 impl RecordFieldPatList {
     pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
-    pub fn pats(&self) -> AstChildren<RecordInnerPat> { support::children(&self.syntax) }
     pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> {
         support::children(&self.syntax)
     }
@@ -1720,15 +1114,6 @@ impl RecordFieldPatList {
     pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
     pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
 }
-/// Record literal's field pattern.
-/// Note: record literal can also match tuple structs.
-///
-/// ```
-/// let Foo { ❰ bar: _ ❱ } = baz;
-/// let TupleStruct { ❰ 0: _ ❱ } = bruh;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordFieldPat {
     pub(crate) syntax: SyntaxNode,
@@ -1739,13 +1124,6 @@ impl RecordFieldPat {
     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
-/// Tuple struct literal pattern.
-///
-/// ```
-/// let ❰ foo::Bar(baz, bruh) ❱ = bruuh;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#tuple-struct-patterns)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleStructPat {
     pub(crate) syntax: SyntaxNode,
@@ -1756,14 +1134,6 @@ impl TupleStructPat {
     pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
-/// Tuple pattern.
-/// Note: this doesn't include tuple structs (see `TupleStructPat`)
-///
-/// ```
-/// let ❰ (foo, bar, .., baz) ❱ = bruh;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/patterns.html#tuple-patterns)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TuplePat {
     pub(crate) syntax: SyntaxNode,
@@ -1773,234 +1143,28 @@ impl TuplePat {
     pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
 }
-/// Visibility.
-///
-/// ```
-/// ❰ pub mod ❱ foo;
-/// ❰ pub(crate) ❱ struct Bar;
-/// ❰ pub(self) ❱ enum Baz {}
-/// ❰ pub(super) ❱ fn bruh() {}
-/// ❰ pub(in bruuh::bruuuh) ❱ type T = u64;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/visibility-and-privacy.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Visibility {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Visibility {
-    pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) }
-    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
-    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
-    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
-}
-/// Single identifier.
-/// Note(@matklad): `Name` is for things that install a new name into the scope,
-/// `NameRef` is a usage of a name. Most of the time, this definition/reference
-/// distinction can be determined purely syntactically, ie in
-/// ```
-/// fn foo() { foo() }
-/// ```
-/// the first foo is `Name`, the second one is `NameRef`.
-/// The notable exception are patterns, where in
-/// ``
-/// let x = 92
-/// ```
-/// `x` can be semantically either a name or a name ref, depeding on
-/// wether there's an `x` constant in scope.
-/// We use `Name` for patterns, and disambiguate semantically (see `NameClass` in ide_db).
-///
-/// ```
-/// let ❰ foo ❱ = bar;
-/// struct ❰ Baz ❱;
-/// fn ❰ bruh ❱() {}
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/identifiers.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Name {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Name {
-    pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
-}
-/// Reference to a name.
-/// See the explanation on the difference between `Name` and `NameRef`
-/// in `Name` ast node docs.
-///
-/// ```
-/// let foo = ❰ bar ❱(❰ Baz(❰ bruh ❱) ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/identifiers.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NameRef {
-    pub(crate) syntax: SyntaxNode,
-}
-impl NameRef {}
-/// Macro call.
-/// Includes all of its attributes and doc comments.
-///
-/// ```
-/// ❰
-///     /// Docs
-///     #[attr]
-///     macro_rules! foo {   // macro rules is also a macro call
-///         ($bar: tt) => {}
-///     }
-/// ❱
-///
-/// // semicolon is a part of `MacroCall` when it is used in item positions
-/// ❰ foo!(); ❱
-///
-/// fn main() {
-///     ❰ foo!() ❱; // macro call in expression positions doesn't include the semi
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/macros.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MacroCall {
+pub struct MacroDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::NameOwner for MacroCall {}
-impl ast::AttrsOwner for MacroCall {}
-impl ast::DocCommentsOwner for MacroCall {}
-impl MacroCall {
-    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
-    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
+impl ast::NameOwner for MacroDef {}
+impl MacroDef {
     pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
-    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
-}
-/// Attribute.
-///
-/// ```
-/// ❰ #![inner_attr] ❱
-///
-/// ❰ #[attr] ❱
-/// ❰ #[foo = "bar"] ❱
-/// ❰ #[baz(bruh::bruuh = "42")] ❱
-/// struct Foo;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/attributes.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Attr {
-    pub(crate) syntax: SyntaxNode,
 }
-impl Attr {
-    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
-    pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
-    pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
-    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
-    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
-    pub fn input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
-    pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
-}
-/// Stores a list of lexer tokens and other `TokenTree`s.
-/// It appears in attributes, macro_rules and macro call (foo!)
-///
-/// ```
-/// macro_call! ❰ { my syntax here } ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/macros.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TokenTree {
-    pub(crate) syntax: SyntaxNode,
-}
-impl TokenTree {}
-/// Generic lifetime, type and constants parameters list **declaration**.
-///
-/// ```
-/// fn foo❰ <'a, 'b, T, U, const BAR: u64> ❱() {}
-///
-/// struct Baz❰ <T> ❱(T);
-///
-/// impl❰ <T> ❱ Bruh<T> {}
-///
-/// type Bruuh = for❰ <'a> ❱ fn(&'a str) -> &'a str;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/generics.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeParamList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl TypeParamList {
-    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
-    pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
-    pub fn type_params(&self) -> AstChildren<TypeParam> { support::children(&self.syntax) }
-    pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> { support::children(&self.syntax) }
-    pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) }
-    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
-}
-/// Single type parameter **declaration**.
-///
-/// ```
-/// fn foo<❰ K ❱, ❰ I ❱, ❰ E: Debug ❱, ❰ V = DefaultType ❱>() {}
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/generics.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeParam {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ast::NameOwner for TypeParam {}
-impl ast::AttrsOwner for TypeParam {}
-impl ast::TypeBoundsOwner for TypeParam {}
-impl TypeParam {
-    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
-    pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) }
-}
-/// Const generic parameter **declaration**.
-/// ```
-/// fn foo<T, U, ❰ const BAR: usize ❱, ❰ const BAZ: bool ❱>() {}
-/// ```
-///
-/// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/2000-const-generics.md#declaring-a-const-parameter)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstParam {
+pub struct MacroItems {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::NameOwner for ConstParam {}
-impl ast::AttrsOwner for ConstParam {}
-impl ast::TypeAscriptionOwner for ConstParam {}
-impl ConstParam {
-    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
-    pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
-}
-/// Lifetime parameter **declaration**.
-///
-/// ```
-/// fn foo<❰ 'a ❱, ❰ 'b ❱, V, G, D>(bar: &'a str, baz: &'b mut str) {}
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/generics.html)
+impl ast::ModuleItemOwner for MacroItems {}
+impl MacroItems {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LifetimeParam {
+pub struct MacroStmts {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::AttrsOwner for LifetimeParam {}
-impl LifetimeParam {
-    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, T![lifetime])
-    }
+impl MacroStmts {
+    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
-/// Type bound declaration clause.
-///
-/// ```
-/// fn foo<T: ❰ ?Sized ❱ + ❰ Debug ❱>() {}
-///
-/// trait Bar<T>
-/// where
-///     T: ❰ Send ❱ + ❰ Sync ❱
-/// {
-///     type Baz: ❰ !Sync ❱ + ❰ Debug ❱ + ❰ ?const Add ❱;
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/trait-bounds.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeBound {
     pub(crate) syntax: SyntaxNode,
@@ -2012,40 +1176,6 @@ impl TypeBound {
     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Type bounds list.
-///
-/// ```
-///
-/// fn foo<T: ❰ ?Sized + Debug ❱>() {}
-///
-/// trait Bar<T>
-/// where
-///     T: ❰ Send + Sync ❱
-/// {
-///     type Baz: ❰ !Sync + Debug ❱;
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/trait-bounds.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeBoundList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl TypeBoundList {
-    pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) }
-}
-/// Single where predicate.
-///
-/// ```
-/// trait Foo<'a, 'b, T>
-/// where
-///     ❰ 'a: 'b ❱,
-///     ❰ T: IntoIterator ❱,
-///     ❰ for<'c> <T as IntoIterator>::Item: Bar<'c> ❱
-/// {}
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/generics.html#where-clauses)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct WherePred {
     pub(crate) syntax: SyntaxNode,
@@ -2053,64 +1183,12 @@ pub struct WherePred {
 impl ast::TypeBoundsOwner for WherePred {}
 impl WherePred {
     pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
-    pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) }
+    pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
     pub fn lifetime_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, T![lifetime])
     }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Where clause.
-///
-/// ```
-/// trait Foo<'a, T> ❰ where 'a: 'static, T: Debug ❱ {}
-///
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/generics.html#where-clauses)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WhereClause {
-    pub(crate) syntax: SyntaxNode,
-}
-impl WhereClause {
-    pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) }
-    pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
-}
-/// Abi declaration.
-/// Note: the abi string is optional.
-///
-/// ```
-/// ❰ extern "C" ❱ {
-///     fn foo() {}
-/// }
-///
-/// type Bar = ❰ extern ❱ fn() -> u32;
-///
-/// type Baz = ❰ extern r#"stdcall"# ❱ fn() -> bool;
-/// ```
-///
-/// - [Extern blocks reference](https://doc.rust-lang.org/reference/items/external-blocks.html)
-/// - [FFI function pointers reference](https://doc.rust-lang.org/reference/items/functions.html#functions)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Abi {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Abi {}
-/// Expression statement.
-///
-/// ```
-/// ❰ 42; ❱
-/// ❰ foo(); ❱
-/// ❰ (); ❱
-/// ❰ {}; ❱
-///
-/// // constructions with trailing curly brace can omit the semicolon
-/// // but only when there are satements immediately after them (this is important!)
-/// ❰ if bool_cond { } ❱
-/// ❰ loop {} ❱
-/// ❰ somestatment; ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/statements.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExprStmt {
     pub(crate) syntax: SyntaxNode,
@@ -2120,267 +1198,20 @@ impl ExprStmt {
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
-/// Let statement.
-///
-/// ```
-/// ❰ #[attr] let foo; ❱
-/// ❰ let bar: u64; ❱
-/// ❰ let baz = 42; ❱
-/// ❰ let bruh: bool = true; ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/statements.html#let-statements)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LetStmt {
     pub(crate) syntax: SyntaxNode,
 }
 impl ast::AttrsOwner for LetStmt {}
-impl ast::TypeAscriptionOwner for LetStmt {}
 impl LetStmt {
     pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
     pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
+    pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
+    pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) }
     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
     pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
-/// Condition of `if` or `while` expression.
-///
-/// ```
-/// if ❰ true ❱ {}
-/// if ❰ let Pat(foo) = bar ❱ {}
-///
-/// while ❰ true ❱ {}
-/// while ❰ let Pat(baz) = bruh ❱ {}
-/// ```
-///
-/// [If expression reference](https://doc.rust-lang.org/reference/expressions/if-expr.html)
-/// [While expression reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-loops)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Condition {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Condition {
-    pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
-    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
-    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
-    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
-}
-/// Parameter list **declaration**.
-///
-/// ```
-/// fn foo❰ (a: u32, b: bool) ❱ -> u32 {}
-/// let bar = ❰ |a, b| ❱ {};
-///
-/// impl Baz {
-///     fn bruh❰ (&self, a: u32) ❱ {}
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)ocs to codegen script
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParamList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ParamList {
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
-    pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) }
-    pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
-}
-/// Self parameter **declaration**.
-///
-/// ```
-/// impl Bruh {
-///     fn foo(❰ self ❱) {}
-///     fn bar(❰ &self ❱) {}
-///     fn baz(❰ &mut self ❱) {}
-///     fn blah<'a>(❰ &'a self ❱) {}
-///     fn blin(❰ self: Box<Self> ❱) {}
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SelfParam {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ast::TypeAscriptionOwner for SelfParam {}
-impl ast::AttrsOwner for SelfParam {}
-impl SelfParam {
-    pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
-    pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
-    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, T![lifetime])
-    }
-    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
-}
-/// Parameter **declaration**.
-///
-/// ```
-/// fn foo(❰ #[attr] Pat(bar): Pat(u32) ❱, ❰ #[attr] _: bool ❱) {}
-///
-/// extern "C" {
-///     fn bar(❰ baz: u32 ❱, ❰ ... ❱) -> u32;
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Param {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ast::TypeAscriptionOwner for Param {}
-impl ast::AttrsOwner for Param {}
-impl Param {
-    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
-    pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }
-}
-/// Use declaration.
-///
-/// ```
-/// ❰ #[attr] pub use foo; ❱
-/// ❰ use bar as baz; ❱
-/// ❰ use bruh::{self, bruuh}; ❱
-/// ❰ use { blin::blen, blah::* };
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UseItem {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ast::AttrsOwner for UseItem {}
-impl ast::VisibilityOwner for UseItem {}
-impl UseItem {
-    pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }
-    pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
-}
-/// Use tree.
-///
-/// ```
-/// pub use ❰ foo::❰ * ❱ ❱;
-/// use ❰ bar as baz ❱;
-/// use ❰ bruh::bruuh::{ ❰ self ❱, ❰ blin ❱ } ❱;
-/// use ❰ { ❰ blin::blen ❱ } ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UseTree {
-    pub(crate) syntax: SyntaxNode,
-}
-impl UseTree {
-    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
-    pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
-    pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
-    pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
-}
-/// Item alias.
-/// Note: this is not the type alias.
-///
-/// ```
-/// use foo ❰ as bar ❱;
-/// use baz::{bruh ❰ as _ ❱};
-/// extern crate bruuh ❰ as blin ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Alias {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ast::NameOwner for Alias {}
-impl Alias {
-    pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
-}
-/// Sublist of use trees.
-///
-/// ```
-/// use bruh::bruuh::❰ { ❰ self ❱, ❰ blin ❱ } ❱;
-/// use ❰ { blin::blen::❰ {} ❱ } ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UseTreeList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl UseTreeList {
-    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
-    pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) }
-    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
-}
-/// Extern crate item.
-///
-/// ```
-/// ❰ #[attr] pub extern crate foo; ❱
-/// ❰ extern crate self as bar; ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/extern-crates.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ExternCrateItem {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ast::AttrsOwner for ExternCrateItem {}
-impl ast::VisibilityOwner for ExternCrateItem {}
-impl ExternCrateItem {
-    pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
-    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
-    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
-    pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
-}
-/// Call site arguments list.
-///
-/// ```
-/// foo::<T, U>❰ (42, true) ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/expressions/call-expr.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ArgList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ArgList {
-    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
-    pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
-    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
-}
-/// Path to a symbol. Includes single identifier names and elaborate paths with
-/// generic parameters.
-///
-/// ```
-/// (0..10).❰ ❰ collect ❱ ::<Vec<_>> ❱();
-/// ❰ ❰ ❰ Vec ❱ ::<u8> ❱ ::with_capacity ❱(1024);
-/// ❰ ❰ <❰ Foo ❱ as ❰ ❰ bar ❱ ::Bar ❱> ❱ ::baz ❱();
-/// ❰ ❰ <❰ bruh ❱> ❱ ::bruuh ❱();
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/paths.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Path {
-    pub(crate) syntax: SyntaxNode,
-}
-impl Path {
-    pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) }
-    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
-    pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) }
-}
-/// Segment of the path to a symbol.
-/// Only path segment of an absolute path holds the `::` token,
-/// all other `::` tokens that connect path segments reside under `Path` itself.`
-///
-/// ```
-/// (0..10).❰ collect ❱ :: ❰ <Vec<_>> ❱();
-/// ❰ Vec ❱ :: ❰ <u8> ❱ :: ❰ with_capacity ❱(1024);
-/// ❰ <❰ Foo ❱ as ❰ bar ❱ :: ❰ Bar ❱> ❱ :: ❰ baz ❱();
-/// ❰ <❰ bruh ❱> ❱ :: ❰ bruuh ❱();
-///
-/// // Note that only in this case `::` token is inlcuded:
-/// ❰ ::foo ❱;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/paths.html)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PathSegment {
     pub(crate) syntax: SyntaxNode,
@@ -2398,50 +1229,22 @@ impl PathSegment {
     pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }
     pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
 }
-/// List of type arguments that are passed at generic instantiation site.
-///
-/// ```
-/// type _ = Foo ❰ ::<'a, u64, Item = Bar, 42, {true}> ❱::Bar;
-///
-/// Vec❰ ::<bool> ❱::();
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeArgList {
+pub struct TypeArg {
     pub(crate) syntax: SyntaxNode,
 }
-impl TypeArgList {
-    pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
-    pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) }
-    pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) }
-    pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) }
-    pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> { support::children(&self.syntax) }
-    pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> { support::children(&self.syntax) }
-    pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) }
-    pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
+impl TypeArg {
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Type argument that is passed at generic instantiation site.
-///
-/// ```
-/// type _ = Foo::<'a, ❰ u64 ❱, ❰ bool ❱, Item = Bar, 42>::Baz;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeArg {
+pub struct LifetimeArg {
     pub(crate) syntax: SyntaxNode,
 }
-impl TypeArg {
-    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+impl LifetimeArg {
+    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, T![lifetime])
+    }
 }
-/// Associated type argument that is passed at generic instantiation site.
-/// ```
-/// type Foo = Bar::<'a, u64, bool, ❰ Item = Baz ❱, 42>::Bruh;
-///
-/// trait Bruh<T>: Iterator<❰ Item: Debug ❱> {}
-/// ```
-///
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AssocTypeArg {
     pub(crate) syntax: SyntaxNode,
@@ -2452,33 +1255,6 @@ impl AssocTypeArg {
     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
     pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
-/// Lifetime argument that is passed at generic instantiation site.
-///
-/// ```
-/// fn foo<'a>(s: &'a str) {
-///     bar::<❰ 'a ❱>(s);
-/// }
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LifetimeArg {
-    pub(crate) syntax: SyntaxNode,
-}
-impl LifetimeArg {
-    pub fn lifetime_token(&self) -> Option<SyntaxToken> {
-        support::token(&self.syntax, T![lifetime])
-    }
-}
-/// Constant value argument that is passed at generic instantiation site.
-///
-/// ```
-/// foo::<u32, ❰ { true } ❱>();
-///
-/// bar::<❰ { 2 + 2} ❱>();
-/// ```
-///
-/// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/2000-const-generics.md#declaring-a-const-parameter)
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ConstArg {
     pub(crate) syntax: SyntaxNode,
@@ -2487,136 +1263,24 @@ impl ConstArg {
     pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
     pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
 }
-/// FIXME: (@edwin0cheng) Remove it to use ItemList instead
-/// https://github.com/rust-analyzer/rust-analyzer/pull/4083#discussion_r422666243
-///
-/// [Reference](https://doc.rust-lang.org/reference/macros.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MacroItems {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ast::ModuleItemOwner for MacroItems {}
-impl MacroItems {}
-/// FIXME: (@edwin0cheng) add some documentation here. As per the writing
-/// of this comment this ast node is not used.
-///
-/// ```
-/// // FIXME: example here
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/macros.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MacroStmts {
-    pub(crate) syntax: SyntaxNode,
-}
-impl MacroStmts {
-    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
-    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
-}
-/// List of items in an extern block.
-///
-/// ```
-/// extern "C" ❰
-///     {
-///         fn foo();
-///         static var: u32;
-///     }
-/// ❱
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/external-blocks.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ExternItemList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ast::ModuleItemOwner for ExternItemList {}
-impl ExternItemList {
-    pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) }
-    pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }
-    pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
-}
-/// Extern block.
-///
-/// ```
-/// ❰
-///     extern "C" {
-///         fn foo();
-///     }
-/// ❱
-///
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/items/external-blocks.html)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ExternBlock {
-    pub(crate) syntax: SyntaxNode,
-}
-impl ExternBlock {
-    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
-    pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) }
-}
-/// Meta item in an attribute.
-///
-/// ```
-/// #[❰ bar::baz = "42" ❱]
-/// #[❰ bruh(bruuh("true")) ❱]
-/// struct Foo;
-/// ```
-///
-/// [Reference](https://doc.rust-lang.org/reference/attributes.html?highlight=meta,item#meta-item-attribute-syntax)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MetaItem {
-    pub(crate) syntax: SyntaxNode,
-}
-impl MetaItem {
-    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
-    pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
-    pub fn attr_input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
-    pub fn nested_meta_items(&self) -> AstChildren<MetaItem> { support::children(&self.syntax) }
-}
-/// Macro 2.0 definition.
-/// Their syntax is still WIP by rustc team...
-/// ```
-/// ❰
-///     macro foo { }
-/// ❱
-/// ```
-///
-/// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/1584-macros.md)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MacroDef {
-    pub(crate) syntax: SyntaxNode,
-}
-impl MacroDef {
-    pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }
-    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
-}
-/// Any kind of nominal type definition.