From 084bd304f304e674fc3d5b132daf8a9f975064c9 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Fri, 3 Jan 2020 20:37:02 +0100
Subject: Switch ast declaration from ron to a macro

---
 crates/ra_syntax/src/ast/generated.rs | 3060 ++++++++++++++++-----------------
 crates/ra_syntax/src/grammar.ron      |  730 --------
 2 files changed, 1526 insertions(+), 2264 deletions(-)

(limited to 'crates/ra_syntax/src')

diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index e64c83d33..2eb4b14d2 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -6,13 +6,13 @@ use crate::{
     SyntaxNode,
 };
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Alias {
+pub struct SourceFile {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for Alias {
+impl AstNode for SourceFile {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            ALIAS => true,
+            SOURCE_FILE => true,
             _ => false,
         }
     }
@@ -27,16 +27,21 @@ impl AstNode for Alias {
         &self.syntax
     }
 }
-impl ast::NameOwner for Alias {}
-impl Alias {}
+impl ast::ModuleItemOwner for SourceFile {}
+impl ast::FnDefOwner for SourceFile {}
+impl SourceFile {
+    pub fn modules(&self) -> AstChildren<Module> {
+        AstChildren::new(&self.syntax)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ArgList {
+pub struct FnDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ArgList {
+impl AstNode for FnDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            ARG_LIST => true,
+            FN_DEF => true,
             _ => false,
         }
     }
@@ -51,19 +56,30 @@ impl AstNode for ArgList {
         &self.syntax
     }
 }
-impl ArgList {
-    pub fn args(&self) -> AstChildren<Expr> {
-        AstChildren::new(&self.syntax)
+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 param_list(&self) -> Option<ParamList> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn ret_type(&self) -> Option<RetType> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn body(&self) -> Option<BlockExpr> {
+        AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ArrayExpr {
+pub struct RetType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ArrayExpr {
+impl AstNode for RetType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            ARRAY_EXPR => true,
+            RET_TYPE => true,
             _ => false,
         }
     }
@@ -78,19 +94,19 @@ impl AstNode for ArrayExpr {
         &self.syntax
     }
 }
-impl ArrayExpr {
-    pub fn exprs(&self) -> AstChildren<Expr> {
-        AstChildren::new(&self.syntax)
+impl RetType {
+    pub fn type_ref(&self) -> Option<TypeRef> {
+        AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ArrayType {
+pub struct StructDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ArrayType {
+impl AstNode for StructDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            ARRAY_TYPE => true,
+            STRUCT_DEF => true,
             _ => false,
         }
     }
@@ -105,22 +121,20 @@ impl AstNode for ArrayType {
         &self.syntax
     }
 }
-impl ArrayType {
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+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 {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct AssocTypeArg {
+pub struct UnionDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for AssocTypeArg {
+impl AstNode for UnionDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            ASSOC_TYPE_ARG => true,
+            UNION_DEF => true,
             _ => false,
         }
     }
@@ -135,22 +149,24 @@ impl AstNode for AssocTypeArg {
         &self.syntax
     }
 }
-impl AssocTypeArg {
-    pub fn name_ref(&self) -> Option<NameRef> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
+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 {
+    pub fn record_field_def_list(&self) -> Option<RecordFieldDefList> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Attr {
+pub struct RecordFieldDefList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for Attr {
+impl AstNode for RecordFieldDefList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            ATTR => true,
+            RECORD_FIELD_DEF_LIST => true,
             _ => false,
         }
     }
@@ -165,60 +181,47 @@ impl AstNode for Attr {
         &self.syntax
     }
 }
-impl Attr {
-    pub fn path(&self) -> Option<Path> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn input(&self) -> Option<AttrInput> {
-        AstChildren::new(&self.syntax).next()
+impl RecordFieldDefList {
+    pub fn fields(&self) -> AstChildren<RecordFieldDef> {
+        AstChildren::new(&self.syntax)
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum AttrInput {
-    Literal(Literal),
-    TokenTree(TokenTree),
-}
-impl From<Literal> for AttrInput {
-    fn from(node: Literal) -> AttrInput {
-        AttrInput::Literal(node)
-    }
-}
-impl From<TokenTree> for AttrInput {
-    fn from(node: TokenTree) -> AttrInput {
-        AttrInput::TokenTree(node)
-    }
+pub struct RecordFieldDef {
+    pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for AttrInput {
+impl AstNode for RecordFieldDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            LITERAL | TOKEN_TREE => true,
+            RECORD_FIELD_DEF => true,
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        let res = match syntax.kind() {
-            LITERAL => AttrInput::Literal(Literal { syntax }),
-            TOKEN_TREE => AttrInput::TokenTree(TokenTree { syntax }),
-            _ => return None,
-        };
-        Some(res)
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
     }
     fn syntax(&self) -> &SyntaxNode {
-        match self {
-            AttrInput::Literal(it) => &it.syntax,
-            AttrInput::TokenTree(it) => &it.syntax,
-        }
+        &self.syntax
     }
 }
-impl AttrInput {}
+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 {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct AwaitExpr {
+pub struct TupleFieldDefList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for AwaitExpr {
+impl AstNode for TupleFieldDefList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            AWAIT_EXPR => true,
+            TUPLE_FIELD_DEF_LIST => true,
             _ => false,
         }
     }
@@ -233,19 +236,19 @@ impl AstNode for AwaitExpr {
         &self.syntax
     }
 }
-impl AwaitExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
+impl TupleFieldDefList {
+    pub fn fields(&self) -> AstChildren<TupleFieldDef> {
+        AstChildren::new(&self.syntax)
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct BinExpr {
+pub struct TupleFieldDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for BinExpr {
+impl AstNode for TupleFieldDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            BIN_EXPR => true,
+            TUPLE_FIELD_DEF => true,
             _ => false,
         }
     }
@@ -260,15 +263,21 @@ impl AstNode for BinExpr {
         &self.syntax
     }
 }
-impl BinExpr {}
+impl ast::VisibilityOwner for TupleFieldDef {}
+impl ast::AttrsOwner for TupleFieldDef {}
+impl TupleFieldDef {
+    pub fn type_ref(&self) -> Option<TypeRef> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct BindPat {
+pub struct EnumDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for BindPat {
+impl AstNode for EnumDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            BIND_PAT => true,
+            ENUM_DEF => true,
             _ => false,
         }
     }
@@ -283,20 +292,24 @@ impl AstNode for BindPat {
         &self.syntax
     }
 }
-impl ast::NameOwner for BindPat {}
-impl BindPat {
-    pub fn pat(&self) -> Option<Pat> {
+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 variant_list(&self) -> Option<EnumVariantList> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Block {
+pub struct EnumVariantList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for Block {
+impl AstNode for EnumVariantList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            BLOCK => true,
+            ENUM_VARIANT_LIST => true,
             _ => false,
         }
     }
@@ -311,24 +324,19 @@ impl AstNode for Block {
         &self.syntax
     }
 }
-impl ast::AttrsOwner for Block {}
-impl ast::ModuleItemOwner for Block {}
-impl Block {
-    pub fn statements(&self) -> AstChildren<Stmt> {
+impl EnumVariantList {
+    pub fn variants(&self) -> AstChildren<EnumVariant> {
         AstChildren::new(&self.syntax)
     }
-    pub fn expr(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
-    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct BlockExpr {
+pub struct EnumVariant {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for BlockExpr {
+impl AstNode for EnumVariant {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            BLOCK_EXPR => true,
+            ENUM_VARIANT => true,
             _ => false,
         }
     }
@@ -343,19 +351,22 @@ impl AstNode for BlockExpr {
         &self.syntax
     }
 }
-impl BlockExpr {
-    pub fn block(&self) -> Option<Block> {
+impl ast::NameOwner for EnumVariant {}
+impl ast::DocCommentsOwner for EnumVariant {}
+impl ast::AttrsOwner for EnumVariant {}
+impl EnumVariant {
+    pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct BoxExpr {
+pub struct TraitDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for BoxExpr {
+impl AstNode for TraitDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            BOX_EXPR => true,
+            TRAIT_DEF => true,
             _ => false,
         }
     }
@@ -370,19 +381,25 @@ impl AstNode for BoxExpr {
         &self.syntax
     }
 }
-impl BoxExpr {
-    pub fn expr(&self) -> Option<Expr> {
+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 item_list(&self) -> Option<ItemList> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct BoxPat {
+pub struct Module {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for BoxPat {
+impl AstNode for Module {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            BOX_PAT => true,
+            MODULE => true,
             _ => false,
         }
     }
@@ -397,19 +414,23 @@ impl AstNode for BoxPat {
         &self.syntax
     }
 }
-impl BoxPat {
-    pub fn pat(&self) -> Option<Pat> {
+impl ast::VisibilityOwner for Module {}
+impl ast::NameOwner for Module {}
+impl ast::AttrsOwner for Module {}
+impl ast::DocCommentsOwner for Module {}
+impl Module {
+    pub fn item_list(&self) -> Option<ItemList> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct BreakExpr {
+pub struct ItemList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for BreakExpr {
+impl AstNode for ItemList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            BREAK_EXPR => true,
+            ITEM_LIST => true,
             _ => false,
         }
     }
@@ -424,19 +445,21 @@ impl AstNode for BreakExpr {
         &self.syntax
     }
 }
-impl BreakExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct CallExpr {
+impl ast::FnDefOwner for ItemList {}
+impl ast::ModuleItemOwner for ItemList {}
+impl ItemList {
+    pub fn impl_items(&self) -> AstChildren<ImplItem> {
+        AstChildren::new(&self.syntax)
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ConstDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for CallExpr {
+impl AstNode for ConstDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            CALL_EXPR => true,
+            CONST_DEF => true,
             _ => false,
         }
     }
@@ -451,20 +474,25 @@ impl AstNode for CallExpr {
         &self.syntax
     }
 }
-impl ast::ArgListOwner for CallExpr {}
-impl CallExpr {
-    pub fn expr(&self) -> Option<Expr> {
+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 body(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct CastExpr {
+pub struct StaticDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for CastExpr {
+impl AstNode for StaticDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            CAST_EXPR => true,
+            STATIC_DEF => true,
             _ => false,
         }
     }
@@ -479,22 +507,25 @@ impl AstNode for CastExpr {
         &self.syntax
     }
 }
-impl CastExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
+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 body(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Condition {
+pub struct TypeAliasDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for Condition {
+impl AstNode for TypeAliasDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            CONDITION => true,
+            TYPE_ALIAS_DEF => true,
             _ => false,
         }
     }
@@ -509,22 +540,25 @@ impl AstNode for Condition {
         &self.syntax
     }
 }
-impl Condition {
-    pub fn pat(&self) -> Option<Pat> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn expr(&self) -> Option<Expr> {
+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 type_ref(&self) -> Option<TypeRef> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstDef {
+pub struct ImplBlock {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ConstDef {
+impl AstNode for ImplBlock {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            CONST_DEF => true,
+            IMPL_BLOCK => true,
             _ => false,
         }
     }
@@ -539,25 +573,21 @@ impl AstNode for ConstDef {
         &self.syntax
     }
 }
-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 body(&self) -> Option<Expr> {
+impl ast::TypeParamsOwner for ImplBlock {}
+impl ast::AttrsOwner for ImplBlock {}
+impl ImplBlock {
+    pub fn item_list(&self) -> Option<ItemList> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ConstParam {
+pub struct ParenType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ConstParam {
+impl AstNode for ParenType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            CONST_PARAM => true,
+            PAREN_TYPE => true,
             _ => false,
         }
     }
@@ -572,22 +602,19 @@ impl AstNode for ConstParam {
         &self.syntax
     }
 }
-impl ast::NameOwner for ConstParam {}
-impl ast::AttrsOwner for ConstParam {}
-impl ast::TypeAscriptionOwner for ConstParam {}
-impl ConstParam {
-    pub fn default_val(&self) -> Option<Expr> {
+impl ParenType {
+    pub fn type_ref(&self) -> Option<TypeRef> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ContinueExpr {
+pub struct TupleType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ContinueExpr {
+impl AstNode for TupleType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            CONTINUE_EXPR => true,
+            TUPLE_TYPE => true,
             _ => false,
         }
     }
@@ -602,15 +629,19 @@ impl AstNode for ContinueExpr {
         &self.syntax
     }
 }
-impl ContinueExpr {}
+impl TupleType {
+    pub fn fields(&self) -> AstChildren<TypeRef> {
+        AstChildren::new(&self.syntax)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct DotDotPat {
+pub struct NeverType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for DotDotPat {
+impl AstNode for NeverType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            DOT_DOT_PAT => true,
+            NEVER_TYPE => true,
             _ => false,
         }
     }
@@ -625,15 +656,15 @@ impl AstNode for DotDotPat {
         &self.syntax
     }
 }
-impl DotDotPat {}
+impl NeverType {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct DynTraitType {
+pub struct PathType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for DynTraitType {
+impl AstNode for PathType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            DYN_TRAIT_TYPE => true,
+            PATH_TYPE => true,
             _ => false,
         }
     }
@@ -648,16 +679,19 @@ impl AstNode for DynTraitType {
         &self.syntax
     }
 }
-impl ast::TypeBoundsOwner for DynTraitType {}
-impl DynTraitType {}
+impl PathType {
+    pub fn path(&self) -> Option<Path> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct EnumDef {
+pub struct PointerType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for EnumDef {
+impl AstNode for PointerType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            ENUM_DEF => true,
+            POINTER_TYPE => true,
             _ => false,
         }
     }
@@ -672,24 +706,19 @@ impl AstNode for EnumDef {
         &self.syntax
     }
 }
-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 variant_list(&self) -> Option<EnumVariantList> {
+impl PointerType {
+    pub fn type_ref(&self) -> Option<TypeRef> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct EnumVariant {
+pub struct ArrayType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for EnumVariant {
+impl AstNode for ArrayType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            ENUM_VARIANT => true,
+            ARRAY_TYPE => true,
             _ => false,
         }
     }
@@ -704,22 +733,22 @@ impl AstNode for EnumVariant {
         &self.syntax
     }
 }
-impl ast::NameOwner for EnumVariant {}
-impl ast::DocCommentsOwner for EnumVariant {}
-impl ast::AttrsOwner for EnumVariant {}
-impl EnumVariant {
+impl ArrayType {
+    pub fn type_ref(&self) -> Option<TypeRef> {
+        AstChildren::new(&self.syntax).next()
+    }
     pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct EnumVariantList {
+pub struct SliceType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for EnumVariantList {
+impl AstNode for SliceType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            ENUM_VARIANT_LIST => true,
+            SLICE_TYPE => true,
             _ => false,
         }
     }
@@ -734,294 +763,69 @@ impl AstNode for EnumVariantList {
         &self.syntax
     }
 }
-impl EnumVariantList {
-    pub fn variants(&self) -> AstChildren<EnumVariant> {
-        AstChildren::new(&self.syntax)
+impl SliceType {
+    pub fn type_ref(&self) -> Option<TypeRef> {
+        AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Expr {
-    TupleExpr(TupleExpr),
-    ArrayExpr(ArrayExpr),
-    ParenExpr(ParenExpr),
-    PathExpr(PathExpr),
-    LambdaExpr(LambdaExpr),
-    IfExpr(IfExpr),
-    LoopExpr(LoopExpr),
-    ForExpr(ForExpr),
-    WhileExpr(WhileExpr),
-    ContinueExpr(ContinueExpr),
-    BreakExpr(BreakExpr),
-    Label(Label),
-    BlockExpr(BlockExpr),
-    ReturnExpr(ReturnExpr),
-    MatchExpr(MatchExpr),
-    RecordLit(RecordLit),
-    CallExpr(CallExpr),
-    IndexExpr(IndexExpr),
-    MethodCallExpr(MethodCallExpr),
-    FieldExpr(FieldExpr),
-    AwaitExpr(AwaitExpr),
-    TryExpr(TryExpr),
-    TryBlockExpr(TryBlockExpr),
-    CastExpr(CastExpr),
-    RefExpr(RefExpr),
-    PrefixExpr(PrefixExpr),
-    RangeExpr(RangeExpr),
-    BinExpr(BinExpr),
-    Literal(Literal),
-    MacroCall(MacroCall),
-    BoxExpr(BoxExpr),
-}
-impl From<TupleExpr> for Expr {
-    fn from(node: TupleExpr) -> Expr {
-        Expr::TupleExpr(node)
-    }
+pub struct ReferenceType {
+    pub(crate) syntax: SyntaxNode,
 }
-impl From<ArrayExpr> for Expr {
-    fn from(node: ArrayExpr) -> Expr {
-        Expr::ArrayExpr(node)
+impl AstNode for ReferenceType {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            REFERENCE_TYPE => true,
+            _ => false,
+        }
     }
-}
-impl From<ParenExpr> for Expr {
-    fn from(node: ParenExpr) -> Expr {
-        Expr::ParenExpr(node)
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
     }
-}
-impl From<PathExpr> for Expr {
-    fn from(node: PathExpr) -> Expr {
-        Expr::PathExpr(node)
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
     }
 }
-impl From<LambdaExpr> for Expr {
-    fn from(node: LambdaExpr) -> Expr {
-        Expr::LambdaExpr(node)
+impl ReferenceType {
+    pub fn type_ref(&self) -> Option<TypeRef> {
+        AstChildren::new(&self.syntax).next()
     }
 }
-impl From<IfExpr> for Expr {
-    fn from(node: IfExpr) -> Expr {
-        Expr::IfExpr(node)
-    }
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PlaceholderType {
+    pub(crate) syntax: SyntaxNode,
 }
-impl From<LoopExpr> for Expr {
-    fn from(node: LoopExpr) -> Expr {
-        Expr::LoopExpr(node)
-    }
-}
-impl From<ForExpr> for Expr {
-    fn from(node: ForExpr) -> Expr {
-        Expr::ForExpr(node)
-    }
-}
-impl From<WhileExpr> for Expr {
-    fn from(node: WhileExpr) -> Expr {
-        Expr::WhileExpr(node)
-    }
-}
-impl From<ContinueExpr> for Expr {
-    fn from(node: ContinueExpr) -> Expr {
-        Expr::ContinueExpr(node)
-    }
-}
-impl From<BreakExpr> for Expr {
-    fn from(node: BreakExpr) -> Expr {
-        Expr::BreakExpr(node)
-    }
-}
-impl From<Label> for Expr {
-    fn from(node: Label) -> Expr {
-        Expr::Label(node)
-    }
-}
-impl From<BlockExpr> for Expr {
-    fn from(node: BlockExpr) -> Expr {
-        Expr::BlockExpr(node)
-    }
-}
-impl From<ReturnExpr> for Expr {
-    fn from(node: ReturnExpr) -> Expr {
-        Expr::ReturnExpr(node)
-    }
-}
-impl From<MatchExpr> for Expr {
-    fn from(node: MatchExpr) -> Expr {
-        Expr::MatchExpr(node)
-    }
-}
-impl From<RecordLit> for Expr {
-    fn from(node: RecordLit) -> Expr {
-        Expr::RecordLit(node)
-    }
-}
-impl From<CallExpr> for Expr {
-    fn from(node: CallExpr) -> Expr {
-        Expr::CallExpr(node)
-    }
-}
-impl From<IndexExpr> for Expr {
-    fn from(node: IndexExpr) -> Expr {
-        Expr::IndexExpr(node)
-    }
-}
-impl From<MethodCallExpr> for Expr {
-    fn from(node: MethodCallExpr) -> Expr {
-        Expr::MethodCallExpr(node)
-    }
-}
-impl From<FieldExpr> for Expr {
-    fn from(node: FieldExpr) -> Expr {
-        Expr::FieldExpr(node)
-    }
-}
-impl From<AwaitExpr> for Expr {
-    fn from(node: AwaitExpr) -> Expr {
-        Expr::AwaitExpr(node)
-    }
-}
-impl From<TryExpr> for Expr {
-    fn from(node: TryExpr) -> Expr {
-        Expr::TryExpr(node)
-    }
-}
-impl From<TryBlockExpr> for Expr {
-    fn from(node: TryBlockExpr) -> Expr {
-        Expr::TryBlockExpr(node)
-    }
-}
-impl From<CastExpr> for Expr {
-    fn from(node: CastExpr) -> Expr {
-        Expr::CastExpr(node)
-    }
-}
-impl From<RefExpr> for Expr {
-    fn from(node: RefExpr) -> Expr {
-        Expr::RefExpr(node)
-    }
-}
-impl From<PrefixExpr> for Expr {
-    fn from(node: PrefixExpr) -> Expr {
-        Expr::PrefixExpr(node)
-    }
-}
-impl From<RangeExpr> for Expr {
-    fn from(node: RangeExpr) -> Expr {
-        Expr::RangeExpr(node)
-    }
-}
-impl From<BinExpr> for Expr {
-    fn from(node: BinExpr) -> Expr {
-        Expr::BinExpr(node)
-    }
-}
-impl From<Literal> for Expr {
-    fn from(node: Literal) -> Expr {
-        Expr::Literal(node)
-    }
-}
-impl From<MacroCall> for Expr {
-    fn from(node: MacroCall) -> Expr {
-        Expr::MacroCall(node)
-    }
-}
-impl From<BoxExpr> for Expr {
-    fn from(node: BoxExpr) -> Expr {
-        Expr::BoxExpr(node)
-    }
-}
-impl AstNode for Expr {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            TUPLE_EXPR | ARRAY_EXPR | PAREN_EXPR | PATH_EXPR | LAMBDA_EXPR | IF_EXPR
-            | LOOP_EXPR | FOR_EXPR | WHILE_EXPR | CONTINUE_EXPR | BREAK_EXPR | LABEL
-            | BLOCK_EXPR | RETURN_EXPR | MATCH_EXPR | RECORD_LIT | CALL_EXPR | INDEX_EXPR
-            | METHOD_CALL_EXPR | FIELD_EXPR | AWAIT_EXPR | TRY_EXPR | TRY_BLOCK_EXPR
-            | CAST_EXPR | REF_EXPR | PREFIX_EXPR | RANGE_EXPR | BIN_EXPR | LITERAL | MACRO_CALL
-            | BOX_EXPR => true,
-            _ => false,
-        }
+impl AstNode for PlaceholderType {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            PLACEHOLDER_TYPE => true,
+            _ => false,
+        }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        let res = match syntax.kind() {
-            TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }),
-            ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
-            PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }),
-            PATH_EXPR => Expr::PathExpr(PathExpr { syntax }),
-            LAMBDA_EXPR => Expr::LambdaExpr(LambdaExpr { syntax }),
-            IF_EXPR => Expr::IfExpr(IfExpr { syntax }),
-            LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }),
-            FOR_EXPR => Expr::ForExpr(ForExpr { syntax }),
-            WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }),
-            CONTINUE_EXPR => Expr::ContinueExpr(ContinueExpr { syntax }),
-            BREAK_EXPR => Expr::BreakExpr(BreakExpr { syntax }),
-            LABEL => Expr::Label(Label { syntax }),
-            BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }),
-            RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }),
-            MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
-            RECORD_LIT => Expr::RecordLit(RecordLit { syntax }),
-            CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
-            INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
-            METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
-            FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
-            AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }),
-            TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
-            TRY_BLOCK_EXPR => Expr::TryBlockExpr(TryBlockExpr { syntax }),
-            CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
-            REF_EXPR => Expr::RefExpr(RefExpr { syntax }),
-            PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }),
-            RANGE_EXPR => Expr::RangeExpr(RangeExpr { syntax }),
-            BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
-            LITERAL => Expr::Literal(Literal { syntax }),
-            MACRO_CALL => Expr::MacroCall(MacroCall { syntax }),
-            BOX_EXPR => Expr::BoxExpr(BoxExpr { syntax }),
-            _ => return None,
-        };
-        Some(res)
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
     }
     fn syntax(&self) -> &SyntaxNode {
-        match self {
-            Expr::TupleExpr(it) => &it.syntax,
-            Expr::ArrayExpr(it) => &it.syntax,
-            Expr::ParenExpr(it) => &it.syntax,
-            Expr::PathExpr(it) => &it.syntax,
-            Expr::LambdaExpr(it) => &it.syntax,
-            Expr::IfExpr(it) => &it.syntax,
-            Expr::LoopExpr(it) => &it.syntax,
-            Expr::ForExpr(it) => &it.syntax,
-            Expr::WhileExpr(it) => &it.syntax,
-            Expr::ContinueExpr(it) => &it.syntax,
-            Expr::BreakExpr(it) => &it.syntax,
-            Expr::Label(it) => &it.syntax,
-            Expr::BlockExpr(it) => &it.syntax,
-            Expr::ReturnExpr(it) => &it.syntax,
-            Expr::MatchExpr(it) => &it.syntax,
-            Expr::RecordLit(it) => &it.syntax,
-            Expr::CallExpr(it) => &it.syntax,
-            Expr::IndexExpr(it) => &it.syntax,
-            Expr::MethodCallExpr(it) => &it.syntax,
-            Expr::FieldExpr(it) => &it.syntax,
-            Expr::AwaitExpr(it) => &it.syntax,
-            Expr::TryExpr(it) => &it.syntax,
-            Expr::TryBlockExpr(it) => &it.syntax,
-            Expr::CastExpr(it) => &it.syntax,
-            Expr::RefExpr(it) => &it.syntax,
-            Expr::PrefixExpr(it) => &it.syntax,
-            Expr::RangeExpr(it) => &it.syntax,
-            Expr::BinExpr(it) => &it.syntax,
-            Expr::Literal(it) => &it.syntax,
-            Expr::MacroCall(it) => &it.syntax,
-            Expr::BoxExpr(it) => &it.syntax,
-        }
+        &self.syntax
     }
 }
-impl Expr {}
+impl PlaceholderType {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ExprStmt {
+pub struct FnPointerType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ExprStmt {
+impl AstNode for FnPointerType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            EXPR_STMT => true,
+            FN_POINTER_TYPE => true,
             _ => false,
         }
     }
@@ -1036,19 +840,22 @@ impl AstNode for ExprStmt {
         &self.syntax
     }
 }
-impl ExprStmt {
-    pub fn expr(&self) -> Option<Expr> {
+impl FnPointerType {
+    pub fn param_list(&self) -> Option<ParamList> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn ret_type(&self) -> Option<RetType> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ExternCrateItem {
+pub struct ForType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ExternCrateItem {
+impl AstNode for ForType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            EXTERN_CRATE_ITEM => true,
+            FOR_TYPE => true,
             _ => false,
         }
     }
@@ -1063,24 +870,19 @@ impl AstNode for ExternCrateItem {
         &self.syntax
     }
 }
-impl ast::AttrsOwner for ExternCrateItem {}
-impl ast::VisibilityOwner for ExternCrateItem {}
-impl ExternCrateItem {
-    pub fn name_ref(&self) -> Option<NameRef> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn alias(&self) -> Option<Alias> {
+impl ForType {
+    pub fn type_ref(&self) -> Option<TypeRef> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct FieldExpr {
+pub struct ImplTraitType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for FieldExpr {
+impl AstNode for ImplTraitType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            FIELD_EXPR => true,
+            IMPL_TRAIT_TYPE => true,
             _ => false,
         }
     }
@@ -1095,22 +897,16 @@ impl AstNode for FieldExpr {
         &self.syntax
     }
 }
-impl FieldExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn name_ref(&self) -> Option<NameRef> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl ast::TypeBoundsOwner for ImplTraitType {}
+impl ImplTraitType {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct FnDef {
+pub struct DynTraitType {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for FnDef {
+impl AstNode for DynTraitType {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            FN_DEF => true,
+            DYN_TRAIT_TYPE => true,
             _ => false,
         }
     }
@@ -1125,30 +921,16 @@ impl AstNode for FnDef {
         &self.syntax
     }
 }
-impl ast::VisibilityOwner for FnDef {}
-impl ast::NameOwner for FnDef {}
-impl ast::TypeParamsOwner for FnDef {}
-impl ast::AttrsOwner for FnDef {}
-impl ast::DocCommentsOwner for FnDef {}
-impl FnDef {
-    pub fn param_list(&self) -> Option<ParamList> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn body(&self) -> Option<BlockExpr> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn ret_type(&self) -> Option<RetType> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl ast::TypeBoundsOwner for DynTraitType {}
+impl DynTraitType {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct FnPointerType {
+pub struct TupleExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for FnPointerType {
+impl AstNode for TupleExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            FN_POINTER_TYPE => true,
+            TUPLE_EXPR => true,
             _ => false,
         }
     }
@@ -1163,22 +945,19 @@ impl AstNode for FnPointerType {
         &self.syntax
     }
 }
-impl FnPointerType {
-    pub fn param_list(&self) -> Option<ParamList> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn ret_type(&self) -> Option<RetType> {
-        AstChildren::new(&self.syntax).next()
+impl TupleExpr {
+    pub fn exprs(&self) -> AstChildren<Expr> {
+        AstChildren::new(&self.syntax)
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ForExpr {
+pub struct ArrayExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ForExpr {
+impl AstNode for ArrayExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            FOR_EXPR => true,
+            ARRAY_EXPR => true,
             _ => false,
         }
     }
@@ -1193,23 +972,19 @@ impl AstNode for ForExpr {
         &self.syntax
     }
 }
-impl ast::LoopBodyOwner for ForExpr {}
-impl ForExpr {
-    pub fn pat(&self) -> Option<Pat> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn iterable(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
+impl ArrayExpr {
+    pub fn exprs(&self) -> AstChildren<Expr> {
+        AstChildren::new(&self.syntax)
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ForType {
+pub struct ParenExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ForType {
+impl AstNode for ParenExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            FOR_TYPE => true,
+            PAREN_EXPR => true,
             _ => false,
         }
     }
@@ -1224,19 +999,19 @@ impl AstNode for ForType {
         &self.syntax
     }
 }
-impl ForType {
-    pub fn type_ref(&self) -> Option<TypeRef> {
+impl ParenExpr {
+    pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct IfExpr {
+pub struct PathExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for IfExpr {
+impl AstNode for PathExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            IF_EXPR => true,
+            PATH_EXPR => true,
             _ => false,
         }
     }
@@ -1251,19 +1026,19 @@ impl AstNode for IfExpr {
         &self.syntax
     }
 }
-impl IfExpr {
-    pub fn condition(&self) -> Option<Condition> {
+impl PathExpr {
+    pub fn path(&self) -> Option<Path> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ImplBlock {
+pub struct LambdaExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ImplBlock {
+impl AstNode for LambdaExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            IMPL_BLOCK => true,
+            LAMBDA_EXPR => true,
             _ => false,
         }
     }
@@ -1278,68 +1053,25 @@ impl AstNode for ImplBlock {
         &self.syntax
     }
 }
-impl ast::TypeParamsOwner for ImplBlock {}
-impl ast::AttrsOwner for ImplBlock {}
-impl ImplBlock {
-    pub fn item_list(&self) -> Option<ItemList> {
+impl LambdaExpr {
+    pub fn param_list(&self) -> Option<ParamList> {
         AstChildren::new(&self.syntax).next()
     }
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ImplItem {
-    FnDef(FnDef),
-    TypeAliasDef(TypeAliasDef),
-    ConstDef(ConstDef),
-}
-impl From<FnDef> for ImplItem {
-    fn from(node: FnDef) -> ImplItem {
-        ImplItem::FnDef(node)
-    }
-}
-impl From<TypeAliasDef> for ImplItem {
-    fn from(node: TypeAliasDef) -> ImplItem {
-        ImplItem::TypeAliasDef(node)
-    }
-}
-impl From<ConstDef> for ImplItem {
-    fn from(node: ConstDef) -> ImplItem {
-        ImplItem::ConstDef(node)
-    }
-}
-impl AstNode for ImplItem {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            FN_DEF | TYPE_ALIAS_DEF | CONST_DEF => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        let res = match syntax.kind() {
-            FN_DEF => ImplItem::FnDef(FnDef { syntax }),
-            TYPE_ALIAS_DEF => ImplItem::TypeAliasDef(TypeAliasDef { syntax }),
-            CONST_DEF => ImplItem::ConstDef(ConstDef { syntax }),
-            _ => return None,
-        };
-        Some(res)
+    pub fn ret_type(&self) -> Option<RetType> {
+        AstChildren::new(&self.syntax).next()
     }
-    fn syntax(&self) -> &SyntaxNode {
-        match self {
-            ImplItem::FnDef(it) => &it.syntax,
-            ImplItem::TypeAliasDef(it) => &it.syntax,
-            ImplItem::ConstDef(it) => &it.syntax,
-        }
+    pub fn body(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
     }
 }
-impl ast::AttrsOwner for ImplItem {}
-impl ImplItem {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ImplTraitType {
+pub struct IfExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ImplTraitType {
+impl AstNode for IfExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            IMPL_TRAIT_TYPE => true,
+            IF_EXPR => true,
             _ => false,
         }
     }
@@ -1354,16 +1086,19 @@ impl AstNode for ImplTraitType {
         &self.syntax
     }
 }
-impl ast::TypeBoundsOwner for ImplTraitType {}
-impl ImplTraitType {}
+impl IfExpr {
+    pub fn condition(&self) -> Option<Condition> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct IndexExpr {
+pub struct LoopExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for IndexExpr {
+impl AstNode for LoopExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            INDEX_EXPR => true,
+            LOOP_EXPR => true,
             _ => false,
         }
     }
@@ -1378,15 +1113,16 @@ impl AstNode for IndexExpr {
         &self.syntax
     }
 }
-impl IndexExpr {}
+impl ast::LoopBodyOwner for LoopExpr {}
+impl LoopExpr {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ItemList {
+pub struct TryBlockExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ItemList {
+impl AstNode for TryBlockExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            ITEM_LIST => true,
+            TRY_BLOCK_EXPR => true,
             _ => false,
         }
     }
@@ -1401,21 +1137,19 @@ impl AstNode for ItemList {
         &self.syntax
     }
 }
-impl ast::FnDefOwner for ItemList {}
-impl ast::ModuleItemOwner for ItemList {}
-impl ItemList {
-    pub fn impl_items(&self) -> AstChildren<ImplItem> {
-        AstChildren::new(&self.syntax)
+impl TryBlockExpr {
+    pub fn body(&self) -> Option<BlockExpr> {
+        AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Label {
+pub struct ForExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for Label {
+impl AstNode for ForExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            LABEL => true,
+            FOR_EXPR => true,
             _ => false,
         }
     }
@@ -1430,15 +1164,23 @@ impl AstNode for Label {
         &self.syntax
     }
 }
-impl Label {}
+impl ast::LoopBodyOwner for ForExpr {}
+impl ForExpr {
+    pub fn pat(&self) -> Option<Pat> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn iterable(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LambdaExpr {
+pub struct WhileExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for LambdaExpr {
+impl AstNode for WhileExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            LAMBDA_EXPR => true,
+            WHILE_EXPR => true,
             _ => false,
         }
     }
@@ -1453,25 +1195,20 @@ impl AstNode for LambdaExpr {
         &self.syntax
     }
 }
-impl LambdaExpr {
-    pub fn param_list(&self) -> Option<ParamList> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn ret_type(&self) -> Option<RetType> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn body(&self) -> Option<Expr> {
+impl ast::LoopBodyOwner for WhileExpr {}
+impl WhileExpr {
+    pub fn condition(&self) -> Option<Condition> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LetStmt {
+pub struct ContinueExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for LetStmt {
+impl AstNode for ContinueExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            LET_STMT => true,
+            CONTINUE_EXPR => true,
             _ => false,
         }
     }
@@ -1486,23 +1223,15 @@ impl AstNode for LetStmt {
         &self.syntax
     }
 }
-impl ast::TypeAscriptionOwner for LetStmt {}
-impl LetStmt {
-    pub fn pat(&self) -> Option<Pat> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn initializer(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl ContinueExpr {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LifetimeArg {
+pub struct BreakExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for LifetimeArg {
+impl AstNode for BreakExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            LIFETIME_ARG => true,
+            BREAK_EXPR => true,
             _ => false,
         }
     }
@@ -1517,15 +1246,19 @@ impl AstNode for LifetimeArg {
         &self.syntax
     }
 }
-impl LifetimeArg {}
+impl BreakExpr {
+    pub fn expr(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LifetimeParam {
+pub struct Label {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for LifetimeParam {
+impl AstNode for Label {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            LIFETIME_PARAM => true,
+            LABEL => true,
             _ => false,
         }
     }
@@ -1540,16 +1273,15 @@ impl AstNode for LifetimeParam {
         &self.syntax
     }
 }
-impl ast::AttrsOwner for LifetimeParam {}
-impl LifetimeParam {}
+impl Label {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Literal {
+pub struct BlockExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for Literal {
+impl AstNode for BlockExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            LITERAL => true,
+            BLOCK_EXPR => true,
             _ => false,
         }
     }
@@ -1564,15 +1296,19 @@ impl AstNode for Literal {
         &self.syntax
     }
 }
-impl Literal {}
+impl BlockExpr {
+    pub fn block(&self) -> Option<Block> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LiteralPat {
+pub struct ReturnExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for LiteralPat {
+impl AstNode for ReturnExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            LITERAL_PAT => true,
+            RETURN_EXPR => true,
             _ => false,
         }
     }
@@ -1587,19 +1323,19 @@ impl AstNode for LiteralPat {
         &self.syntax
     }
 }
-impl LiteralPat {
-    pub fn literal(&self) -> Option<Literal> {
-        AstChildren::new(&self.syntax).next()
+impl ReturnExpr {
+    pub fn expr(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct LoopExpr {
+pub struct CallExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for LoopExpr {
+impl AstNode for CallExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            LOOP_EXPR => true,
+            CALL_EXPR => true,
             _ => false,
         }
     }
@@ -1614,16 +1350,20 @@ impl AstNode for LoopExpr {
         &self.syntax
     }
 }
-impl ast::LoopBodyOwner for LoopExpr {}
-impl LoopExpr {}
+impl ast::ArgListOwner for CallExpr {}
+impl CallExpr {
+    pub fn expr(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MacroCall {
+pub struct MethodCallExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for MacroCall {
+impl AstNode for MethodCallExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            MACRO_CALL => true,
+            METHOD_CALL_EXPR => true,
             _ => false,
         }
     }
@@ -1638,25 +1378,26 @@ impl AstNode for MacroCall {
         &self.syntax
     }
 }
-impl ast::NameOwner for MacroCall {}
-impl ast::AttrsOwner for MacroCall {}
-impl ast::DocCommentsOwner for MacroCall {}
-impl MacroCall {
-    pub fn token_tree(&self) -> Option<TokenTree> {
+impl ast::ArgListOwner for MethodCallExpr {}
+impl MethodCallExpr {
+    pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
-    pub fn path(&self) -> Option<Path> {
+    pub fn name_ref(&self) -> Option<NameRef> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn type_arg_list(&self) -> Option<TypeArgList> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MacroItems {
+pub struct IndexExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for MacroItems {
+impl AstNode for IndexExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            MACRO_ITEMS => true,
+            INDEX_EXPR => true,
             _ => false,
         }
     }
@@ -1671,17 +1412,15 @@ impl AstNode for MacroItems {
         &self.syntax
     }
 }
-impl ast::ModuleItemOwner for MacroItems {}
-impl ast::FnDefOwner for MacroItems {}
-impl MacroItems {}
+impl IndexExpr {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MacroStmts {
+pub struct FieldExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for MacroStmts {
+impl AstNode for FieldExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            MACRO_STMTS => true,
+            FIELD_EXPR => true,
             _ => false,
         }
     }
@@ -1696,22 +1435,22 @@ impl AstNode for MacroStmts {
         &self.syntax
     }
 }
-impl MacroStmts {
-    pub fn statements(&self) -> AstChildren<Stmt> {
-        AstChildren::new(&self.syntax)
-    }
+impl FieldExpr {
     pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
+    pub fn name_ref(&self) -> Option<NameRef> {
+        AstChildren::new(&self.syntax).next()
+    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MatchArm {
+pub struct AwaitExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for MatchArm {
+impl AstNode for AwaitExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            MATCH_ARM => true,
+            AWAIT_EXPR => true,
             _ => false,
         }
     }
@@ -1726,26 +1465,19 @@ impl AstNode for MatchArm {
         &self.syntax
     }
 }
-impl ast::AttrsOwner for MatchArm {}
-impl MatchArm {
-    pub fn pats(&self) -> AstChildren<Pat> {
-        AstChildren::new(&self.syntax)
-    }
-    pub fn guard(&self) -> Option<MatchGuard> {
-        AstChildren::new(&self.syntax).next()
-    }
+impl AwaitExpr {
     pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MatchArmList {
+pub struct TryExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for MatchArmList {
+impl AstNode for TryExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            MATCH_ARM_LIST => true,
+            TRY_EXPR => true,
             _ => false,
         }
     }
@@ -1760,20 +1492,19 @@ impl AstNode for MatchArmList {
         &self.syntax
     }
 }
-impl ast::AttrsOwner for MatchArmList {}
-impl MatchArmList {
-    pub fn arms(&self) -> AstChildren<MatchArm> {
-        AstChildren::new(&self.syntax)
+impl TryExpr {
+    pub fn expr(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MatchExpr {
+pub struct CastExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for MatchExpr {
+impl AstNode for CastExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            MATCH_EXPR => true,
+            CAST_EXPR => true,
             _ => false,
         }
     }
@@ -1788,22 +1519,22 @@ impl AstNode for MatchExpr {
         &self.syntax
     }
 }
-impl MatchExpr {
+impl CastExpr {
     pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
-    pub fn match_arm_list(&self) -> Option<MatchArmList> {
+    pub fn type_ref(&self) -> Option<TypeRef> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MatchGuard {
+pub struct RefExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for MatchGuard {
+impl AstNode for RefExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            MATCH_GUARD => true,
+            REF_EXPR => true,
             _ => false,
         }
     }
@@ -1818,19 +1549,19 @@ impl AstNode for MatchGuard {
         &self.syntax
     }
 }
-impl MatchGuard {
+impl RefExpr {
     pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MethodCallExpr {
+pub struct PrefixExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for MethodCallExpr {
+impl AstNode for PrefixExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            METHOD_CALL_EXPR => true,
+            PREFIX_EXPR => true,
             _ => false,
         }
     }
@@ -1845,26 +1576,19 @@ impl AstNode for MethodCallExpr {
         &self.syntax
     }
 }
-impl ast::ArgListOwner for MethodCallExpr {}
-impl MethodCallExpr {
+impl PrefixExpr {
     pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
-    pub fn name_ref(&self) -> Option<NameRef> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn type_arg_list(&self) -> Option<TypeArgList> {
-        AstChildren::new(&self.syntax).next()
-    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Module {
+pub struct BoxExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for Module {
+impl AstNode for BoxExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            MODULE => true,
+            BOX_EXPR => true,
             _ => false,
         }
     }
@@ -1879,144 +1603,118 @@ impl AstNode for Module {
         &self.syntax
     }
 }
-impl ast::VisibilityOwner for Module {}
-impl ast::NameOwner for Module {}
-impl ast::AttrsOwner for Module {}
-impl ast::DocCommentsOwner for Module {}
-impl Module {
-    pub fn item_list(&self) -> Option<ItemList> {
+impl BoxExpr {
+    pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ModuleItem {
-    StructDef(StructDef),
-    UnionDef(UnionDef),
-    EnumDef(EnumDef),
-    FnDef(FnDef),
-    TraitDef(TraitDef),
-    TypeAliasDef(TypeAliasDef),
-    ImplBlock(ImplBlock),
-    UseItem(UseItem),
-    ExternCrateItem(ExternCrateItem),
-    ConstDef(ConstDef),
-    StaticDef(StaticDef),
-    Module(Module),
+pub struct RangeExpr {
+    pub(crate) syntax: SyntaxNode,
 }
-impl From<StructDef> for ModuleItem {
-    fn from(node: StructDef) -> ModuleItem {
-        ModuleItem::StructDef(node)
+impl AstNode for RangeExpr {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            RANGE_EXPR => true,
+            _ => false,
+        }
     }
-}
-impl From<UnionDef> for ModuleItem {
-    fn from(node: UnionDef) -> ModuleItem {
-        ModuleItem::UnionDef(node)
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
     }
-}
-impl From<EnumDef> for ModuleItem {
-    fn from(node: EnumDef) -> ModuleItem {
-        ModuleItem::EnumDef(node)
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
     }
 }
-impl From<FnDef> for ModuleItem {
-    fn from(node: FnDef) -> ModuleItem {
-        ModuleItem::FnDef(node)
-    }
+impl RangeExpr {}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct BinExpr {
+    pub(crate) syntax: SyntaxNode,
 }
-impl From<TraitDef> for ModuleItem {
-    fn from(node: TraitDef) -> ModuleItem {
-        ModuleItem::TraitDef(node)
+impl AstNode for BinExpr {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            BIN_EXPR => true,
+            _ => false,
+        }
     }
-}
-impl From<TypeAliasDef> for ModuleItem {
-    fn from(node: TypeAliasDef) -> ModuleItem {
-        ModuleItem::TypeAliasDef(node)
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
     }
-}
-impl From<ImplBlock> for ModuleItem {
-    fn from(node: ImplBlock) -> ModuleItem {
-        ModuleItem::ImplBlock(node)
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
     }
 }
-impl From<UseItem> for ModuleItem {
-    fn from(node: UseItem) -> ModuleItem {
-        ModuleItem::UseItem(node)
-    }
+impl BinExpr {}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Literal {
+    pub(crate) syntax: SyntaxNode,
 }
-impl From<ExternCrateItem> for ModuleItem {
-    fn from(node: ExternCrateItem) -> ModuleItem {
-        ModuleItem::ExternCrateItem(node)
+impl AstNode for Literal {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            LITERAL => true,
+            _ => false,
+        }
     }
-}
-impl From<ConstDef> for ModuleItem {
-    fn from(node: ConstDef) -> ModuleItem {
-        ModuleItem::ConstDef(node)
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
     }
-}
-impl From<StaticDef> for ModuleItem {
-    fn from(node: StaticDef) -> ModuleItem {
-        ModuleItem::StaticDef(node)
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
     }
 }
-impl From<Module> for ModuleItem {
-    fn from(node: Module) -> ModuleItem {
-        ModuleItem::Module(node)
-    }
+impl Literal {}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MatchExpr {
+    pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ModuleItem {
+impl AstNode for MatchExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            STRUCT_DEF | UNION_DEF | ENUM_DEF | FN_DEF | TRAIT_DEF | TYPE_ALIAS_DEF
-            | IMPL_BLOCK | USE_ITEM | EXTERN_CRATE_ITEM | CONST_DEF | STATIC_DEF | MODULE => true,
+            MATCH_EXPR => true,
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        let res = match syntax.kind() {
-            STRUCT_DEF => ModuleItem::StructDef(StructDef { syntax }),
-            UNION_DEF => ModuleItem::UnionDef(UnionDef { syntax }),
-            ENUM_DEF => ModuleItem::EnumDef(EnumDef { syntax }),
-            FN_DEF => ModuleItem::FnDef(FnDef { syntax }),
-            TRAIT_DEF => ModuleItem::TraitDef(TraitDef { syntax }),
-            TYPE_ALIAS_DEF => ModuleItem::TypeAliasDef(TypeAliasDef { syntax }),
-            IMPL_BLOCK => ModuleItem::ImplBlock(ImplBlock { syntax }),
-            USE_ITEM => ModuleItem::UseItem(UseItem { syntax }),
-            EXTERN_CRATE_ITEM => ModuleItem::ExternCrateItem(ExternCrateItem { syntax }),
-            CONST_DEF => ModuleItem::ConstDef(ConstDef { syntax }),
-            STATIC_DEF => ModuleItem::StaticDef(StaticDef { syntax }),
-            MODULE => ModuleItem::Module(Module { syntax }),
-            _ => return None,
-        };
-        Some(res)
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
     }
     fn syntax(&self) -> &SyntaxNode {
-        match self {
-            ModuleItem::StructDef(it) => &it.syntax,
-            ModuleItem::UnionDef(it) => &it.syntax,
-            ModuleItem::EnumDef(it) => &it.syntax,
-            ModuleItem::FnDef(it) => &it.syntax,
-            ModuleItem::TraitDef(it) => &it.syntax,
-            ModuleItem::TypeAliasDef(it) => &it.syntax,
-            ModuleItem::ImplBlock(it) => &it.syntax,
-            ModuleItem::UseItem(it) => &it.syntax,
-            ModuleItem::ExternCrateItem(it) => &it.syntax,
-            ModuleItem::ConstDef(it) => &it.syntax,
-            ModuleItem::StaticDef(it) => &it.syntax,
-            ModuleItem::Module(it) => &it.syntax,
-        }
+        &self.syntax
+    }
+}
+impl MatchExpr {
+    pub fn expr(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn match_arm_list(&self) -> Option<MatchArmList> {
+        AstChildren::new(&self.syntax).next()
     }
 }
-impl ast::AttrsOwner for ModuleItem {}
-impl ast::VisibilityOwner for ModuleItem {}
-impl ModuleItem {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Name {
+pub struct MatchArmList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for Name {
+impl AstNode for MatchArmList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            NAME => true,
+            MATCH_ARM_LIST => true,
             _ => false,
         }
     }
@@ -2031,15 +1729,20 @@ impl AstNode for Name {
         &self.syntax
     }
 }
-impl Name {}
+impl ast::AttrsOwner for MatchArmList {}
+impl MatchArmList {
+    pub fn arms(&self) -> AstChildren<MatchArm> {
+        AstChildren::new(&self.syntax)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NameRef {
+pub struct MatchArm {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for NameRef {
+impl AstNode for MatchArm {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            NAME_REF => true,
+            MATCH_ARM => true,
             _ => false,
         }
     }
@@ -2054,15 +1757,26 @@ impl AstNode for NameRef {
         &self.syntax
     }
 }
-impl NameRef {}
+impl ast::AttrsOwner for MatchArm {}
+impl MatchArm {
+    pub fn pats(&self) -> AstChildren<Pat> {
+        AstChildren::new(&self.syntax)
+    }
+    pub fn guard(&self) -> Option<MatchGuard> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn expr(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NeverType {
+pub struct MatchGuard {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for NeverType {
+impl AstNode for MatchGuard {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            NEVER_TYPE => true,
+            MATCH_GUARD => true,
             _ => false,
         }
     }
@@ -2077,64 +1791,49 @@ impl AstNode for NeverType {
         &self.syntax
     }
 }
-impl NeverType {}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum NominalDef {
-    StructDef(StructDef),
-    EnumDef(EnumDef),
-    UnionDef(UnionDef),
-}
-impl From<StructDef> for NominalDef {
-    fn from(node: StructDef) -> NominalDef {
-        NominalDef::StructDef(node)
-    }
-}
-impl From<EnumDef> for NominalDef {
-    fn from(node: EnumDef) -> NominalDef {
-        NominalDef::EnumDef(node)
+impl MatchGuard {
+    pub fn expr(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
     }
 }
-impl From<UnionDef> for NominalDef {
-    fn from(node: UnionDef) -> NominalDef {
-        NominalDef::UnionDef(node)
-    }
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RecordLit {
+    pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for NominalDef {
+impl AstNode for RecordLit {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            STRUCT_DEF | ENUM_DEF | UNION_DEF => true,
+            RECORD_LIT => true,
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        let res = match syntax.kind() {
-            STRUCT_DEF => NominalDef::StructDef(StructDef { syntax }),
-            ENUM_DEF => NominalDef::EnumDef(EnumDef { syntax }),
-            UNION_DEF => NominalDef::UnionDef(UnionDef { syntax }),
-            _ => return None,
-        };
-        Some(res)
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
     }
     fn syntax(&self) -> &SyntaxNode {
-        match self {
-            NominalDef::StructDef(it) => &it.syntax,
-            NominalDef::EnumDef(it) => &it.syntax,
-            NominalDef::UnionDef(it) => &it.syntax,
-        }
+        &self.syntax
+    }
+}
+impl RecordLit {
+    pub fn path(&self) -> Option<Path> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn record_field_list(&self) -> Option<RecordFieldList> {
+        AstChildren::new(&self.syntax).next()
     }
 }
-impl ast::NameOwner for NominalDef {}
-impl ast::TypeParamsOwner for NominalDef {}
-impl ast::AttrsOwner for NominalDef {}
-impl NominalDef {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Param {
+pub struct RecordFieldList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for Param {
+impl AstNode for RecordFieldList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PARAM => true,
+            RECORD_FIELD_LIST => true,
             _ => false,
         }
     }
@@ -2149,21 +1848,22 @@ impl AstNode for Param {
         &self.syntax
     }
 }
-impl ast::TypeAscriptionOwner for Param {}
-impl ast::AttrsOwner for Param {}
-impl Param {
-    pub fn pat(&self) -> Option<Pat> {
+impl RecordFieldList {
+    pub fn fields(&self) -> AstChildren<RecordField> {
+        AstChildren::new(&self.syntax)
+    }
+    pub fn spread(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParamList {
+pub struct RecordField {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ParamList {
+impl AstNode for RecordField {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PARAM_LIST => true,
+            RECORD_FIELD => true,
             _ => false,
         }
     }
@@ -2178,22 +1878,22 @@ impl AstNode for ParamList {
         &self.syntax
     }
 }
-impl ParamList {
-    pub fn params(&self) -> AstChildren<Param> {
-        AstChildren::new(&self.syntax)
+impl RecordField {
+    pub fn name_ref(&self) -> Option<NameRef> {
+        AstChildren::new(&self.syntax).next()
     }
-    pub fn self_param(&self) -> Option<SelfParam> {
+    pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParenExpr {
+pub struct RefPat {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ParenExpr {
+impl AstNode for RefPat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PAREN_EXPR => true,
+            REF_PAT => true,
             _ => false,
         }
     }
@@ -2208,19 +1908,19 @@ impl AstNode for ParenExpr {
         &self.syntax
     }
 }
-impl ParenExpr {
-    pub fn expr(&self) -> Option<Expr> {
+impl RefPat {
+    pub fn pat(&self) -> Option<Pat> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ParenType {
+pub struct BoxPat {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ParenType {
+impl AstNode for BoxPat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PAREN_TYPE => true,
+            BOX_PAT => true,
             _ => false,
         }
     }
@@ -2235,140 +1935,70 @@ impl AstNode for ParenType {
         &self.syntax
     }
 }
-impl ParenType {
-    pub fn type_ref(&self) -> Option<TypeRef> {
+impl BoxPat {
+    pub fn pat(&self) -> Option<Pat> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Pat {
-    RefPat(RefPat),
-    BoxPat(BoxPat),
-    BindPat(BindPat),
-    PlaceholderPat(PlaceholderPat),
-    DotDotPat(DotDotPat),
-    PathPat(PathPat),
-    RecordPat(RecordPat),
-    TupleStructPat(TupleStructPat),
-    TuplePat(TuplePat),
-    SlicePat(SlicePat),
-    RangePat(RangePat),
-    LiteralPat(LiteralPat),
+pub struct BindPat {
+    pub(crate) syntax: SyntaxNode,
 }
-impl From<RefPat> for Pat {
-    fn from(node: RefPat) -> Pat {
-        Pat::RefPat(node)
+impl AstNode for BindPat {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            BIND_PAT => true,
+            _ => false,
+        }
     }
-}
-impl From<BoxPat> for Pat {
-    fn from(node: BoxPat) -> Pat {
-        Pat::BoxPat(node)
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
     }
-}
-impl From<BindPat> for Pat {
-    fn from(node: BindPat) -> Pat {
-        Pat::BindPat(node)
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
     }
 }
-impl From<PlaceholderPat> for Pat {
-    fn from(node: PlaceholderPat) -> Pat {
-        Pat::PlaceholderPat(node)
+impl ast::NameOwner for BindPat {}
+impl BindPat {
+    pub fn pat(&self) -> Option<Pat> {
+        AstChildren::new(&self.syntax).next()
     }
 }
-impl From<DotDotPat> for Pat {
-    fn from(node: DotDotPat) -> Pat {
-        Pat::DotDotPat(node)
-    }
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PlaceholderPat {
+    pub(crate) syntax: SyntaxNode,
 }
-impl From<PathPat> for Pat {
-    fn from(node: PathPat) -> Pat {
-        Pat::PathPat(node)
-    }
-}
-impl From<RecordPat> for Pat {
-    fn from(node: RecordPat) -> Pat {
-        Pat::RecordPat(node)
-    }
-}
-impl From<TupleStructPat> for Pat {
-    fn from(node: TupleStructPat) -> Pat {
-        Pat::TupleStructPat(node)
-    }
-}
-impl From<TuplePat> for Pat {
-    fn from(node: TuplePat) -> Pat {
-        Pat::TuplePat(node)
-    }
-}
-impl From<SlicePat> for Pat {
-    fn from(node: SlicePat) -> Pat {
-        Pat::SlicePat(node)
-    }
-}
-impl From<RangePat> for Pat {
-    fn from(node: RangePat) -> Pat {
-        Pat::RangePat(node)
-    }
-}
-impl From<LiteralPat> for Pat {
-    fn from(node: LiteralPat) -> Pat {
-        Pat::LiteralPat(node)
-    }
-}
-impl AstNode for Pat {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            REF_PAT | BOX_PAT | BIND_PAT | PLACEHOLDER_PAT | DOT_DOT_PAT | PATH_PAT
-            | RECORD_PAT | TUPLE_STRUCT_PAT | TUPLE_PAT | SLICE_PAT | RANGE_PAT | LITERAL_PAT => {
-                true
-            }
-            _ => false,
-        }
+impl AstNode for PlaceholderPat {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            PLACEHOLDER_PAT => true,
+            _ => false,
+        }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        let res = match syntax.kind() {
-            REF_PAT => Pat::RefPat(RefPat { syntax }),
-            BOX_PAT => Pat::BoxPat(BoxPat { syntax }),
-            BIND_PAT => Pat::BindPat(BindPat { syntax }),
-            PLACEHOLDER_PAT => Pat::PlaceholderPat(PlaceholderPat { syntax }),
-            DOT_DOT_PAT => Pat::DotDotPat(DotDotPat { syntax }),
-            PATH_PAT => Pat::PathPat(PathPat { syntax }),
-            RECORD_PAT => Pat::RecordPat(RecordPat { syntax }),
-            TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
-            TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
-            SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
-            RANGE_PAT => Pat::RangePat(RangePat { syntax }),
-            LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }),
-            _ => return None,
-        };
-        Some(res)
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
     }
     fn syntax(&self) -> &SyntaxNode {
-        match self {
-            Pat::RefPat(it) => &it.syntax,
-            Pat::BoxPat(it) => &it.syntax,
-            Pat::BindPat(it) => &it.syntax,
-            Pat::PlaceholderPat(it) => &it.syntax,
-            Pat::DotDotPat(it) => &it.syntax,
-            Pat::PathPat(it) => &it.syntax,
-            Pat::RecordPat(it) => &it.syntax,
-            Pat::TupleStructPat(it) => &it.syntax,
-            Pat::TuplePat(it) => &it.syntax,
-            Pat::SlicePat(it) => &it.syntax,
-            Pat::RangePat(it) => &it.syntax,
-            Pat::LiteralPat(it) => &it.syntax,
-        }
+        &self.syntax
     }
 }
-impl Pat {}
+impl PlaceholderPat {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Path {
+pub struct DotDotPat {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for Path {
+impl AstNode for DotDotPat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PATH => true,
+            DOT_DOT_PAT => true,
             _ => false,
         }
     }
@@ -2383,22 +2013,15 @@ impl AstNode for Path {
         &self.syntax
     }
 }
-impl Path {
-    pub fn segment(&self) -> Option<PathSegment> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn qualifier(&self) -> Option<Path> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl DotDotPat {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PathExpr {
+pub struct PathPat {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for PathExpr {
+impl AstNode for PathPat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PATH_EXPR => true,
+            PATH_PAT => true,
             _ => false,
         }
     }
@@ -2413,19 +2036,19 @@ impl AstNode for PathExpr {
         &self.syntax
     }
 }
-impl PathExpr {
+impl PathPat {
     pub fn path(&self) -> Option<Path> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PathPat {
+pub struct SlicePat {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for PathPat {
+impl AstNode for SlicePat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PATH_PAT => true,
+            SLICE_PAT => true,
             _ => false,
         }
     }
@@ -2440,19 +2063,15 @@ impl AstNode for PathPat {
         &self.syntax
     }
 }
-impl PathPat {
-    pub fn path(&self) -> Option<Path> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl SlicePat {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PathSegment {
+pub struct RangePat {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for PathSegment {
+impl AstNode for RangePat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PATH_SEGMENT => true,
+            RANGE_PAT => true,
             _ => false,
         }
     }
@@ -2467,31 +2086,15 @@ impl AstNode for PathSegment {
         &self.syntax
     }
 }
-impl PathSegment {
-    pub fn name_ref(&self) -> Option<NameRef> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn type_arg_list(&self) -> Option<TypeArgList> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn param_list(&self) -> Option<ParamList> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn ret_type(&self) -> Option<RetType> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn path_type(&self) -> Option<PathType> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl RangePat {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PathType {
+pub struct LiteralPat {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for PathType {
+impl AstNode for LiteralPat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PATH_TYPE => true,
+            LITERAL_PAT => true,
             _ => false,
         }
     }
@@ -2506,19 +2109,19 @@ impl AstNode for PathType {
         &self.syntax
     }
 }
-impl PathType {
-    pub fn path(&self) -> Option<Path> {
+impl LiteralPat {
+    pub fn literal(&self) -> Option<Literal> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PlaceholderPat {
+pub struct RecordPat {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for PlaceholderPat {
+impl AstNode for RecordPat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PLACEHOLDER_PAT => true,
+            RECORD_PAT => true,
             _ => false,
         }
     }
@@ -2533,15 +2136,22 @@ impl AstNode for PlaceholderPat {
         &self.syntax
     }
 }
-impl PlaceholderPat {}
+impl RecordPat {
+    pub fn record_field_pat_list(&self) -> Option<RecordFieldPatList> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn path(&self) -> Option<Path> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PlaceholderType {
+pub struct RecordFieldPatList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for PlaceholderType {
+impl AstNode for RecordFieldPatList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PLACEHOLDER_TYPE => true,
+            RECORD_FIELD_PAT_LIST => true,
             _ => false,
         }
     }
@@ -2556,15 +2166,22 @@ impl AstNode for PlaceholderType {
         &self.syntax
     }
 }
-impl PlaceholderType {}
+impl RecordFieldPatList {
+    pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> {
+        AstChildren::new(&self.syntax)
+    }
+    pub fn bind_pats(&self) -> AstChildren<BindPat> {
+        AstChildren::new(&self.syntax)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PointerType {
+pub struct RecordFieldPat {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for PointerType {
+impl AstNode for RecordFieldPat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            POINTER_TYPE => true,
+            RECORD_FIELD_PAT => true,
             _ => false,
         }
     }
@@ -2579,19 +2196,20 @@ impl AstNode for PointerType {
         &self.syntax
     }
 }
-impl PointerType {
-    pub fn type_ref(&self) -> Option<TypeRef> {
+impl ast::NameOwner for RecordFieldPat {}
+impl RecordFieldPat {
+    pub fn pat(&self) -> Option<Pat> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PrefixExpr {
+pub struct TupleStructPat {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for PrefixExpr {
+impl AstNode for TupleStructPat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PREFIX_EXPR => true,
+            TUPLE_STRUCT_PAT => true,
             _ => false,
         }
     }
@@ -2606,19 +2224,22 @@ impl AstNode for PrefixExpr {
         &self.syntax
     }
 }
-impl PrefixExpr {
-    pub fn expr(&self) -> Option<Expr> {
+impl TupleStructPat {
+    pub fn path(&self) -> Option<Path> {
         AstChildren::new(&self.syntax).next()
     }
+    pub fn args(&self) -> AstChildren<Pat> {
+        AstChildren::new(&self.syntax)
+    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RangeExpr {
+pub struct TuplePat {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RangeExpr {
+impl AstNode for TuplePat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RANGE_EXPR => true,
+            TUPLE_PAT => true,
             _ => false,
         }
     }
@@ -2633,15 +2254,19 @@ impl AstNode for RangeExpr {
         &self.syntax
     }
 }
-impl RangeExpr {}
+impl TuplePat {
+    pub fn args(&self) -> AstChildren<Pat> {
+        AstChildren::new(&self.syntax)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RangePat {
+pub struct Visibility {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RangePat {
+impl AstNode for Visibility {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RANGE_PAT => true,
+            VISIBILITY => true,
             _ => false,
         }
     }
@@ -2656,15 +2281,15 @@ impl AstNode for RangePat {
         &self.syntax
     }
 }
-impl RangePat {}
+impl Visibility {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordField {
+pub struct Name {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RecordField {
+impl AstNode for Name {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RECORD_FIELD => true,
+            NAME => true,
             _ => false,
         }
     }
@@ -2679,22 +2304,15 @@ impl AstNode for RecordField {
         &self.syntax
     }
 }
-impl RecordField {
-    pub fn name_ref(&self) -> Option<NameRef> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl Name {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordFieldDef {
+pub struct NameRef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RecordFieldDef {
+impl AstNode for NameRef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RECORD_FIELD_DEF => true,
+            NAME_REF => true,
             _ => false,
         }
     }
@@ -2709,20 +2327,15 @@ impl AstNode for RecordFieldDef {
         &self.syntax
     }
 }
-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 {}
+impl NameRef {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordFieldDefList {
+pub struct MacroCall {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RecordFieldDefList {
+impl AstNode for MacroCall {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RECORD_FIELD_DEF_LIST => true,
+            MACRO_CALL => true,
             _ => false,
         }
     }
@@ -2737,19 +2350,25 @@ impl AstNode for RecordFieldDefList {
         &self.syntax
     }
 }
-impl RecordFieldDefList {
-    pub fn fields(&self) -> AstChildren<RecordFieldDef> {
-        AstChildren::new(&self.syntax)
-    }
-}
+impl ast::NameOwner for MacroCall {}
+impl ast::AttrsOwner for MacroCall {}
+impl ast::DocCommentsOwner for MacroCall {}
+impl MacroCall {
+    pub fn token_tree(&self) -> Option<TokenTree> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn path(&self) -> Option<Path> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordFieldList {
+pub struct Attr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RecordFieldList {
+impl AstNode for Attr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RECORD_FIELD_LIST => true,
+            ATTR => true,
             _ => false,
         }
     }
@@ -2764,22 +2383,22 @@ impl AstNode for RecordFieldList {
         &self.syntax
     }
 }
-impl RecordFieldList {
-    pub fn fields(&self) -> AstChildren<RecordField> {
-        AstChildren::new(&self.syntax)
+impl Attr {
+    pub fn path(&self) -> Option<Path> {
+        AstChildren::new(&self.syntax).next()
     }
-    pub fn spread(&self) -> Option<Expr> {
+    pub fn input(&self) -> Option<AttrInput> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordFieldPat {
+pub struct TokenTree {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RecordFieldPat {
+impl AstNode for TokenTree {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RECORD_FIELD_PAT => true,
+            TOKEN_TREE => true,
             _ => false,
         }
     }
@@ -2794,20 +2413,15 @@ impl AstNode for RecordFieldPat {
         &self.syntax
     }
 }
-impl ast::NameOwner for RecordFieldPat {}
-impl RecordFieldPat {
-    pub fn pat(&self) -> Option<Pat> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl TokenTree {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordFieldPatList {
+pub struct TypeParamList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RecordFieldPatList {
+impl AstNode for TypeParamList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RECORD_FIELD_PAT_LIST => true,
+            TYPE_PARAM_LIST => true,
             _ => false,
         }
     }
@@ -2822,22 +2436,22 @@ impl AstNode for RecordFieldPatList {
         &self.syntax
     }
 }
-impl RecordFieldPatList {
-    pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> {
+impl TypeParamList {
+    pub fn type_params(&self) -> AstChildren<TypeParam> {
         AstChildren::new(&self.syntax)
     }
-    pub fn bind_pats(&self) -> AstChildren<BindPat> {
+    pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> {
         AstChildren::new(&self.syntax)
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordLit {
+pub struct TypeParam {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RecordLit {
+impl AstNode for TypeParam {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RECORD_LIT => true,
+            TYPE_PARAM => true,
             _ => false,
         }
     }
@@ -2852,22 +2466,22 @@ impl AstNode for RecordLit {
         &self.syntax
     }
 }
-impl RecordLit {
-    pub fn path(&self) -> Option<Path> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn record_field_list(&self) -> Option<RecordFieldList> {
+impl ast::NameOwner for TypeParam {}
+impl ast::AttrsOwner for TypeParam {}
+impl ast::TypeBoundsOwner for TypeParam {}
+impl TypeParam {
+    pub fn default_type(&self) -> Option<TypeRef> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RecordPat {
+pub struct ConstParam {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RecordPat {
+impl AstNode for ConstParam {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RECORD_PAT => true,
+            CONST_PARAM => true,
             _ => false,
         }
     }
@@ -2882,22 +2496,22 @@ impl AstNode for RecordPat {
         &self.syntax
     }
 }
-impl RecordPat {
-    pub fn record_field_pat_list(&self) -> Option<RecordFieldPatList> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn path(&self) -> Option<Path> {
+impl ast::NameOwner for ConstParam {}
+impl ast::AttrsOwner for ConstParam {}
+impl ast::TypeAscriptionOwner for ConstParam {}
+impl ConstParam {
+    pub fn default_val(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RefExpr {
+pub struct LifetimeParam {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RefExpr {
+impl AstNode for LifetimeParam {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            REF_EXPR => true,
+            LIFETIME_PARAM => true,
             _ => false,
         }
     }
@@ -2912,19 +2526,16 @@ impl AstNode for RefExpr {
         &self.syntax
     }
 }
-impl RefExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl ast::AttrsOwner for LifetimeParam {}
+impl LifetimeParam {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RefPat {
+pub struct TypeBound {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RefPat {
+impl AstNode for TypeBound {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            REF_PAT => true,
+            TYPE_BOUND => true,
             _ => false,
         }
     }
@@ -2939,19 +2550,19 @@ impl AstNode for RefPat {
         &self.syntax
     }
 }
-impl RefPat {
-    pub fn pat(&self) -> Option<Pat> {
+impl TypeBound {
+    pub fn type_ref(&self) -> Option<TypeRef> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReferenceType {
+pub struct TypeBoundList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ReferenceType {
+impl AstNode for TypeBoundList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            REFERENCE_TYPE => true,
+            TYPE_BOUND_LIST => true,
             _ => false,
         }
     }
@@ -2966,19 +2577,19 @@ impl AstNode for ReferenceType {
         &self.syntax
     }
 }
-impl ReferenceType {
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        AstChildren::new(&self.syntax).next()
+impl TypeBoundList {
+    pub fn bounds(&self) -> AstChildren<TypeBound> {
+        AstChildren::new(&self.syntax)
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RetType {
+pub struct WherePred {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RetType {
+impl AstNode for WherePred {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RET_TYPE => true,
+            WHERE_PRED => true,
             _ => false,
         }
     }
@@ -2993,19 +2604,20 @@ impl AstNode for RetType {
         &self.syntax
     }
 }
-impl RetType {
+impl ast::TypeBoundsOwner for WherePred {}
+impl WherePred {
     pub fn type_ref(&self) -> Option<TypeRef> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ReturnExpr {
+pub struct WhereClause {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for ReturnExpr {
+impl AstNode for WhereClause {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RETURN_EXPR => true,
+            WHERE_CLAUSE => true,
             _ => false,
         }
     }
@@ -3020,19 +2632,19 @@ impl AstNode for ReturnExpr {
         &self.syntax
     }
 }
-impl ReturnExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
+impl WhereClause {
+    pub fn predicates(&self) -> AstChildren<WherePred> {
+        AstChildren::new(&self.syntax)
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SelfParam {
+pub struct ExprStmt {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for SelfParam {
+impl AstNode for ExprStmt {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            SELF_PARAM => true,
+            EXPR_STMT => true,
             _ => false,
         }
     }
@@ -3047,17 +2659,19 @@ impl AstNode for SelfParam {
         &self.syntax
     }
 }
-impl ast::TypeAscriptionOwner for SelfParam {}
-impl ast::AttrsOwner for SelfParam {}
-impl SelfParam {}
+impl ExprStmt {
+    pub fn expr(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SlicePat {
+pub struct LetStmt {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for SlicePat {
+impl AstNode for LetStmt {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            SLICE_PAT => true,
+            LET_STMT => true,
             _ => false,
         }
     }
@@ -3072,15 +2686,23 @@ impl AstNode for SlicePat {
         &self.syntax
     }
 }
-impl SlicePat {}
+impl ast::TypeAscriptionOwner for LetStmt {}
+impl LetStmt {
+    pub fn pat(&self) -> Option<Pat> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn initializer(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SliceType {
+pub struct Condition {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for SliceType {
+impl AstNode for Condition {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            SLICE_TYPE => true,
+            CONDITION => true,
             _ => false,
         }
     }
@@ -3095,19 +2717,22 @@ impl AstNode for SliceType {
         &self.syntax
     }
 }
-impl SliceType {
-    pub fn type_ref(&self) -> Option<TypeRef> {
+impl Condition {
+    pub fn pat(&self) -> Option<Pat> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct SourceFile {
+pub struct Block {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for SourceFile {
+impl AstNode for Block {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            SOURCE_FILE => true,
+            BLOCK => true,
             _ => false,
         }
     }
@@ -3122,21 +2747,24 @@ impl AstNode for SourceFile {
         &self.syntax
     }
 }
-impl ast::ModuleItemOwner for SourceFile {}
-impl ast::FnDefOwner for SourceFile {}
-impl SourceFile {
-    pub fn modules(&self) -> AstChildren<Module> {
+impl ast::AttrsOwner for Block {}
+impl ast::ModuleItemOwner for Block {}
+impl Block {
+    pub fn statements(&self) -> AstChildren<Stmt> {
         AstChildren::new(&self.syntax)
     }
+    pub fn expr(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
+    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct StaticDef {
+pub struct ParamList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for StaticDef {
+impl AstNode for ParamList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            STATIC_DEF => true,
+            PARAM_LIST => true,
             _ => false,
         }
     }
@@ -3151,63 +2779,47 @@ impl AstNode for StaticDef {
         &self.syntax
     }
 }
-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 body(&self) -> Option<Expr> {
+impl ParamList {
+    pub fn self_param(&self) -> Option<SelfParam> {
         AstChildren::new(&self.syntax).next()
     }
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Stmt {
-    ExprStmt(ExprStmt),
-    LetStmt(LetStmt),
-}
-impl From<ExprStmt> for Stmt {
-    fn from(node: ExprStmt) -> Stmt {
-        Stmt::ExprStmt(node)
+    pub fn params(&self) -> AstChildren<Param> {
+        AstChildren::new(&self.syntax)
     }
 }
-impl From<LetStmt> for Stmt {
-    fn from(node: LetStmt) -> Stmt {
-        Stmt::LetStmt(node)
-    }
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SelfParam {
+    pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for Stmt {
+impl AstNode for SelfParam {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            EXPR_STMT | LET_STMT => true,
+            SELF_PARAM => true,
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        let res = match syntax.kind() {
-            EXPR_STMT => Stmt::ExprStmt(ExprStmt { syntax }),
-            LET_STMT => Stmt::LetStmt(LetStmt { syntax }),
-            _ => return None,
-        };
-        Some(res)
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
     }
     fn syntax(&self) -> &SyntaxNode {
-        match self {
-            Stmt::ExprStmt(it) => &it.syntax,
-            Stmt::LetStmt(it) => &it.syntax,
-        }
+        &self.syntax
     }
 }
-impl Stmt {}
+impl ast::TypeAscriptionOwner for SelfParam {}
+impl ast::AttrsOwner for SelfParam {}
+impl SelfParam {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct StructDef {
+pub struct Param {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for StructDef {
+impl AstNode for Param {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            STRUCT_DEF => true,
+            PARAM => true,
             _ => false,
         }
     }
@@ -3222,43 +2834,21 @@ impl AstNode for StructDef {
         &self.syntax
     }
 }
-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 {}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TokenTree {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for TokenTree {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            TOKEN_TREE => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
+impl ast::TypeAscriptionOwner for Param {}
+impl ast::AttrsOwner for Param {}
+impl Param {
+    pub fn pat(&self) -> Option<Pat> {
+        AstChildren::new(&self.syntax).next()
     }
 }
-impl TokenTree {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TraitDef {
+pub struct UseItem {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TraitDef {
+impl AstNode for UseItem {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TRAIT_DEF => true,
+            USE_ITEM => true,
             _ => false,
         }
     }
@@ -3273,25 +2863,21 @@ impl AstNode for TraitDef {
         &self.syntax
     }
 }
-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 item_list(&self) -> Option<ItemList> {
+impl ast::AttrsOwner for UseItem {}
+impl ast::VisibilityOwner for UseItem {}
+impl UseItem {
+    pub fn use_tree(&self) -> Option<UseTree> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TryBlockExpr {
+pub struct UseTree {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TryBlockExpr {
+impl AstNode for UseTree {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TRY_BLOCK_EXPR => true,
+            USE_TREE => true,
             _ => false,
         }
     }
@@ -3306,19 +2892,25 @@ impl AstNode for TryBlockExpr {
         &self.syntax
     }
 }
-impl TryBlockExpr {
-    pub fn body(&self) -> Option<BlockExpr> {
+impl UseTree {
+    pub fn path(&self) -> Option<Path> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn use_tree_list(&self) -> Option<UseTreeList> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn alias(&self) -> Option<Alias> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TryExpr {
+pub struct Alias {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TryExpr {
+impl AstNode for Alias {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TRY_EXPR => true,
+            ALIAS => true,
             _ => false,
         }
     }
@@ -3333,19 +2925,16 @@ impl AstNode for TryExpr {
         &self.syntax
     }
 }
-impl TryExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl ast::NameOwner for Alias {}
+impl Alias {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TupleExpr {
+pub struct UseTreeList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TupleExpr {
+impl AstNode for UseTreeList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TUPLE_EXPR => true,
+            USE_TREE_LIST => true,
             _ => false,
         }
     }
@@ -3360,19 +2949,19 @@ impl AstNode for TupleExpr {
         &self.syntax
     }
 }
-impl TupleExpr {
-    pub fn exprs(&self) -> AstChildren<Expr> {
+impl UseTreeList {
+    pub fn use_trees(&self) -> AstChildren<UseTree> {
         AstChildren::new(&self.syntax)
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TupleFieldDef {
+pub struct ExternCrateItem {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TupleFieldDef {
+impl AstNode for ExternCrateItem {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TUPLE_FIELD_DEF => true,
+            EXTERN_CRATE_ITEM => true,
             _ => false,
         }
     }
@@ -3387,21 +2976,24 @@ impl AstNode for TupleFieldDef {
         &self.syntax
     }
 }
-impl ast::VisibilityOwner for TupleFieldDef {}
-impl ast::AttrsOwner for TupleFieldDef {}
-impl TupleFieldDef {
-    pub fn type_ref(&self) -> Option<TypeRef> {
+impl ast::AttrsOwner for ExternCrateItem {}
+impl ast::VisibilityOwner for ExternCrateItem {}
+impl ExternCrateItem {
+    pub fn name_ref(&self) -> Option<NameRef> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn alias(&self) -> Option<Alias> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TupleFieldDefList {
+pub struct ArgList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TupleFieldDefList {
+impl AstNode for ArgList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TUPLE_FIELD_DEF_LIST => true,
+            ARG_LIST => true,
             _ => false,
         }
     }
@@ -3416,19 +3008,19 @@ impl AstNode for TupleFieldDefList {
         &self.syntax
     }
 }
-impl TupleFieldDefList {
-    pub fn fields(&self) -> AstChildren<TupleFieldDef> {
+impl ArgList {
+    pub fn args(&self) -> AstChildren<Expr> {
         AstChildren::new(&self.syntax)
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TuplePat {
+pub struct Path {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TuplePat {
+impl AstNode for Path {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TUPLE_PAT => true,
+            PATH => true,
             _ => false,
         }
     }
@@ -3443,19 +3035,22 @@ impl AstNode for TuplePat {
         &self.syntax
     }
 }
-impl TuplePat {
-    pub fn args(&self) -> AstChildren<Pat> {
-        AstChildren::new(&self.syntax)
+impl Path {
+    pub fn segment(&self) -> Option<PathSegment> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn qualifier(&self) -> Option<Path> {
+        AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TupleStructPat {
+pub struct PathSegment {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TupleStructPat {
+impl AstNode for PathSegment {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TUPLE_STRUCT_PAT => true,
+            PATH_SEGMENT => true,
             _ => false,
         }
     }
@@ -3470,49 +3065,31 @@ impl AstNode for TupleStructPat {
         &self.syntax
     }
 }
-impl TupleStructPat {
-    pub fn args(&self) -> AstChildren<Pat> {
-        AstChildren::new(&self.syntax)
-    }
-    pub fn path(&self) -> Option<Path> {
+impl PathSegment {
+    pub fn name_ref(&self) -> Option<NameRef> {
         AstChildren::new(&self.syntax).next()
     }
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TupleType {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for TupleType {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            TUPLE_TYPE => true,
-            _ => false,
-        }
+    pub fn type_arg_list(&self) -> Option<TypeArgList> {
+        AstChildren::new(&self.syntax).next()
     }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+    pub fn param_list(&self) -> Option<ParamList> {
+        AstChildren::new(&self.syntax).next()
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
+    pub fn ret_type(&self) -> Option<RetType> {
+        AstChildren::new(&self.syntax).next()
     }
-}
-impl TupleType {
-    pub fn fields(&self) -> AstChildren<TypeRef> {
-        AstChildren::new(&self.syntax)
+    pub fn path_type(&self) -> Option<PathType> {
+        AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeAliasDef {
+pub struct TypeArgList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TypeAliasDef {
+impl AstNode for TypeArgList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TYPE_ALIAS_DEF => true,
+            TYPE_ARG_LIST => true,
             _ => false,
         }
     }
@@ -3527,15 +3104,15 @@ impl AstNode for TypeAliasDef {
         &self.syntax
     }
 }
-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 type_ref(&self) -> Option<TypeRef> {
-        AstChildren::new(&self.syntax).next()
+impl TypeArgList {
+    pub fn type_args(&self) -> AstChildren<TypeArg> {
+        AstChildren::new(&self.syntax)
+    }
+    pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> {
+        AstChildren::new(&self.syntax)
+    }
+    pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> {
+        AstChildren::new(&self.syntax)
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -3566,13 +3143,13 @@ impl TypeArg {
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeArgList {
+pub struct AssocTypeArg {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TypeArgList {
+impl AstNode for AssocTypeArg {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TYPE_ARG_LIST => true,
+            ASSOC_TYPE_ARG => true,
             _ => false,
         }
     }
@@ -3587,25 +3164,22 @@ impl AstNode for TypeArgList {
         &self.syntax
     }
 }
-impl TypeArgList {
-    pub fn type_args(&self) -> AstChildren<TypeArg> {
-        AstChildren::new(&self.syntax)
-    }
-    pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> {
-        AstChildren::new(&self.syntax)
+impl AssocTypeArg {
+    pub fn name_ref(&self) -> Option<NameRef> {
+        AstChildren::new(&self.syntax).next()
     }
-    pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> {
-        AstChildren::new(&self.syntax)
+    pub fn type_ref(&self) -> Option<TypeRef> {
+        AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeBound {
+pub struct LifetimeArg {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TypeBound {
+impl AstNode for LifetimeArg {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TYPE_BOUND => true,
+            LIFETIME_ARG => true,
             _ => false,
         }
     }
@@ -3620,19 +3194,15 @@ impl AstNode for TypeBound {
         &self.syntax
     }
 }
-impl TypeBound {
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl LifetimeArg {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeBoundList {
+pub struct MacroItems {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TypeBoundList {
+impl AstNode for MacroItems {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TYPE_BOUND_LIST => true,
+            MACRO_ITEMS => true,
             _ => false,
         }
     }
@@ -3647,19 +3217,17 @@ impl AstNode for TypeBoundList {
         &self.syntax
     }
 }
-impl TypeBoundList {
-    pub fn bounds(&self) -> AstChildren<TypeBound> {
-        AstChildren::new(&self.syntax)
-    }
-}
+impl ast::ModuleItemOwner for MacroItems {}
+impl ast::FnDefOwner for MacroItems {}
+impl MacroItems {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeParam {
+pub struct MacroStmts {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TypeParam {
+impl AstNode for MacroStmts {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TYPE_PARAM => true,
+            MACRO_STMTS => true,
             _ => false,
         }
     }
@@ -3674,44 +3242,62 @@ impl AstNode for TypeParam {
         &self.syntax
     }
 }
-impl ast::NameOwner for TypeParam {}
-impl ast::AttrsOwner for TypeParam {}
-impl ast::TypeBoundsOwner for TypeParam {}
-impl TypeParam {
-    pub fn default_type(&self) -> Option<TypeRef> {
+impl MacroStmts {
+    pub fn statements(&self) -> AstChildren<Stmt> {
+        AstChildren::new(&self.syntax)
+    }
+    pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TypeParamList {
-    pub(crate) syntax: SyntaxNode,
+pub enum NominalDef {
+    StructDef(StructDef),
+    EnumDef(EnumDef),
+    UnionDef(UnionDef),
 }
-impl AstNode for TypeParamList {
+impl From<StructDef> for NominalDef {
+    fn from(node: StructDef) -> NominalDef {
+        NominalDef::StructDef(node)
+    }
+}
+impl From<EnumDef> for NominalDef {
+    fn from(node: EnumDef) -> NominalDef {
+        NominalDef::EnumDef(node)
+    }
+}
+impl From<UnionDef> for NominalDef {
+    fn from(node: UnionDef) -> NominalDef {
+        NominalDef::UnionDef(node)
+    }
+}
+impl AstNode for NominalDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TYPE_PARAM_LIST => true,
+            STRUCT_DEF | ENUM_DEF | UNION_DEF => true,
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+        let res = match syntax.kind() {
+            STRUCT_DEF => NominalDef::StructDef(StructDef { syntax }),
+            ENUM_DEF => NominalDef::EnumDef(EnumDef { syntax }),
+            UNION_DEF => NominalDef::UnionDef(UnionDef { syntax }),
+            _ => return None,
+        };
+        Some(res)
     }
     fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-impl TypeParamList {
-    pub fn type_params(&self) -> AstChildren<TypeParam> {
-        AstChildren::new(&self.syntax)
-    }
-    pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> {
-        AstChildren::new(&self.syntax)
+        match self {
+            NominalDef::StructDef(it) => &it.syntax,
+            NominalDef::EnumDef(it) => &it.syntax,
+            NominalDef::UnionDef(it) => &it.syntax,
+        }
     }
 }
+impl ast::NameOwner for NominalDef {}
+impl ast::TypeParamsOwner for NominalDef {}
+impl ast::AttrsOwner for NominalDef {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum TypeRef {
     ParenType(ParenType),
@@ -3839,231 +3425,637 @@ impl AstNode for TypeRef {
         }
     }
 }
-impl TypeRef {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UnionDef {
-    pub(crate) syntax: SyntaxNode,
+pub enum ModuleItem {
+    StructDef(StructDef),
+    UnionDef(UnionDef),
+    EnumDef(EnumDef),
+    FnDef(FnDef),
+    TraitDef(TraitDef),
+    TypeAliasDef(TypeAliasDef),
+    ImplBlock(ImplBlock),
+    UseItem(UseItem),
+    ExternCrateItem(ExternCrateItem),
+    ConstDef(ConstDef),
+    StaticDef(StaticDef),
+    Module(Module),
 }
-impl AstNode for UnionDef {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            UNION_DEF => true,
-            _ => false,
-        }
+impl From<StructDef> for ModuleItem {
+    fn from(node: StructDef) -> ModuleItem {
+        ModuleItem::StructDef(node)
     }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+}
+impl From<UnionDef> for ModuleItem {
+    fn from(node: UnionDef) -> ModuleItem {
+        ModuleItem::UnionDef(node)
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
+}
+impl From<EnumDef> for ModuleItem {
+    fn from(node: EnumDef) -> ModuleItem {
+        ModuleItem::EnumDef(node)
     }
 }
-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 {
-    pub fn record_field_def_list(&self) -> Option<RecordFieldDefList> {
-        AstChildren::new(&self.syntax).next()
+impl From<FnDef> for ModuleItem {
+    fn from(node: FnDef) -> ModuleItem {
+        ModuleItem::FnDef(node)
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UseItem {
-    pub(crate) syntax: SyntaxNode,
+impl From<TraitDef> for ModuleItem {
+    fn from(node: TraitDef) -> ModuleItem {
+        ModuleItem::TraitDef(node)
+    }
 }
-impl AstNode for UseItem {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            USE_ITEM => true,
-            _ => false,
-        }
+impl From<TypeAliasDef> for ModuleItem {
+    fn from(node: TypeAliasDef) -> ModuleItem {
+        ModuleItem::TypeAliasDef(node)
     }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+}
+impl From<ImplBlock> for ModuleItem {
+    fn from(node: ImplBlock) -> ModuleItem {
+        ModuleItem::ImplBlock(node)
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
+}
+impl From<UseItem> for ModuleItem {
+    fn from(node: UseItem) -> ModuleItem {
+        ModuleItem::UseItem(node)
     }
 }
-impl ast::AttrsOwner for UseItem {}
-impl ast::VisibilityOwner for UseItem {}
-impl UseItem {
-    pub fn use_tree(&self) -> Option<UseTree> {
-        AstChildren::new(&self.syntax).next()
+impl From<ExternCrateItem> for ModuleItem {
+    fn from(node: ExternCrateItem) -> ModuleItem {
+        ModuleItem::ExternCrateItem(node)
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UseTree {
-    pub(crate) syntax: SyntaxNode,
+impl From<ConstDef> for ModuleItem {
+    fn from(node: ConstDef) -> ModuleItem {
+        ModuleItem::ConstDef(node)
+    }
 }
-impl AstNode for UseTree {
+impl From<StaticDef> for ModuleItem {
+    fn from(node: StaticDef) -> ModuleItem {
+        ModuleItem::StaticDef(node)
+    }
+}
+impl From<Module> for ModuleItem {
+    fn from(node: Module) -> ModuleItem {
+        ModuleItem::Module(node)
+    }
+}
+impl AstNode for ModuleItem {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            USE_TREE => true,
+            STRUCT_DEF | UNION_DEF | ENUM_DEF | FN_DEF | TRAIT_DEF | TYPE_ALIAS_DEF
+            | IMPL_BLOCK | USE_ITEM | EXTERN_CRATE_ITEM | CONST_DEF | STATIC_DEF | MODULE => true,
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+        let res = match syntax.kind() {
+            STRUCT_DEF => ModuleItem::StructDef(StructDef { syntax }),
+            UNION_DEF => ModuleItem::UnionDef(UnionDef { syntax }),
+            ENUM_DEF => ModuleItem::EnumDef(EnumDef { syntax }),
+            FN_DEF => ModuleItem::FnDef(FnDef { syntax }),
+            TRAIT_DEF => ModuleItem::TraitDef(TraitDef { syntax }),
+            TYPE_ALIAS_DEF => ModuleItem::TypeAliasDef(TypeAliasDef { syntax }),
+            IMPL_BLOCK => ModuleItem::ImplBlock(ImplBlock { syntax }),
+            USE_ITEM => ModuleItem::UseItem(UseItem { syntax }),
+            EXTERN_CRATE_ITEM => ModuleItem::ExternCrateItem(ExternCrateItem { syntax }),
+            CONST_DEF => ModuleItem::ConstDef(ConstDef { syntax }),
+            STATIC_DEF => ModuleItem::StaticDef(StaticDef { syntax }),
+            MODULE => ModuleItem::Module(Module { syntax }),
+            _ => return None,
+        };
+        Some(res)
     }
     fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
+        match self {
+            ModuleItem::StructDef(it) => &it.syntax,
+            ModuleItem::UnionDef(it) => &it.syntax,
+            ModuleItem::EnumDef(it) => &it.syntax,
+            ModuleItem::FnDef(it) => &it.syntax,
+            ModuleItem::TraitDef(it) => &it.syntax,
+            ModuleItem::TypeAliasDef(it) => &it.syntax,
+            ModuleItem::ImplBlock(it) => &it.syntax,
+            ModuleItem::UseItem(it) => &it.syntax,
+            ModuleItem::ExternCrateItem(it) => &it.syntax,
+            ModuleItem::ConstDef(it) => &it.syntax,
+            ModuleItem::StaticDef(it) => &it.syntax,
+            ModuleItem::Module(it) => &it.syntax,
+        }
     }
 }
-impl UseTree {
-    pub fn path(&self) -> Option<Path> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn use_tree_list(&self) -> Option<UseTreeList> {
-        AstChildren::new(&self.syntax).next()
+impl ast::AttrsOwner for ModuleItem {}
+impl ast::VisibilityOwner for ModuleItem {}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ImplItem {
+    FnDef(FnDef),
+    TypeAliasDef(TypeAliasDef),
+    ConstDef(ConstDef),
+}
+impl From<FnDef> for ImplItem {
+    fn from(node: FnDef) -> ImplItem {
+        ImplItem::FnDef(node)
     }
-    pub fn alias(&self) -> Option<Alias> {
-        AstChildren::new(&self.syntax).next()
+}
+impl From<TypeAliasDef> for ImplItem {
+    fn from(node: TypeAliasDef) -> ImplItem {
+        ImplItem::TypeAliasDef(node)
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct UseTreeList {
-    pub(crate) syntax: SyntaxNode,
+impl From<ConstDef> for ImplItem {
+    fn from(node: ConstDef) -> ImplItem {
+        ImplItem::ConstDef(node)
+    }
 }
-impl AstNode for UseTreeList {
+impl AstNode for ImplItem {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            USE_TREE_LIST => true,
+            FN_DEF | TYPE_ALIAS_DEF | CONST_DEF => true,
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-impl UseTreeList {
-    pub fn use_trees(&self) -> AstChildren<UseTree> {
-        AstChildren::new(&self.syntax)
+        let res = match syntax.kind() {
+            FN_DEF => ImplItem::FnDef(FnDef { syntax }),
+            TYPE_ALIAS_DEF => ImplItem::TypeAliasDef(TypeAliasDef { syntax }),
+            CONST_DEF => ImplItem::ConstDef(ConstDef { syntax }),
+            _ => return None,
+        };
+        Some(res)
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            ImplItem::FnDef(it) => &it.syntax,
+            ImplItem::TypeAliasDef(it) => &it.syntax,
+            ImplItem::ConstDef(it) => &it.syntax,
+        }
     }
 }
+impl ast::AttrsOwner for ImplItem {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Visibility {
-    pub(crate) syntax: SyntaxNode,
+pub enum Expr {
+    TupleExpr(TupleExpr),
+    ArrayExpr(ArrayExpr),
+    ParenExpr(ParenExpr),
+    PathExpr(PathExpr),
+    LambdaExpr(LambdaExpr),
+    IfExpr(IfExpr),
+    LoopExpr(LoopExpr),
+    ForExpr(ForExpr),
+    WhileExpr(WhileExpr),
+    ContinueExpr(ContinueExpr),
+    BreakExpr(BreakExpr),
+    Label(Label),
+    BlockExpr(BlockExpr),
+    ReturnExpr(ReturnExpr),
+    MatchExpr(MatchExpr),
+    RecordLit(RecordLit),
+    CallExpr(CallExpr),
+    IndexExpr(IndexExpr),
+    MethodCallExpr(MethodCallExpr),
+    FieldExpr(FieldExpr),
+    AwaitExpr(AwaitExpr),
+    TryExpr(TryExpr),
+    TryBlockExpr(TryBlockExpr),
+    CastExpr(CastExpr),
+    RefExpr(RefExpr),
+    PrefixExpr(PrefixExpr),
+    RangeExpr(RangeExpr),
+    BinExpr(BinExpr),
+    Literal(Literal),
+    MacroCall(MacroCall),
+    BoxExpr(BoxExpr),
 }
-impl AstNode for Visibility {
+impl From<TupleExpr> for Expr {
+    fn from(node: TupleExpr) -> Expr {
+        Expr::TupleExpr(node)
+    }
+}
+impl From<ArrayExpr> for Expr {
+    fn from(node: ArrayExpr) -> Expr {
+        Expr::ArrayExpr(node)
+    }
+}
+impl From<ParenExpr> for Expr {
+    fn from(node: ParenExpr) -> Expr {
+        Expr::ParenExpr(node)
+    }
+}
+impl From<PathExpr> for Expr {
+    fn from(node: PathExpr) -> Expr {
+        Expr::PathExpr(node)
+    }
+}
+impl From<LambdaExpr> for Expr {
+    fn from(node: LambdaExpr) -> Expr {
+        Expr::LambdaExpr(node)
+    }
+}
+impl From<IfExpr> for Expr {
+    fn from(node: IfExpr) -> Expr {
+        Expr::IfExpr(node)
+    }
+}
+impl From<LoopExpr> for Expr {
+    fn from(node: LoopExpr) -> Expr {
+        Expr::LoopExpr(node)
+    }
+}
+impl From<ForExpr> for Expr {
+    fn from(node: ForExpr) -> Expr {
+        Expr::ForExpr(node)
+    }
+}
+impl From<WhileExpr> for Expr {
+    fn from(node: WhileExpr) -> Expr {
+        Expr::WhileExpr(node)
+    }
+}
+impl From<ContinueExpr> for Expr {
+    fn from(node: ContinueExpr) -> Expr {
+        Expr::ContinueExpr(node)
+    }
+}
+impl From<BreakExpr> for Expr {
+    fn from(node: BreakExpr) -> Expr {
+        Expr::BreakExpr(node)
+    }
+}
+impl From<Label> for Expr {
+    fn from(node: Label) -> Expr {
+        Expr::Label(node)
+    }
+}
+impl From<BlockExpr> for Expr {
+    fn from(node: BlockExpr) -> Expr {
+        Expr::BlockExpr(node)
+    }
+}
+impl From<ReturnExpr> for Expr {
+    fn from(node: ReturnExpr) -> Expr {
+        Expr::ReturnExpr(node)
+    }
+}
+impl From<MatchExpr> for Expr {
+    fn from(node: MatchExpr) -> Expr {
+        Expr::MatchExpr(node)
+    }
+}
+impl From<RecordLit> for Expr {
+    fn from(node: RecordLit) -> Expr {
+        Expr::RecordLit(node)
+    }
+}
+impl From<CallExpr> for Expr {
+    fn from(node: CallExpr) -> Expr {
+        Expr::CallExpr(node)
+    }
+}
+impl From<IndexExpr> for Expr {
+    fn from(node: IndexExpr) -> Expr {
+        Expr::IndexExpr(node)
+    }
+}
+impl From<MethodCallExpr> for Expr {
+    fn from(node: MethodCallExpr) -> Expr {
+        Expr::MethodCallExpr(node)
+    }
+}
+impl From<FieldExpr> for Expr {
+    fn from(node: FieldExpr) -> Expr {
+        Expr::FieldExpr(node)
+    }
+}
+impl From<AwaitExpr> for Expr {
+    fn from(node: AwaitExpr) -> Expr {
+        Expr::AwaitExpr(node)
+    }
+}
+impl From<TryExpr> for Expr {
+    fn from(node: TryExpr) -> Expr {
+        Expr::TryExpr(node)
+    }
+}
+impl From<TryBlockExpr> for Expr {
+    fn from(node: TryBlockExpr) -> Expr {
+        Expr::TryBlockExpr(node)
+    }
+}
+impl From<CastExpr> for Expr {
+    fn from(node: CastExpr) -> Expr {
+        Expr::CastExpr(node)
+    }
+}
+impl From<RefExpr> for Expr {
+    fn from(node: RefExpr) -> Expr {
+        Expr::RefExpr(node)
+    }
+}
+impl From<PrefixExpr> for Expr {
+    fn from(node: PrefixExpr) -> Expr {
+        Expr::PrefixExpr(node)
+    }
+}
+impl From<RangeExpr> for Expr {
+    fn from(node: RangeExpr) -> Expr {
+        Expr::RangeExpr(node)
+    }
+}
+impl From<BinExpr> for Expr {
+    fn from(node: BinExpr) -> Expr {
+        Expr::BinExpr(node)
+    }
+}
+impl From<Literal> for Expr {
+    fn from(node: Literal) -> Expr {
+        Expr::Literal(node)
+    }
+}
+impl From<MacroCall> for Expr {
+    fn from(node: MacroCall) -> Expr {
+        Expr::MacroCall(node)
+    }
+}
+impl From<BoxExpr> for Expr {
+    fn from(node: BoxExpr) -> Expr {
+        Expr::BoxExpr(node)
+    }
+}
+impl AstNode for Expr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            VISIBILITY => true,
+            TUPLE_EXPR | ARRAY_EXPR | PAREN_EXPR | PATH_EXPR | LAMBDA_EXPR | IF_EXPR
+            | LOOP_EXPR | FOR_EXPR | WHILE_EXPR | CONTINUE_EXPR | BREAK_EXPR | LABEL
+            | BLOCK_EXPR | RETURN_EXPR | MATCH_EXPR | RECORD_LIT | CALL_EXPR | INDEX_EXPR
+            | METHOD_CALL_EXPR | FIELD_EXPR | AWAIT_EXPR | TRY_EXPR | TRY_BLOCK_EXPR
+            | CAST_EXPR | REF_EXPR | PREFIX_EXPR | RANGE_EXPR | BIN_EXPR | LITERAL | MACRO_CALL
+            | BOX_EXPR => true,
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+        let res = match syntax.kind() {
+            TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }),
+            ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
+            PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }),
+            PATH_EXPR => Expr::PathExpr(PathExpr { syntax }),
+            LAMBDA_EXPR => Expr::LambdaExpr(LambdaExpr { syntax }),
+            IF_EXPR => Expr::IfExpr(IfExpr { syntax }),
+            LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }),
+            FOR_EXPR => Expr::ForExpr(ForExpr { syntax }),
+            WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }),
+            CONTINUE_EXPR => Expr::ContinueExpr(ContinueExpr { syntax }),
+            BREAK_EXPR => Expr::BreakExpr(BreakExpr { syntax }),
+            LABEL => Expr::Label(Label { syntax }),
+            BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }),
+            RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }),
+            MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
+            RECORD_LIT => Expr::RecordLit(RecordLit { syntax }),
+            CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
+            INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
+            METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
+            FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
+            AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }),
+            TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
+            TRY_BLOCK_EXPR => Expr::TryBlockExpr(TryBlockExpr { syntax }),
+            CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
+            REF_EXPR => Expr::RefExpr(RefExpr { syntax }),
+            PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }),
+            RANGE_EXPR => Expr::RangeExpr(RangeExpr { syntax }),
+            BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
+            LITERAL => Expr::Literal(Literal { syntax }),
+            MACRO_CALL => Expr::MacroCall(MacroCall { syntax }),
+            BOX_EXPR => Expr::BoxExpr(BoxExpr { syntax }),
+            _ => return None,
+        };
+        Some(res)
     }
     fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
+        match self {
+            Expr::TupleExpr(it) => &it.syntax,
+            Expr::ArrayExpr(it) => &it.syntax,
+            Expr::ParenExpr(it) => &it.syntax,
+            Expr::PathExpr(it) => &it.syntax,
+            Expr::LambdaExpr(it) => &it.syntax,
+            Expr::IfExpr(it) => &it.syntax,
+            Expr::LoopExpr(it) => &it.syntax,
+            Expr::ForExpr(it) => &it.syntax,
+            Expr::WhileExpr(it) => &it.syntax,
+            Expr::ContinueExpr(it) => &it.syntax,
+            Expr::BreakExpr(it) => &it.syntax,
+            Expr::Label(it) => &it.syntax,
+            Expr::BlockExpr(it) => &it.syntax,
+            Expr::ReturnExpr(it) => &it.syntax,
+            Expr::MatchExpr(it) => &it.syntax,
+            Expr::RecordLit(it) => &it.syntax,
+            Expr::CallExpr(it) => &it.syntax,
+            Expr::IndexExpr(it) => &it.syntax,
+            Expr::MethodCallExpr(it) => &it.syntax,
+            Expr::FieldExpr(it) => &it.syntax,
+            Expr::AwaitExpr(it) => &it.syntax,
+            Expr::TryExpr(it) => &it.syntax,
+            Expr::TryBlockExpr(it) => &it.syntax,
+            Expr::CastExpr(it) => &it.syntax,
+            Expr::RefExpr(it) => &it.syntax,
+            Expr::PrefixExpr(it) => &it.syntax,
+            Expr::RangeExpr(it) => &it.syntax,
+            Expr::BinExpr(it) => &it.syntax,
+            Expr::Literal(it) => &it.syntax,
+            Expr::MacroCall(it) => &it.syntax,
+            Expr::BoxExpr(it) => &it.syntax,
+        }
     }
 }
-impl Visibility {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WhereClause {
-    pub(crate) syntax: SyntaxNode,
+pub enum Pat {
+    RefPat(RefPat),
+    BoxPat(BoxPat),
+    BindPat(BindPat),
+    PlaceholderPat(PlaceholderPat),
+    DotDotPat(DotDotPat),
+    PathPat(PathPat),
+    RecordPat(RecordPat),
+    TupleStructPat(TupleStructPat),
+    TuplePat(TuplePat),
+    SlicePat(SlicePat),
+    RangePat(RangePat),
+    LiteralPat(LiteralPat),
 }
-impl AstNode for WhereClause {
+impl From<RefPat> for Pat {
+    fn from(node: RefPat) -> Pat {
+        Pat::RefPat(node)
+    }
+}
+impl From<BoxPat> for Pat {
+    fn from(node: BoxPat) -> Pat {
+        Pat::BoxPat(node)
+    }
+}
+impl From<BindPat> for Pat {
+    fn from(node: BindPat) -> Pat {
+        Pat::BindPat(node)
+    }
+}
+impl From<PlaceholderPat> for Pat {
+    fn from(node: PlaceholderPat) -> Pat {
+        Pat::PlaceholderPat(node)
+    }
+}
+impl From<DotDotPat> for Pat {
+    fn from(node: DotDotPat) -> Pat {
+        Pat::DotDotPat(node)
+    }
+}
+impl From<PathPat> for Pat {
+    fn from(node: PathPat) -> Pat {
+        Pat::PathPat(node)
+    }
+}
+impl From<RecordPat> for Pat {
+    fn from(node: RecordPat) -> Pat {
+        Pat::RecordPat(node)
+    }
+}
+impl From<TupleStructPat> for Pat {
+    fn from(node: TupleStructPat) -> Pat {
+        Pat::TupleStructPat(node)
+    }
+}
+impl From<TuplePat> for Pat {
+    fn from(node: TuplePat) -> Pat {
+        Pat::TuplePat(node)
+    }
+}
+impl From<SlicePat> for Pat {
+    fn from(node: SlicePat) -> Pat {
+        Pat::SlicePat(node)
+    }
+}
+impl From<RangePat> for Pat {
+    fn from(node: RangePat) -> Pat {
+        Pat::RangePat(node)
+    }
+}
+impl From<LiteralPat> for Pat {
+    fn from(node: LiteralPat) -> Pat {
+        Pat::LiteralPat(node)
+    }
+}
+impl AstNode for Pat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            WHERE_CLAUSE => true,
+            REF_PAT | BOX_PAT | BIND_PAT | PLACEHOLDER_PAT | DOT_DOT_PAT | PATH_PAT
+            | RECORD_PAT | TUPLE_STRUCT_PAT | TUPLE_PAT | SLICE_PAT | RANGE_PAT | LITERAL_PAT => {
+                true
+            }
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+        let res = match syntax.kind() {
+            REF_PAT => Pat::RefPat(RefPat { syntax }),
+            BOX_PAT => Pat::BoxPat(BoxPat { syntax }),
+            BIND_PAT => Pat::BindPat(BindPat { syntax }),
+            PLACEHOLDER_PAT => Pat::PlaceholderPat(PlaceholderPat { syntax }),
+            DOT_DOT_PAT => Pat::DotDotPat(DotDotPat { syntax }),
+            PATH_PAT => Pat::PathPat(PathPat { syntax }),
+            RECORD_PAT => Pat::RecordPat(RecordPat { syntax }),
+            TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
+            TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
+            SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
+            RANGE_PAT => Pat::RangePat(RangePat { syntax }),
+            LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }),
+            _ => return None,
+        };
+        Some(res)
     }
     fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
+        match self {
+            Pat::RefPat(it) => &it.syntax,
+            Pat::BoxPat(it) => &it.syntax,
+            Pat::BindPat(it) => &it.syntax,
+            Pat::PlaceholderPat(it) => &it.syntax,
+            Pat::DotDotPat(it) => &it.syntax,
+            Pat::PathPat(it) => &it.syntax,
+            Pat::RecordPat(it) => &it.syntax,
+            Pat::TupleStructPat(it) => &it.syntax,
+            Pat::TuplePat(it) => &it.syntax,
+            Pat::SlicePat(it) => &it.syntax,
+            Pat::RangePat(it) => &it.syntax,
+            Pat::LiteralPat(it) => &it.syntax,
+        }
     }
 }
-impl WhereClause {
-    pub fn predicates(&self) -> AstChildren<WherePred> {
-        AstChildren::new(&self.syntax)
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum AttrInput {
+    Literal(Literal),
+    TokenTree(TokenTree),
+}
+impl From<Literal> for AttrInput {
+    fn from(node: Literal) -> AttrInput {
+        AttrInput::Literal(node)
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WherePred {
-    pub(crate) syntax: SyntaxNode,
+impl From<TokenTree> for AttrInput {
+    fn from(node: TokenTree) -> AttrInput {
+        AttrInput::TokenTree(node)
+    }
 }
-impl AstNode for WherePred {
+impl AstNode for AttrInput {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            WHERE_PRED => true,
+            LITERAL | TOKEN_TREE => true,
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+        let res = match syntax.kind() {
+            LITERAL => AttrInput::Literal(Literal { syntax }),
+            TOKEN_TREE => AttrInput::TokenTree(TokenTree { syntax }),
+            _ => return None,
+        };
+        Some(res)
     }
     fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
+        match self {
+            AttrInput::Literal(it) => &it.syntax,
+            AttrInput::TokenTree(it) => &it.syntax,
+        }
     }
 }
-impl ast::TypeBoundsOwner for WherePred {}
-impl WherePred {
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        AstChildren::new(&self.syntax).next()
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum Stmt {
+    ExprStmt(ExprStmt),
+    LetStmt(LetStmt),
+}
+impl From<ExprStmt> for Stmt {
+    fn from(node: ExprStmt) -> Stmt {
+        Stmt::ExprStmt(node)
     }
 }
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct WhileExpr {
-    pub(crate) syntax: SyntaxNode,
+impl From<LetStmt> for Stmt {
+    fn from(node: LetStmt) -> Stmt {
+        Stmt::LetStmt(node)
+    }
 }
-impl AstNode for WhileExpr {
+impl AstNode for Stmt {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            WHILE_EXPR => true,
+            EXPR_STMT | LET_STMT => true,
             _ => false,
         }
     }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
+        let res = match syntax.kind() {
+            EXPR_STMT => Stmt::ExprStmt(ExprStmt { syntax }),
+            LET_STMT => Stmt::LetStmt(LetStmt { syntax }),
+            _ => return None,
+        };
+        Some(res)
     }
     fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-impl ast::LoopBodyOwner for WhileExpr {}
-impl WhileExpr {
-    pub fn condition(&self) -> Option<Condition> {
-        AstChildren::new(&self.syntax).next()
+        match self {
+            Stmt::ExprStmt(it) => &it.syntax,
+            Stmt::LetStmt(it) => &it.syntax,
+        }
     }
 }
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index e43a724f0..47446a878 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -1,736 +1,6 @@
 // Stores definitions which must be used in multiple places
 // See `cargo xtask codegen` (defined in xtasks/src/main.rs)
 Grammar(
-    punct: [
-        (";", "SEMI"),
-        (",", "COMMA"),
-        ("(", "L_PAREN"),
-        (")", "R_PAREN"),
-        ("{", "L_CURLY"),
-        ("}", "R_CURLY"),
-        ("[", "L_BRACK"),
-        ("]", "R_BRACK"),
-        ("<", "L_ANGLE"),
-        (">", "R_ANGLE"),
-        ("@", "AT"),
-        ("#", "POUND"),
-        ("~", "TILDE"),
-        ("?", "QUESTION"),
-        ("$", "DOLLAR"),
-        ("&", "AMP"),
-        ("|", "PIPE"),
-        ("+", "PLUS"),
-        ("*", "STAR"),
-        ("/", "SLASH"),
-        ("^", "CARET"),
-        ("%", "PERCENT"),
-        ("_", "UNDERSCORE"),
-        (".", "DOT"),
-        ("..", "DOTDOT"),
-        ("...", "DOTDOTDOT"),
-        ("..=", "DOTDOTEQ"),
-        (":", "COLON"),
-        ("::", "COLONCOLON"),
-        ("=", "EQ"),
-        ("==", "EQEQ"),
-        ("=>", "FAT_ARROW"),
-        ("!", "EXCL"),
-        ("!=", "NEQ"),
-        ("-", "MINUS"),
-        ("->", "THIN_ARROW"),
-        ("<=", "LTEQ"),
-        (">=", "GTEQ"),
-        ("+=", "PLUSEQ"),
-        ("-=", "MINUSEQ"),
-        ("|=", "PIPEEQ"),
-        ("&=", "AMPEQ"),
-        ("^=", "CARETEQ"),
-        ("/=", "SLASHEQ"),
-        ("*=", "STAREQ"),
-        ("%=", "PERCENTEQ"),
-        ("&&", "AMPAMP"),
-        ("||", "PIPEPIPE"),
-        ("<<", "SHL"),
-        (">>", "SHR"),
-        ("<<=", "SHLEQ"),
-        (">>=", "SHREQ"),
-    ],
-    keywords: [
-        "async",
-        "use",
-        "fn",
-        "struct",
-        "enum",
-        "trait",
-        "impl",
-        "dyn",
-        "true",
-        "false",
-        "as",
-        "extern",
-        "crate",
-        "mod",
-        "pub",
-        "self",
-        "super",
-        "in",
-        "where",
-        "for",
-        "loop",
-        "while",
-        "continue",
-        "break",
-        "if",
-        "else",
-        "match",
-        "const",
-        "static",
-        "mut",
-        "unsafe",
-        "type",
-        "ref",
-        "let",
-        "move",
-        "return",
-        "try",
-        "box",
-        "await",
-        "macro"
-    ],
-    contextual_keywords: [
-        "auto",
-        "default",
-        "existential",
-        "union",
-    ],
-    literals: [
-        "INT_NUMBER",
-        "FLOAT_NUMBER",
-        "CHAR",
-        "BYTE",
-        "STRING",
-        "RAW_STRING",
-        "BYTE_STRING",
-        "RAW_BYTE_STRING",
-    ],
-    tokens: [
-        "ERROR",
-        "IDENT",
-        "WHITESPACE",
-        "LIFETIME",
-        "COMMENT",
-        "SHEBANG",
-        "L_DOLLAR",
-        "R_DOLLAR",
-    ],
-    nodes: [
-        "SOURCE_FILE",
-
-        "STRUCT_DEF",
-        "UNION_DEF",
-        "ENUM_DEF",
-        "FN_DEF",
-        "RET_TYPE",
-        "EXTERN_CRATE_ITEM",
-        "MODULE",
-        "USE_ITEM",
-        "STATIC_DEF",
-        "CONST_DEF",
-        "TRAIT_DEF",
-        "IMPL_BLOCK",
-        "TYPE_ALIAS_DEF",
-        "MACRO_CALL",
-        "TOKEN_TREE",
-        "MACRO_DEF",
-
-        "PAREN_TYPE",
-        "TUPLE_TYPE",
-        "NEVER_TYPE",
-        "PATH_TYPE",
-        "POINTER_TYPE",
-        "ARRAY_TYPE",
-        "SLICE_TYPE",
-        "REFERENCE_TYPE",
-        "PLACEHOLDER_TYPE",
-        "FN_POINTER_TYPE",
-        "FOR_TYPE",
-        "IMPL_TRAIT_TYPE",
-        "DYN_TRAIT_TYPE",
-
-        "REF_PAT",
-        "BOX_PAT",
-        "BIND_PAT",
-        "PLACEHOLDER_PAT",
-        "DOT_DOT_PAT",
-        "PATH_PAT",
-        "RECORD_PAT",
-        "RECORD_FIELD_PAT_LIST",
-        "RECORD_FIELD_PAT",
-        "TUPLE_STRUCT_PAT",
-        "TUPLE_PAT",
-        "SLICE_PAT",
-        "RANGE_PAT",
-        "LITERAL_PAT",
-
-        // atoms
-        "TUPLE_EXPR",
-        "ARRAY_EXPR",
-        "PAREN_EXPR",
-        "PATH_EXPR",
-        "LAMBDA_EXPR",
-        "IF_EXPR",
-        "WHILE_EXPR",
-        "CONDITION",
-        "LOOP_EXPR",
-        "FOR_EXPR",
-        "CONTINUE_EXPR",
-        "BREAK_EXPR",
-        "LABEL",
-        "BLOCK_EXPR",
-        "RETURN_EXPR",
-        "MATCH_EXPR",
-        "MATCH_ARM_LIST",
-        "MATCH_ARM",
-        "MATCH_GUARD",
-        "RECORD_LIT",
-        "RECORD_FIELD_LIST",
-        "RECORD_FIELD",
-        "TRY_BLOCK_EXPR",
-        "BOX_EXPR",
-
-        // postfix
-        "CALL_EXPR",
-        "INDEX_EXPR",
-        "METHOD_CALL_EXPR",
-        "FIELD_EXPR",
-        "AWAIT_EXPR",
-        "TRY_EXPR",
-        "CAST_EXPR",
-
-        // unary
-        "REF_EXPR",
-        "PREFIX_EXPR",
-
-        "RANGE_EXPR", // just weird
-        "BIN_EXPR",
-
-        "BLOCK",
-        "EXTERN_BLOCK",
-        "EXTERN_ITEM_LIST",
-        "ENUM_VARIANT",
-        "RECORD_FIELD_DEF_LIST",
-        "RECORD_FIELD_DEF",
-        "TUPLE_FIELD_DEF_LIST",
-        "TUPLE_FIELD_DEF",
-        "ENUM_VARIANT_LIST",
-        "ITEM_LIST",
-        "ATTR",
-        "META_ITEM", // not an item actually
-        "USE_TREE",
-        "USE_TREE_LIST",
-        "PATH",
-        "PATH_SEGMENT",
-        "LITERAL",
-        "ALIAS",
-        "VISIBILITY",
-        "WHERE_CLAUSE",
-        "WHERE_PRED",
-        "ABI",
-        "NAME",
-        "NAME_REF",
-
-        "LET_STMT",
-        "EXPR_STMT",
-
-        "TYPE_PARAM_LIST",
-        "LIFETIME_PARAM",
-        "TYPE_PARAM",
-        "CONST_PARAM",
-        "TYPE_ARG_LIST",
-        "LIFETIME_ARG",
-        "TYPE_ARG",
-        "ASSOC_TYPE_ARG",
-
-        "PARAM_LIST",
-        "PARAM",
-        "SELF_PARAM",
-        "ARG_LIST",
-        "TYPE_BOUND",
-        "TYPE_BOUND_LIST",
-
-        // macro related
-        "MACRO_ITEMS",
-        "MACRO_STMTS",
-    ],
     ast: {
-        "SourceFile": (
-            traits: [ "ModuleItemOwner", "FnDefOwner" ],
-            collections: [
-                ("modules", "Module"),
-            ]
-        ),
-        "FnDef": (
-            traits: [
-                "VisibilityOwner",
-                "NameOwner",
-                "TypeParamsOwner",
-                "AttrsOwner",
-                "DocCommentsOwner"
-            ],
-            options: [ "ParamList", ["body", "BlockExpr"], "RetType" ],
-        ),
-        "RetType": (options: ["TypeRef"]),
-        "StructDef": (
-            traits: [
-                "VisibilityOwner",
-                "NameOwner",
-                "TypeParamsOwner",
-                "AttrsOwner",
-                "DocCommentsOwner"
-            ]
-        ),
-        "UnionDef": (
-            traits: [
-                "VisibilityOwner",
-                "NameOwner",
-                "TypeParamsOwner",
-                "AttrsOwner",
-                "DocCommentsOwner"
-            ],
-            options: ["RecordFieldDefList"],
-        ),
-        "RecordFieldDefList": (collections: [("fields", "RecordFieldDef")]),
-        "RecordFieldDef": (
-            traits: [
-                "VisibilityOwner",
-                "NameOwner",
-                "AttrsOwner",
-                "DocCommentsOwner",
-                "TypeAscriptionOwner"
-            ]
-        ),
-        "TupleFieldDefList": (collections: [("fields", "TupleFieldDef")]),
-        "TupleFieldDef": ( traits: ["VisibilityOwner", "AttrsOwner"], options: ["TypeRef"]),
-        "EnumDef": ( traits: [
-            "VisibilityOwner",
-            "NameOwner",
-            "TypeParamsOwner",
-            "AttrsOwner",
-            "DocCommentsOwner"
-        ], options: [["variant_list", "EnumVariantList"]] ),
-        "EnumVariantList": ( collections: [("variants", "EnumVariant")] ),
-        "EnumVariant": ( traits: ["NameOwner", "DocCommentsOwner", "AttrsOwner"], options: ["Expr"] ),
-        "TraitDef": (
-            traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner", "TypeParamsOwner", "TypeBoundsOwner"],
-            options: ["ItemList"]
-        ),
-        "Module": (
-            traits: ["VisibilityOwner", "NameOwner", "AttrsOwner", "DocCommentsOwner" ],
-            options: [ "ItemList" ]
-        ),
-        "ItemList": (
-            collections: [("impl_items", "ImplItem")],
-            traits: [ "FnDefOwner", "ModuleItemOwner" ],
-        ),
-        "ConstDef": (
-            traits: [
-                "VisibilityOwner",
-                "NameOwner",
-                "TypeParamsOwner",
-                "AttrsOwner",
-                "DocCommentsOwner",
-                "TypeAscriptionOwner",
-            ],
-            options: [ ["body","Expr"]],
-        ),
-        "StaticDef": (
-            traits: [
-                "VisibilityOwner",
-                "NameOwner",
-                "TypeParamsOwner",
-                "AttrsOwner",
-                "DocCommentsOwner",
-                "TypeAscriptionOwner",
-            ],
-            options: [ ["body","Expr"]],
-        ),
-        "TypeAliasDef": (
-            traits: [
-                "VisibilityOwner",
-                "NameOwner",
-                "TypeParamsOwner",
-                "AttrsOwner",
-                "DocCommentsOwner",
-                "TypeBoundsOwner",
-            ],
-            options: ["TypeRef"]
-        ),
-        "ImplBlock": (options: ["ItemList"], traits: ["TypeParamsOwner", "AttrsOwner"]),
-
-        "ParenType": (options: ["TypeRef"]),
-        "TupleType": ( collections: [("fields", "TypeRef")] ),
-        "NeverType": (),
-        "PathType": (options: ["Path"]),
-        "PointerType": (options: ["TypeRef"]),
-        "ArrayType": ( options: ["TypeRef", "Expr"] ),
-        "SliceType": ( options: ["TypeRef"] ),
-        "ReferenceType": (options: ["TypeRef"]),
-        "PlaceholderType": (),
-        "FnPointerType": (options: ["ParamList", "RetType"]),
-        "ForType": (options: ["TypeRef"]),
-        "ImplTraitType": (
-            traits: ["TypeBoundsOwner"],
-        ),
-        "DynTraitType": (
-            traits: ["TypeBoundsOwner"],
-        ),
-
-        "TypeRef": ( enum: [
-            "ParenType",
-            "TupleType",
-            "NeverType",
-            "PathType",
-            "PointerType",
-            "ArrayType",
-            "SliceType",
-            "ReferenceType",
-            "PlaceholderType",
-            "FnPointerType",
-            "ForType",
-            "ImplTraitType",
-            "DynTraitType",
-        ]),
-
-        "NominalDef": (
-            enum: ["StructDef", "EnumDef", "UnionDef"],
-            traits: [
-                "NameOwner",
-                "TypeParamsOwner",
-                "AttrsOwner"
-            ],
-        ),
-        "ModuleItem": (
-            enum: ["StructDef", "UnionDef", "EnumDef", "FnDef", "TraitDef", "TypeAliasDef", "ImplBlock",
-                   "UseItem", "ExternCrateItem", "ConstDef", "StaticDef", "Module" ],
-            traits: ["AttrsOwner", "VisibilityOwner"],
-        ),
-        "ImplItem": (
-            enum: ["FnDef", "TypeAliasDef", "ConstDef"],
-            traits: ["AttrsOwner"]
-        ),
-
-        "TupleExpr": (
-            collections: [("exprs", "Expr")]
-        ),
-        "ArrayExpr": (
-            collections: [("exprs", "Expr")]
-        ),
-        "ParenExpr": (options: ["Expr"]),
-        "PathExpr": (options: ["Path"]),
-        "LambdaExpr": (
-            options: [
-                "ParamList", "RetType",
-                ["body", "Expr"],
-            ]
-        ),
-        "IfExpr": (
-            options: [ "Condition" ]
-        ),
-        "LoopExpr": (
-            traits: ["LoopBodyOwner"],
-        ),
-        "TryBlockExpr": (
-            options: [["body", "BlockExpr"]],
-        ),
-        "ForExpr": (
-            traits: ["LoopBodyOwner"],
-            options: [
-                "Pat",
-                ["iterable", "Expr"],
-            ]
-        ),
-        "WhileExpr": (
-            traits: ["LoopBodyOwner"],
-            options: [ "Condition" ]
-        ),
-        "ContinueExpr": (),
-        "BreakExpr": (options: ["Expr"]),
-        "Label": (),
-        "BlockExpr": (
-            options: [ "Block" ]
-        ),
-        "ReturnExpr": (options: ["Expr"]),
-        "MatchExpr": (
-            options: [ "Expr", "MatchArmList" ],
-        ),
-        "MatchArmList": (
-            collections: [ ("arms", "MatchArm") ],
-            traits: [ "AttrsOwner" ]
-        ),
-        "MatchArm": (
-            options: [
-                [ "guard", "MatchGuard" ],
-                "Expr",
-            ],
-            collections: [ ("pats", "Pat") ],
-            traits: [ "AttrsOwner" ]
-        ),
-        "MatchGuard": (options: ["Expr"]),
-        "RecordLit": (options: ["Path", "RecordFieldList"]),
-        "RecordFieldList": (
-            collections: [ ("fields", "RecordField") ],
-            options: [["spread", "Expr"]]
-        ),
-        "RecordField": (options: ["NameRef", "Expr"]),
-        "CallExpr": (
-            traits: ["ArgListOwner"],
-            options: [ "Expr" ],
-        ),
-        "MethodCallExpr": (
-            traits: ["ArgListOwner"],
-            options: [ "Expr", "NameRef", "TypeArgList" ],
-        ),
-        "IndexExpr": (),
-        "FieldExpr": (options: ["Expr", "NameRef"]),
-        "AwaitExpr": (options: ["Expr"]),
-        "TryExpr": (options: ["Expr"]),
-        "CastExpr": (options: ["Expr", "TypeRef"]),
-        "RefExpr": (options: ["Expr"]),
-        "PrefixExpr": (options: ["Expr"]),
-        "BoxExpr": (options: ["Expr"]),
-        "RangeExpr": (),
-        "BinExpr": (),
-
-        "Literal": (),
-
-        "Expr": (
-            enum: [
-                "TupleExpr",
-                "ArrayExpr",
-                "ParenExpr",
-                "PathExpr",
-                "LambdaExpr",
-                "IfExpr",
-                "LoopExpr",
-                "ForExpr",
-                "WhileExpr",
-                "ContinueExpr",
-                "BreakExpr",
-                "Label",
-                "BlockExpr",
-                "ReturnExpr",
-                "MatchExpr",
-                "RecordLit",
-                "CallExpr",
-                "IndexExpr",
-                "MethodCallExpr",
-                "FieldExpr",
-                "AwaitExpr",
-                "TryExpr",
-                "TryBlockExpr",
-                "CastExpr",
-                "RefExpr",
-                "PrefixExpr",
-                "RangeExpr",
-                "BinExpr",
-                "Literal",
-                "MacroCall",
-                "BoxExpr",
-            ],
-        ),
-
-        "RefPat": ( options: [ "Pat" ]),
-        "BoxPat": ( options: [ "Pat" ]),
-        "BindPat": (
-            options: [ "Pat" ],
-            traits: ["NameOwner"]
-        ),
-        "PlaceholderPat": (),
-        "DotDotPat": (),
-        "PathPat": ( options: [ "Path" ] ),
-        "RecordPat": ( options: ["RecordFieldPatList", "Path"] ),
-        "RecordFieldPatList": (
-            collections: [
-                ("record_field_pats", "RecordFieldPat"),
-                ("bind_pats", "BindPat"),
-            ]
-        ),
-        "RecordFieldPat": (
-            traits: ["NameOwner"],
-            options: ["Pat"]
-        ),
-        "TupleStructPat": (
-            options: ["Path"],
-            collections: [("args", "Pat")],
-        ),
-        "TuplePat": ( collections: [("args", "Pat")] ),
-        "SlicePat": (),
-        "RangePat": (),
-        "LiteralPat": (options: ["Literal"]),
-
-        "Pat": (
-            enum: [
-                "RefPat",
-                "BoxPat",
-                "BindPat",
-                "PlaceholderPat",
-                "DotDotPat",
-                "PathPat",
-                "RecordPat",
-                "TupleStructPat",
-                "TuplePat",
-                "SlicePat",
-                "RangePat",
-                "LiteralPat",
-            ],
-        ),
-
-        "Visibility": (),
-        "Name": (),
-        "NameRef": (),
-        "MacroCall": (
-            traits: [ "NameOwner", "AttrsOwner","DocCommentsOwner" ],
-            options: [ "TokenTree", "Path" ],
-        ),
-        "AttrInput": ( enum: [ "Literal", "TokenTree" ] ),
-        "Attr": ( options: [ "Path", [ "input", "AttrInput" ] ] ),
-        "TokenTree": (),
-        "TypeParamList": (
-            collections: [
-                ("type_params", "TypeParam" ),
-                ("lifetime_params", "LifetimeParam" ),
-            ]
-        ),
-        "TypeParam": (
-            options: [("default_type", "TypeRef")],
-            traits: ["NameOwner", "AttrsOwner", "TypeBoundsOwner"],
-        ),
-        "ConstParam": (
-            options: [("default_val", "Expr")],
-            traits: ["NameOwner", "AttrsOwner", "TypeAscriptionOwner"],
-        ),
-        "LifetimeParam": (
-            traits: ["AttrsOwner"],
-        ),
-        "TypeBound": (
-            options: [
-                "TypeRef",
-            ]
-        ),
-        "TypeBoundList": (
-            collections: [
-                ("bounds", "TypeBound"),
-            ]
-        ),
-        "WherePred": (
-            options: [
-                "TypeRef",
-            ],
-            traits: [
-                "TypeBoundsOwner",
-            ],
-        ),
-        "WhereClause": (
-            collections: [
-                ("predicates", "WherePred"),
-            ],
-        ),
-        "ExprStmt": (
-            options: [ ["expr", "Expr"] ]
-        ),
-        "LetStmt": (
-            options: [
-                ["pat", "Pat"],
-                ["initializer", "Expr"],
-            ],
-            traits: [
-                "TypeAscriptionOwner",
-            ]
-        ),
-        "Condition": (
-            options: [ "Pat", "Expr" ]
-        ),
-        "Stmt": (
-            enum: ["ExprStmt", "LetStmt"],
-        ),
-        "Block": (
-            options: [ "Expr" ],
-            collections: [
-                ("statements", "Stmt"),
-            ],
-            traits: [
-                "AttrsOwner",
-                "ModuleItemOwner",
-            ]
-        ),
-        "ParamList": (
-            options: [ "SelfParam" ],
-            collections: [
-                ("params", "Param"),
-            ]
-        ),
-        "SelfParam": (
-            traits: [
-                "TypeAscriptionOwner",
-                "AttrsOwner",
-            ]
-        ),
-        "Param": (
-            options: [ "Pat" ],
-            traits: [
-                "TypeAscriptionOwner",
-                "AttrsOwner",
-            ]
-        ),
-        "UseItem": (
-            traits: ["AttrsOwner", "VisibilityOwner"],
-            options: [ "UseTree" ],
-        ),
-        "UseTree": (
-            options: [ "Path", "UseTreeList", "Alias" ]
-        ),
-        "Alias": (
-            traits: ["NameOwner"],
-        ),
-        "UseTreeList": (
-            collections: [("use_trees", "UseTree")]
-        ),
-        "ExternCrateItem": (
-            traits: ["AttrsOwner", "VisibilityOwner"],
-            options: ["NameRef", "Alias"],
-        ),
-        "ArgList": (
-            collections: [
-                ("args", "Expr"),
-            ]
-        ),
-        "Path": (
-            options: [
-                ["segment", "PathSegment"],
-                ["qualifier", "Path"],
-            ]
-        ),
-        "PathSegment": (
-            options: [ "NameRef", "TypeArgList", "ParamList", "RetType", "PathType" ]
-        ),
-        "TypeArgList": (collections: [
-            ("type_args", "TypeArg"),
-            ("lifetime_args", "LifetimeArg"),
-            ("assoc_type_args", "AssocTypeArg"),
-        ]),
-        "TypeArg": (options: ["TypeRef"]),
-        "AssocTypeArg": (options: ["NameRef", "TypeRef"]),
-        "LifetimeArg": (),
-
-        "MacroItems": (
-            traits: [ "ModuleItemOwner", "FnDefOwner" ],
-        ),
-
-        "MacroStmts" : (
-            options: [ "Expr" ],
-            collections: [
-                ("statements", "Stmt"),
-            ],
-        )
     },
 )
-- 
cgit v1.2.3