diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 1e0ba3f71b..f5199e09f2 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1,4 +1,6 @@
 //! This file is actually hand-written, but the submodules are indeed generated.
 
+#[rustfmt::skip]
 pub(super) mod nodes;
+#[rustfmt::skip]
 pub(super) mod tokens;
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 18bf306577..6e258250c4 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -29,17 +29,13 @@ impl AstNode for SourceFile {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::ModuleItemOwner for SourceFile {}
 impl ast::FnDefOwner for SourceFile {}
 impl ast::AttrsOwner for SourceFile {}
 impl SourceFile {
-    pub fn modules(&self) -> AstChildren<Module> {
-        support::children(&self.syntax)
-    }
+    pub fn modules(&self) -> AstChildren<Module> { support::children(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FnDef {
@@ -64,9 +60,7 @@ impl AstNode for FnDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::VisibilityOwner for FnDef {}
 impl ast::NameOwner for FnDef {}
@@ -74,36 +68,16 @@ impl ast::TypeParamsOwner for FnDef {}
 impl ast::DocCommentsOwner for FnDef {}
 impl ast::AttrsOwner for FnDef {}
 impl FnDef {
-    pub fn abi(&self) -> Option<Abi> {
-        support::child(&self.syntax)
-    }
-    pub fn const_kw(&self) -> Option<ConstKw> {
-        support::token(&self.syntax)
-    }
-    pub fn default_kw(&self) -> Option<DefaultKw> {
-        support::token(&self.syntax)
-    }
-    pub fn async_kw(&self) -> Option<AsyncKw> {
-        support::token(&self.syntax)
-    }
-    pub fn unsafe_kw(&self) -> Option<UnsafeKw> {
-        support::token(&self.syntax)
-    }
-    pub fn fn_kw(&self) -> Option<FnKw> {
-        support::token(&self.syntax)
-    }
-    pub fn param_list(&self) -> Option<ParamList> {
-        support::child(&self.syntax)
-    }
-    pub fn ret_type(&self) -> Option<RetType> {
-        support::child(&self.syntax)
-    }
-    pub fn body(&self) -> Option<BlockExpr> {
-        support::child(&self.syntax)
-    }
-    pub fn semi(&self) -> Option<Semi> {
-        support::token(&self.syntax)
-    }
+    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
+    pub fn const_kw(&self) -> Option<ConstKw> { support::token(&self.syntax) }
+    pub fn default_kw(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
+    pub fn async_kw(&self) -> Option<AsyncKw> { support::token(&self.syntax) }
+    pub fn unsafe_kw(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
+    pub fn fn_kw(&self) -> Option<FnKw> { support::token(&self.syntax) }
+    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
+    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
+    pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
+    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RetType {
@@ -128,17 +102,11 @@ impl AstNode for RetType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RetType {
-    pub fn thin_arrow(&self) -> Option<ThinArrow> {
-        support::token(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
+    pub fn thin_arrow(&self) -> Option<ThinArrow> { support::token(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StructDef {
@@ -163,9 +131,7 @@ impl AstNode for StructDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::VisibilityOwner for StructDef {}
 impl ast::NameOwner for StructDef {}
@@ -173,15 +139,9 @@ impl ast::TypeParamsOwner for StructDef {}
 impl ast::AttrsOwner for StructDef {}
 impl ast::DocCommentsOwner for StructDef {}
 impl StructDef {
-    pub fn struct_kw(&self) -> Option<StructKw> {
-        support::token(&self.syntax)
-    }
-    pub fn field_def_list(&self) -> Option<FieldDefList> {
-        support::child(&self.syntax)
-    }
-    pub fn semi(&self) -> Option<Semi> {
-        support::token(&self.syntax)
-    }
+    pub fn struct_kw(&self) -> Option<StructKw> { support::token(&self.syntax) }
+    pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
+    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UnionDef {
@@ -206,9 +166,7 @@ impl AstNode for UnionDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::VisibilityOwner for UnionDef {}
 impl ast::NameOwner for UnionDef {}
@@ -216,9 +174,7 @@ impl ast::TypeParamsOwner for UnionDef {}
 impl ast::AttrsOwner for UnionDef {}
 impl ast::DocCommentsOwner for UnionDef {}
 impl UnionDef {
-    pub fn union_kw(&self) -> Option<UnionKw> {
-        support::token(&self.syntax)
-    }
+    pub fn union_kw(&self) -> Option<UnionKw> { support::token(&self.syntax) }
     pub fn record_field_def_list(&self) -> Option<RecordFieldDefList> {
         support::child(&self.syntax)
     }
@@ -246,20 +202,12 @@ impl AstNode for RecordFieldDefList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RecordFieldDefList {
-    pub fn l_curly(&self) -> Option<LCurly> {
-        support::token(&self.syntax)
-    }
-    pub fn fields(&self) -> AstChildren<RecordFieldDef> {
-        support::children(&self.syntax)
-    }
-    pub fn r_curly(&self) -> Option<RCurly> {
-        support::token(&self.syntax)
-    }
+    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn fields(&self) -> AstChildren<RecordFieldDef> { support::children(&self.syntax) }
+    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordFieldDef {
@@ -284,9 +232,7 @@ impl AstNode for RecordFieldDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::VisibilityOwner for RecordFieldDef {}
 impl ast::NameOwner for RecordFieldDef {}
@@ -317,20 +263,12 @@ impl AstNode for TupleFieldDefList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TupleFieldDefList {
-    pub fn l_paren(&self) -> Option<LParen> {
-        support::token(&self.syntax)
-    }
-    pub fn fields(&self) -> AstChildren<TupleFieldDef> {
-        support::children(&self.syntax)
-    }
-    pub fn r_paren(&self) -> Option<RParen> {
-        support::token(&self.syntax)
-    }
+    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn fields(&self) -> AstChildren<TupleFieldDef> { support::children(&self.syntax) }
+    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleFieldDef {
@@ -355,16 +293,12 @@ impl AstNode for TupleFieldDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::VisibilityOwner for TupleFieldDef {}
 impl ast::AttrsOwner for TupleFieldDef {}
 impl TupleFieldDef {
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EnumDef {
@@ -389,9 +323,7 @@ impl AstNode for EnumDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::VisibilityOwner for EnumDef {}
 impl ast::NameOwner for EnumDef {}
@@ -399,12 +331,8 @@ impl ast::TypeParamsOwner for EnumDef {}
 impl ast::AttrsOwner for EnumDef {}
 impl ast::DocCommentsOwner for EnumDef {}
 impl EnumDef {
-    pub fn enum_kw(&self) -> Option<EnumKw> {
-        support::token(&self.syntax)
-    }
-    pub fn variant_list(&self) -> Option<EnumVariantList> {
-        support::child(&self.syntax)
-    }
+    pub fn enum_kw(&self) -> Option<EnumKw> { support::token(&self.syntax) }
+    pub fn variant_list(&self) -> Option<EnumVariantList> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EnumVariantList {
@@ -429,20 +357,12 @@ impl AstNode for EnumVariantList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl EnumVariantList {
-    pub fn l_curly(&self) -> Option<LCurly> {
-        support::token(&self.syntax)
-    }
-    pub fn variants(&self) -> AstChildren<EnumVariant> {
-        support::children(&self.syntax)
-    }
-    pub fn r_curly(&self) -> Option<RCurly> {
-        support::token(&self.syntax)
-    }
+    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn variants(&self) -> AstChildren<EnumVariant> { support::children(&self.syntax) }
+    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EnumVariant {
@@ -467,24 +387,16 @@ impl AstNode for EnumVariant {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::VisibilityOwner for EnumVariant {}
 impl ast::NameOwner for EnumVariant {}
 impl ast::DocCommentsOwner for EnumVariant {}
 impl ast::AttrsOwner for EnumVariant {}
 impl EnumVariant {
-    pub fn field_def_list(&self) -> Option<FieldDefList> {
-        support::child(&self.syntax)
-    }
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TraitDef {
@@ -509,9 +421,7 @@ impl AstNode for TraitDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::VisibilityOwner for TraitDef {}
 impl ast::NameOwner for TraitDef {}
@@ -520,18 +430,10 @@ impl ast::DocCommentsOwner for TraitDef {}
 impl ast::TypeParamsOwner for TraitDef {}
 impl ast::TypeBoundsOwner for TraitDef {}
 impl TraitDef {
-    pub fn unsafe_kw(&self) -> Option<UnsafeKw> {
-        support::token(&self.syntax)
-    }
-    pub fn auto_kw(&self) -> Option<AutoKw> {
-        support::token(&self.syntax)
-    }
-    pub fn trait_kw(&self) -> Option<TraitKw> {
-        support::token(&self.syntax)
-    }
-    pub fn item_list(&self) -> Option<ItemList> {
-        support::child(&self.syntax)
-    }
+    pub fn unsafe_kw(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
+    pub fn auto_kw(&self) -> Option<AutoKw> { support::token(&self.syntax) }
+    pub fn trait_kw(&self) -> Option<TraitKw> { support::token(&self.syntax) }
+    pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Module {
@@ -556,24 +458,16 @@ impl AstNode for Module {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &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 mod_kw(&self) -> Option<ModKw> {
-        support::token(&self.syntax)
-    }
-    pub fn item_list(&self) -> Option<ItemList> {
-        support::child(&self.syntax)
-    }
-    pub fn semi(&self) -> Option<Semi> {
-        support::token(&self.syntax)
-    }
+    pub fn mod_kw(&self) -> Option<ModKw> { support::token(&self.syntax) }
+    pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
+    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ItemList {
@@ -598,22 +492,14 @@ impl AstNode for ItemList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::FnDefOwner for ItemList {}
 impl ast::ModuleItemOwner for ItemList {}
 impl ItemList {
-    pub fn l_curly(&self) -> Option<LCurly> {
-        support::token(&self.syntax)
-    }
-    pub fn impl_items(&self) -> AstChildren<ImplItem> {
-        support::children(&self.syntax)
-    }
-    pub fn r_curly(&self) -> Option<RCurly> {
-        support::token(&self.syntax)
-    }
+    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn impl_items(&self) -> AstChildren<ImplItem> { support::children(&self.syntax) }
+    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ConstDef {
@@ -638,9 +524,7 @@ impl AstNode for ConstDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::VisibilityOwner for ConstDef {}
 impl ast::NameOwner for ConstDef {}
@@ -649,21 +533,11 @@ impl ast::AttrsOwner for ConstDef {}
 impl ast::DocCommentsOwner for ConstDef {}
 impl ast::TypeAscriptionOwner for ConstDef {}
 impl ConstDef {
-    pub fn default_kw(&self) -> Option<DefaultKw> {
-        support::token(&self.syntax)
-    }
-    pub fn const_kw(&self) -> Option<ConstKw> {
-        support::token(&self.syntax)
-    }
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn body(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn semi(&self) -> Option<Semi> {
-        support::token(&self.syntax)
-    }
+    pub fn default_kw(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
+    pub fn const_kw(&self) -> Option<ConstKw> { support::token(&self.syntax) }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StaticDef {
@@ -688,9 +562,7 @@ impl AstNode for StaticDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::VisibilityOwner for StaticDef {}
 impl ast::NameOwner for StaticDef {}
@@ -699,21 +571,11 @@ impl ast::AttrsOwner for StaticDef {}
 impl ast::DocCommentsOwner for StaticDef {}
 impl ast::TypeAscriptionOwner for StaticDef {}
 impl StaticDef {
-    pub fn static_kw(&self) -> Option<StaticKw> {
-        support::token(&self.syntax)
-    }
-    pub fn mut_kw(&self) -> Option<MutKw> {
-        support::token(&self.syntax)
-    }
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn body(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn semi(&self) -> Option<Semi> {
-        support::token(&self.syntax)
-    }
+    pub fn static_kw(&self) -> Option<StaticKw> { support::token(&self.syntax) }
+    pub fn mut_kw(&self) -> Option<MutKw> { support::token(&self.syntax) }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeAliasDef {
@@ -738,9 +600,7 @@ impl AstNode for TypeAliasDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::VisibilityOwner for TypeAliasDef {}
 impl ast::NameOwner for TypeAliasDef {}
@@ -749,21 +609,11 @@ impl ast::AttrsOwner for TypeAliasDef {}
 impl ast::DocCommentsOwner for TypeAliasDef {}
 impl ast::TypeBoundsOwner for TypeAliasDef {}
 impl TypeAliasDef {
-    pub fn default_kw(&self) -> Option<DefaultKw> {
-        support::token(&self.syntax)
-    }
-    pub fn type_kw(&self) -> Option<TypeKw> {
-        support::token(&self.syntax)
-    }
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
-    pub fn semi(&self) -> Option<Semi> {
-        support::token(&self.syntax)
-    }
+    pub fn default_kw(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
+    pub fn type_kw(&self) -> Option<TypeKw> { support::token(&self.syntax) }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ImplDef {
@@ -788,34 +638,18 @@ impl AstNode for ImplDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::TypeParamsOwner for ImplDef {}
 impl ast::AttrsOwner for ImplDef {}
 impl ImplDef {
-    pub fn default_kw(&self) -> Option<DefaultKw> {
-        support::token(&self.syntax)
-    }
-    pub fn const_kw(&self) -> Option<ConstKw> {
-        support::token(&self.syntax)
-    }
-    pub fn unsafe_kw(&self) -> Option<UnsafeKw> {
-        support::token(&self.syntax)
-    }
-    pub fn impl_kw(&self) -> Option<ImplKw> {
-        support::token(&self.syntax)
-    }
-    pub fn excl(&self) -> Option<Excl> {
-        support::token(&self.syntax)
-    }
-    pub fn for_kw(&self) -> Option<ForKw> {
-        support::token(&self.syntax)
-    }
-    pub fn item_list(&self) -> Option<ItemList> {
-        support::child(&self.syntax)
-    }
+    pub fn default_kw(&self) -> Option<DefaultKw> { support::token(&self.syntax) }
+    pub fn const_kw(&self) -> Option<ConstKw> { support::token(&self.syntax) }
+    pub fn unsafe_kw(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
+    pub fn impl_kw(&self) -> Option<ImplKw> { support::token(&self.syntax) }
+    pub fn excl(&self) -> Option<Excl> { support::token(&self.syntax) }
+    pub fn for_kw(&self) -> Option<ForKw> { support::token(&self.syntax) }
+    pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParenType {
@@ -840,20 +674,12 @@ impl AstNode for ParenType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ParenType {
-    pub fn l_paren(&self) -> Option<LParen> {
-        support::token(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
-    pub fn r_paren(&self) -> Option<RParen> {
-        support::token(&self.syntax)
-    }
+    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleType {
@@ -878,20 +704,12 @@ impl AstNode for TupleType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TupleType {
-    pub fn l_paren(&self) -> Option<LParen> {
-        support::token(&self.syntax)
-    }
-    pub fn fields(&self) -> AstChildren<TypeRef> {
-        support::children(&self.syntax)
-    }
-    pub fn r_paren(&self) -> Option<RParen> {
-        support::token(&self.syntax)
-    }
+    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn fields(&self) -> AstChildren<TypeRef> { support::children(&self.syntax) }
+    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NeverType {
@@ -916,14 +734,10 @@ impl AstNode for NeverType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl NeverType {
-    pub fn excl(&self) -> Option<Excl> {
-        support::token(&self.syntax)
-    }
+    pub fn excl(&self) -> Option<Excl> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PathType {
@@ -948,14 +762,10 @@ impl AstNode for PathType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl PathType {
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
-    }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PointerType {
@@ -980,20 +790,12 @@ impl AstNode for PointerType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl PointerType {
-    pub fn star(&self) -> Option<Star> {
-        support::token(&self.syntax)
-    }
-    pub fn const_kw(&self) -> Option<ConstKw> {
-        support::token(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
+    pub fn star(&self) -> Option<Star> { support::token(&self.syntax) }
+    pub fn const_kw(&self) -> Option<ConstKw> { support::token(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ArrayType {
@@ -1018,26 +820,14 @@ impl AstNode for ArrayType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ArrayType {
-    pub fn l_brack(&self) -> Option<LBrack> {
-        support::token(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
-    pub fn semi(&self) -> Option<Semi> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn r_brack(&self) -> Option<RBrack> {
-        support::token(&self.syntax)
-    }
+    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SliceType {
@@ -1062,20 +852,12 @@ impl AstNode for SliceType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl SliceType {
-    pub fn l_brack(&self) -> Option<LBrack> {
-        support::token(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
-    pub fn r_brack(&self) -> Option<RBrack> {
-        support::token(&self.syntax)
-    }
+    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
+    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ReferenceType {
@@ -1100,23 +882,13 @@ impl AstNode for ReferenceType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ReferenceType {
-    pub fn amp(&self) -> Option<Amp> {
-        support::token(&self.syntax)
-    }
-    pub fn lifetime(&self) -> Option<Lifetime> {
-        support::token(&self.syntax)
-    }
-    pub fn mut_kw(&self) -> Option<MutKw> {
-        support::token(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
+    pub fn amp(&self) -> Option<Amp> { support::token(&self.syntax) }
+    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn mut_kw(&self) -> Option<MutKw> { support::token(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PlaceholderType {
@@ -1141,14 +913,10 @@ impl AstNode for PlaceholderType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl PlaceholderType {
-    pub fn underscore(&self) -> Option<Underscore> {
-        support::token(&self.syntax)
-    }
+    pub fn underscore(&self) -> Option<Underscore> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FnPointerType {
@@ -1173,26 +941,14 @@ impl AstNode for FnPointerType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl FnPointerType {
-    pub fn abi(&self) -> Option<Abi> {
-        support::child(&self.syntax)
-    }
-    pub fn unsafe_kw(&self) -> Option<UnsafeKw> {
-        support::token(&self.syntax)
-    }
-    pub fn fn_kw(&self) -> Option<FnKw> {
-        support::token(&self.syntax)
-    }
-    pub fn param_list(&self) -> Option<ParamList> {
-        support::child(&self.syntax)
-    }
-    pub fn ret_type(&self) -> Option<RetType> {
-        support::child(&self.syntax)
-    }
+    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
+    pub fn unsafe_kw(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
+    pub fn fn_kw(&self) -> Option<FnKw> { support::token(&self.syntax) }
+    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
+    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ForType {
@@ -1217,20 +973,12 @@ impl AstNode for ForType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ForType {
-    pub fn for_kw(&self) -> Option<ForKw> {
-        support::token(&self.syntax)
-    }
-    pub fn type_param_list(&self) -> Option<TypeParamList> {
-        support::child(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
+    pub fn for_kw(&self) -> Option<ForKw> { support::token(&self.syntax) }
+    pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ImplTraitType {
@@ -1255,15 +1003,11 @@ impl AstNode for ImplTraitType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::TypeBoundsOwner for ImplTraitType {}
 impl ImplTraitType {
-    pub fn impl_kw(&self) -> Option<ImplKw> {
-        support::token(&self.syntax)
-    }
+    pub fn impl_kw(&self) -> Option<ImplKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DynTraitType {
@@ -1288,15 +1032,11 @@ impl AstNode for DynTraitType {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::TypeBoundsOwner for DynTraitType {}
 impl DynTraitType {
-    pub fn dyn_kw(&self) -> Option<DynKw> {
-        support::token(&self.syntax)
-    }
+    pub fn dyn_kw(&self) -> Option<DynKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleExpr {
@@ -1321,21 +1061,13 @@ impl AstNode for TupleExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for TupleExpr {}
 impl TupleExpr {
-    pub fn l_paren(&self) -> Option<LParen> {
-        support::token(&self.syntax)
-    }
-    pub fn exprs(&self) -> AstChildren<Expr> {
-        support::children(&self.syntax)
-    }
-    pub fn r_paren(&self) -> Option<RParen> {
-        support::token(&self.syntax)
-    }
+    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
+    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ArrayExpr {
@@ -1360,24 +1092,14 @@ impl AstNode for ArrayExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for ArrayExpr {}
 impl ArrayExpr {
-    pub fn l_brack(&self) -> Option<LBrack> {
-        support::token(&self.syntax)
-    }
-    pub fn exprs(&self) -> AstChildren<Expr> {
-        support::children(&self.syntax)
-    }
-    pub fn semi(&self) -> Option<Semi> {
-        support::token(&self.syntax)
-    }
-    pub fn r_brack(&self) -> Option<RBrack> {
-        support::token(&self.syntax)
-    }
+    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
+    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
+    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParenExpr {
@@ -1402,21 +1124,13 @@ impl AstNode for ParenExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for ParenExpr {}
 impl ParenExpr {
-    pub fn l_paren(&self) -> Option<LParen> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn r_paren(&self) -> Option<RParen> {
-        support::token(&self.syntax)
-    }
+    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PathExpr {
@@ -1441,14 +1155,10 @@ impl AstNode for PathExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl PathExpr {
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
-    }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LambdaExpr {
@@ -1473,30 +1183,16 @@ impl AstNode for LambdaExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for LambdaExpr {}
 impl LambdaExpr {
-    pub fn static_kw(&self) -> Option<StaticKw> {
-        support::token(&self.syntax)
-    }
-    pub fn async_kw(&self) -> Option<AsyncKw> {
-        support::token(&self.syntax)
-    }
-    pub fn move_kw(&self) -> Option<MoveKw> {
-        support::token(&self.syntax)
-    }
-    pub fn param_list(&self) -> Option<ParamList> {
-        support::child(&self.syntax)
-    }
-    pub fn ret_type(&self) -> Option<RetType> {
-        support::child(&self.syntax)
-    }
-    pub fn body(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn static_kw(&self) -> Option<StaticKw> { support::token(&self.syntax) }
+    pub fn async_kw(&self) -> Option<AsyncKw> { support::token(&self.syntax) }
+    pub fn move_kw(&self) -> Option<MoveKw> { support::token(&self.syntax) }
+    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
+    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
+    pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct IfExpr {
@@ -1521,18 +1217,12 @@ impl AstNode for IfExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for IfExpr {}
 impl IfExpr {
-    pub fn if_kw(&self) -> Option<IfKw> {
-        support::token(&self.syntax)
-    }
-    pub fn condition(&self) -> Option<Condition> {
-        support::child(&self.syntax)
-    }
+    pub fn if_kw(&self) -> Option<IfKw> { support::token(&self.syntax) }
+    pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LoopExpr {
@@ -1557,16 +1247,12 @@ impl AstNode for LoopExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for LoopExpr {}
 impl ast::LoopBodyOwner for LoopExpr {}
 impl LoopExpr {
-    pub fn loop_kw(&self) -> Option<LoopKw> {
-        support::token(&self.syntax)
-    }
+    pub fn loop_kw(&self) -> Option<LoopKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TryBlockExpr {
@@ -1591,18 +1277,12 @@ impl AstNode for TryBlockExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for TryBlockExpr {}
 impl TryBlockExpr {
-    pub fn try_kw(&self) -> Option<TryKw> {
-        support::token(&self.syntax)
-    }
-    pub fn body(&self) -> Option<BlockExpr> {
-        support::child(&self.syntax)
-    }
+    pub fn try_kw(&self) -> Option<TryKw> { support::token(&self.syntax) }
+    pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ForExpr {
@@ -1627,25 +1307,15 @@ impl AstNode for ForExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for ForExpr {}
 impl ast::LoopBodyOwner for ForExpr {}
 impl ForExpr {
-    pub fn for_kw(&self) -> Option<ForKw> {
-        support::token(&self.syntax)
-    }
-    pub fn pat(&self) -> Option<Pat> {
-        support::child(&self.syntax)
-    }
-    pub fn in_kw(&self) -> Option<InKw> {
-        support::token(&self.syntax)
-    }
-    pub fn iterable(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn for_kw(&self) -> Option<ForKw> { support::token(&self.syntax) }
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
+    pub fn in_kw(&self) -> Option<InKw> { support::token(&self.syntax) }
+    pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct WhileExpr {
@@ -1670,19 +1340,13 @@ impl AstNode for WhileExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for WhileExpr {}
 impl ast::LoopBodyOwner for WhileExpr {}
 impl WhileExpr {
-    pub fn while_kw(&self) -> Option<WhileKw> {
-        support::token(&self.syntax)
-    }
-    pub fn condition(&self) -> Option<Condition> {
-        support::child(&self.syntax)
-    }
+    pub fn while_kw(&self) -> Option<WhileKw> { support::token(&self.syntax) }
+    pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ContinueExpr {
@@ -1707,18 +1371,12 @@ impl AstNode for ContinueExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for ContinueExpr {}
 impl ContinueExpr {
-    pub fn continue_kw(&self) -> Option<ContinueKw> {
-        support::token(&self.syntax)
-    }
-    pub fn lifetime(&self) -> Option<Lifetime> {
-        support::token(&self.syntax)
-    }
+    pub fn continue_kw(&self) -> Option<ContinueKw> { support::token(&self.syntax) }
+    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BreakExpr {
@@ -1743,21 +1401,13 @@ impl AstNode for BreakExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for BreakExpr {}
 impl BreakExpr {
-    pub fn break_kw(&self) -> Option<BreakKw> {
-        support::token(&self.syntax)
-    }
-    pub fn lifetime(&self) -> Option<Lifetime> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn break_kw(&self) -> Option<BreakKw> { support::token(&self.syntax) }
+    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Label {
@@ -1782,14 +1432,10 @@ impl AstNode for Label {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Label {
-    pub fn lifetime(&self) -> Option<Lifetime> {
-        support::token(&self.syntax)
-    }
+    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BlockExpr {
@@ -1814,21 +1460,13 @@ impl AstNode for BlockExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for BlockExpr {}
 impl BlockExpr {
-    pub fn label(&self) -> Option<Label> {
-        support::child(&self.syntax)
-    }
-    pub fn unsafe_kw(&self) -> Option<UnsafeKw> {
-        support::token(&self.syntax)
-    }
-    pub fn block(&self) -> Option<Block> {
-        support::child(&self.syntax)
-    }
+    pub fn label(&self) -> Option<Label> { support::child(&self.syntax) }
+    pub fn unsafe_kw(&self) -> Option<UnsafeKw> { support::token(&self.syntax) }
+    pub fn block(&self) -> Option<Block> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ReturnExpr {
@@ -1853,15 +1491,11 @@ impl AstNode for ReturnExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for ReturnExpr {}
 impl ReturnExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CallExpr {
@@ -1886,15 +1520,11 @@ impl AstNode for CallExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::ArgListOwner for CallExpr {}
 impl CallExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MethodCallExpr {
@@ -1919,25 +1549,15 @@ impl AstNode for MethodCallExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for MethodCallExpr {}
 impl ast::ArgListOwner for MethodCallExpr {}
 impl MethodCallExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn dot(&self) -> Option<Dot> {
-        support::token(&self.syntax)
-    }
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
-    }
-    pub fn type_arg_list(&self) -> Option<TypeArgList> {
-        support::child(&self.syntax)
-    }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn dot(&self) -> Option<Dot> { support::token(&self.syntax) }
+    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
+    pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct IndexExpr {
@@ -1962,18 +1582,12 @@ impl AstNode for IndexExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for IndexExpr {}
 impl IndexExpr {
-    pub fn l_brack(&self) -> Option<LBrack> {
-        support::token(&self.syntax)
-    }
-    pub fn r_brack(&self) -> Option<RBrack> {
-        support::token(&self.syntax)
-    }
+    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FieldExpr {
@@ -1998,21 +1612,13 @@ impl AstNode for FieldExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for FieldExpr {}
 impl FieldExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn dot(&self) -> Option<Dot> {
-        support::token(&self.syntax)
-    }
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
-    }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn dot(&self) -> Option<Dot> { support::token(&self.syntax) }
+    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AwaitExpr {
@@ -2037,21 +1643,13 @@ impl AstNode for AwaitExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for AwaitExpr {}
 impl AwaitExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn dot(&self) -> Option<Dot> {
-        support::token(&self.syntax)
-    }
-    pub fn await_kw(&self) -> Option<AwaitKw> {
-        support::token(&self.syntax)
-    }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn dot(&self) -> Option<Dot> { support::token(&self.syntax) }
+    pub fn await_kw(&self) -> Option<AwaitKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TryExpr {
@@ -2076,18 +1674,12 @@ impl AstNode for TryExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for TryExpr {}
 impl TryExpr {
-    pub fn try_kw(&self) -> Option<TryKw> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn try_kw(&self) -> Option<TryKw> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CastExpr {
@@ -2112,21 +1704,13 @@ impl AstNode for CastExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for CastExpr {}
 impl CastExpr {
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn as_kw(&self) -> Option<AsKw> {
-        support::token(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn as_kw(&self) -> Option<AsKw> { support::token(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RefExpr {
@@ -2151,24 +1735,14 @@ impl AstNode for RefExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for RefExpr {}
 impl RefExpr {
-    pub fn amp(&self) -> Option<Amp> {
-        support::token(&self.syntax)
-    }
-    pub fn raw_kw(&self) -> Option<RawKw> {
-        support::token(&self.syntax)
-    }
-    pub fn mut_kw(&self) -> Option<MutKw> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn amp(&self) -> Option<Amp> { support::token(&self.syntax) }
+    pub fn raw_kw(&self) -> Option<RawKw> { support::token(&self.syntax) }
+    pub fn mut_kw(&self) -> Option<MutKw> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PrefixExpr {
@@ -2193,18 +1767,12 @@ impl AstNode for PrefixExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for PrefixExpr {}
 impl PrefixExpr {
-    pub fn prefix_op(&self) -> Option<PrefixOp> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn prefix_op(&self) -> Option<PrefixOp> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BoxExpr {
@@ -2229,18 +1797,12 @@ impl AstNode for BoxExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for BoxExpr {}
 impl BoxExpr {
-    pub fn box_kw(&self) -> Option<BoxKw> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn box_kw(&self) -> Option<BoxKw> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RangeExpr {
@@ -2265,15 +1827,11 @@ impl AstNode for RangeExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for RangeExpr {}
 impl RangeExpr {
-    pub fn range_op(&self) -> Option<RangeOp> {
-        support::token(&self.syntax)
-    }
+    pub fn range_op(&self) -> Option<RangeOp> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BinExpr {
@@ -2298,15 +1856,11 @@ impl AstNode for BinExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for BinExpr {}
 impl BinExpr {
-    pub fn bin_op(&self) -> Option<BinOp> {
-        support::token(&self.syntax)
-    }
+    pub fn bin_op(&self) -> Option<BinOp> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Literal {
@@ -2331,14 +1885,10 @@ impl AstNode for Literal {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Literal {
-    pub fn literal_token(&self) -> Option<LiteralToken> {
-        support::token(&self.syntax)
-    }
+    pub fn literal_token(&self) -> Option<LiteralToken> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MatchExpr {
@@ -2363,21 +1913,13 @@ impl AstNode for MatchExpr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for MatchExpr {}
 impl MatchExpr {
-    pub fn match_kw(&self) -> Option<MatchKw> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn match_arm_list(&self) -> Option<MatchArmList> {
-        support::child(&self.syntax)
-    }
+    pub fn match_kw(&self) -> Option<MatchKw> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MatchArmList {
@@ -2402,21 +1944,13 @@ impl AstNode for MatchArmList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for MatchArmList {}
 impl MatchArmList {
-    pub fn l_curly(&self) -> Option<LCurly> {
-        support::token(&self.syntax)
-    }
-    pub fn arms(&self) -> AstChildren<MatchArm> {
-        support::children(&self.syntax)
-    }
-    pub fn r_curly(&self) -> Option<RCurly> {
-        support::token(&self.syntax)
-    }
+    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }
+    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MatchArm {
@@ -2441,24 +1975,14 @@ impl AstNode for MatchArm {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for MatchArm {}
 impl MatchArm {
-    pub fn pat(&self) -> Option<Pat> {
-        support::child(&self.syntax)
-    }
-    pub fn guard(&self) -> Option<MatchGuard> {
-        support::child(&self.syntax)
-    }
-    pub fn fat_arrow(&self) -> Option<FatArrow> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
+    pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) }
+    pub fn fat_arrow(&self) -> Option<FatArrow> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MatchGuard {
@@ -2483,17 +2007,11 @@ impl AstNode for MatchGuard {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl MatchGuard {
-    pub fn if_kw(&self) -> Option<IfKw> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn if_kw(&self) -> Option<IfKw> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordLit {
@@ -2518,17 +2036,11 @@ impl AstNode for RecordLit {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RecordLit {
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
-    }
-    pub fn record_field_list(&self) -> Option<RecordFieldList> {
-        support::child(&self.syntax)
-    }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
+    pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordFieldList {
@@ -2553,26 +2065,14 @@ impl AstNode for RecordFieldList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RecordFieldList {
-    pub fn l_curly(&self) -> Option<LCurly> {
-        support::token(&self.syntax)
-    }
-    pub fn fields(&self) -> AstChildren<RecordField> {
-        support::children(&self.syntax)
-    }
-    pub fn dotdot(&self) -> Option<Dotdot> {
-        support::token(&self.syntax)
-    }
-    pub fn spread(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn r_curly(&self) -> Option<RCurly> {
-        support::token(&self.syntax)
-    }
+    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) }
+    pub fn dotdot(&self) -> Option<Dotdot> { support::token(&self.syntax) }
+    pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordField {
@@ -2597,21 +2097,13 @@ impl AstNode for RecordField {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for RecordField {}
 impl RecordField {
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
-    }
-    pub fn colon(&self) -> Option<Colon> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
+    pub fn colon(&self) -> Option<Colon> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct OrPat {
@@ -2636,14 +2128,10 @@ impl AstNode for OrPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl OrPat {
-    pub fn pats(&self) -> AstChildren<Pat> {
-        support::children(&self.syntax)
-    }
+    pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParenPat {
@@ -2668,20 +2156,12 @@ impl AstNode for ParenPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ParenPat {
-    pub fn l_paren(&self) -> Option<LParen> {
-        support::token(&self.syntax)
-    }
-    pub fn pat(&self) -> Option<Pat> {
-        support::child(&self.syntax)
-    }
-    pub fn r_paren(&self) -> Option<RParen> {
-        support::token(&self.syntax)
-    }
+    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
+    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RefPat {
@@ -2706,20 +2186,12 @@ impl AstNode for RefPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RefPat {
-    pub fn amp(&self) -> Option<Amp> {
-        support::token(&self.syntax)
-    }
-    pub fn mut_kw(&self) -> Option<MutKw> {
-        support::token(&self.syntax)
-    }
-    pub fn pat(&self) -> Option<Pat> {
-        support::child(&self.syntax)
-    }
+    pub fn amp(&self) -> Option<Amp> { support::token(&self.syntax) }
+    pub fn mut_kw(&self) -> Option<MutKw> { support::token(&self.syntax) }
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BoxPat {
@@ -2744,17 +2216,11 @@ impl AstNode for BoxPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl BoxPat {
-    pub fn box_kw(&self) -> Option<BoxKw> {
-        support::token(&self.syntax)
-    }
-    pub fn pat(&self) -> Option<Pat> {
-        support::child(&self.syntax)
-    }
+    pub fn box_kw(&self) -> Option<BoxKw> { support::token(&self.syntax) }
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BindPat {
@@ -2779,22 +2245,14 @@ impl AstNode for BindPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for BindPat {}
 impl ast::NameOwner for BindPat {}
 impl BindPat {
-    pub fn ref_kw(&self) -> Option<RefKw> {
-        support::token(&self.syntax)
-    }
-    pub fn mut_kw(&self) -> Option<MutKw> {
-        support::token(&self.syntax)
-    }
-    pub fn pat(&self) -> Option<Pat> {
-        support::child(&self.syntax)
-    }
+    pub fn ref_kw(&self) -> Option<RefKw> { support::token(&self.syntax) }
+    pub fn mut_kw(&self) -> Option<MutKw> { support::token(&self.syntax) }
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PlaceholderPat {
@@ -2819,14 +2277,10 @@ impl AstNode for PlaceholderPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl PlaceholderPat {
-    pub fn underscore(&self) -> Option<Underscore> {
-        support::token(&self.syntax)
-    }
+    pub fn underscore(&self) -> Option<Underscore> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DotDotPat {
@@ -2851,14 +2305,10 @@ impl AstNode for DotDotPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl DotDotPat {
-    pub fn dotdot(&self) -> Option<Dotdot> {
-        support::token(&self.syntax)
-    }
+    pub fn dotdot(&self) -> Option<Dotdot> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PathPat {
@@ -2883,14 +2333,10 @@ impl AstNode for PathPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl PathPat {
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
-    }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SlicePat {
@@ -2915,20 +2361,12 @@ impl AstNode for SlicePat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl SlicePat {
-    pub fn l_brack(&self) -> Option<LBrack> {
-        support::token(&self.syntax)
-    }
-    pub fn args(&self) -> AstChildren<Pat> {
-        support::children(&self.syntax)
-    }
-    pub fn r_brack(&self) -> Option<RBrack> {
-        support::token(&self.syntax)
-    }
+    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
+    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RangePat {
@@ -2953,14 +2391,10 @@ impl AstNode for RangePat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RangePat {
-    pub fn range_separator(&self) -> Option<RangeSeparator> {
-        support::token(&self.syntax)
-    }
+    pub fn range_separator(&self) -> Option<RangeSeparator> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LiteralPat {
@@ -2985,14 +2419,10 @@ impl AstNode for LiteralPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl LiteralPat {
-    pub fn literal(&self) -> Option<Literal> {
-        support::child(&self.syntax)
-    }
+    pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MacroPat {
@@ -3017,14 +2447,10 @@ impl AstNode for MacroPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl MacroPat {
-    pub fn macro_call(&self) -> Option<MacroCall> {
-        support::child(&self.syntax)
-    }
+    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordPat {
@@ -3049,17 +2475,13 @@ impl AstNode for RecordPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RecordPat {
     pub fn record_field_pat_list(&self) -> Option<RecordFieldPatList> {
         support::child(&self.syntax)
     }
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
-    }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordFieldPatList {
@@ -3084,29 +2506,17 @@ impl AstNode for RecordFieldPatList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl RecordFieldPatList {
-    pub fn l_curly(&self) -> Option<LCurly> {
-        support::token(&self.syntax)
-    }
-    pub fn pats(&self) -> AstChildren<RecordInnerPat> {
-        support::children(&self.syntax)
-    }
+    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn pats(&self) -> AstChildren<RecordInnerPat> { support::children(&self.syntax) }
     pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> {
         support::children(&self.syntax)
     }
-    pub fn bind_pats(&self) -> AstChildren<BindPat> {
-        support::children(&self.syntax)
-    }
-    pub fn dotdot(&self) -> Option<Dotdot> {
-        support::token(&self.syntax)
-    }
-    pub fn r_curly(&self) -> Option<RCurly> {
-        support::token(&self.syntax)
-    }
+    pub fn bind_pats(&self) -> AstChildren<BindPat> { support::children(&self.syntax) }
+    pub fn dotdot(&self) -> Option<Dotdot> { support::token(&self.syntax) }
+    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RecordFieldPat {
@@ -3131,19 +2541,13 @@ impl AstNode for RecordFieldPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for RecordFieldPat {}
 impl ast::NameOwner for RecordFieldPat {}
 impl RecordFieldPat {
-    pub fn colon(&self) -> Option<Colon> {
-        support::token(&self.syntax)
-    }
-    pub fn pat(&self) -> Option<Pat> {
-        support::child(&self.syntax)
-    }
+    pub fn colon(&self) -> Option<Colon> { support::token(&self.syntax) }
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TupleStructPat {
@@ -3168,23 +2572,13 @@ impl AstNode for TupleStructPat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TupleStructPat {
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
-    }
-    pub fn l_paren(&self) -> Option<LParen> {
-        support::token(&self.syntax)
-    }
-    pub fn args(&self) -> AstChildren<Pat> {
-        support::children(&self.syntax)
-    }
-    pub fn r_paren(&self) -> Option<RParen> {
-        support::token(&self.syntax)
-    }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
+    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
+    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TuplePat {
@@ -3209,20 +2603,12 @@ impl AstNode for TuplePat {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TuplePat {
-    pub fn l_paren(&self) -> Option<LParen> {
-        support::token(&self.syntax)
-    }
-    pub fn args(&self) -> AstChildren<Pat> {
-        support::children(&self.syntax)
-    }
-    pub fn r_paren(&self) -> Option<RParen> {
-        support::token(&self.syntax)
-    }
+    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
+    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Visibility {
@@ -3247,23 +2633,13 @@ impl AstNode for Visibility {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Visibility {
-    pub fn pub_kw(&self) -> Option<PubKw> {
-        support::token(&self.syntax)
-    }
-    pub fn super_kw(&self) -> Option<SuperKw> {
-        support::token(&self.syntax)
-    }
-    pub fn self_kw(&self) -> Option<SelfKw> {
-        support::token(&self.syntax)
-    }
-    pub fn crate_kw(&self) -> Option<CrateKw> {
-        support::token(&self.syntax)
-    }
+    pub fn pub_kw(&self) -> Option<PubKw> { support::token(&self.syntax) }
+    pub fn super_kw(&self) -> Option<SuperKw> { support::token(&self.syntax) }
+    pub fn self_kw(&self) -> Option<SelfKw> { support::token(&self.syntax) }
+    pub fn crate_kw(&self) -> Option<CrateKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Name {
@@ -3288,14 +2664,10 @@ impl AstNode for Name {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Name {
-    pub fn ident(&self) -> Option<Ident> {
-        support::token(&self.syntax)
-    }
+    pub fn ident(&self) -> Option<Ident> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NameRef {
@@ -3320,14 +2692,10 @@ impl AstNode for NameRef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl NameRef {
-    pub fn name_ref_token(&self) -> Option<NameRefToken> {
-        support::token(&self.syntax)
-    }
+    pub fn name_ref_token(&self) -> Option<NameRefToken> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MacroCall {
@@ -3352,26 +2720,16 @@ impl AstNode for MacroCall {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::NameOwner for MacroCall {}
 impl ast::AttrsOwner for MacroCall {}
 impl ast::DocCommentsOwner for MacroCall {}
 impl MacroCall {
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
-    }
-    pub fn excl(&self) -> Option<Excl> {
-        support::token(&self.syntax)
-    }
-    pub fn token_tree(&self) -> Option<TokenTree> {
-        support::child(&self.syntax)
-    }
-    pub fn semi(&self) -> Option<Semi> {
-        support::token(&self.syntax)
-    }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
+    pub fn excl(&self) -> Option<Excl> { support::token(&self.syntax) }
+    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
+    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Attr {
@@ -3396,32 +2754,16 @@ impl AstNode for Attr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Attr {
-    pub fn pound(&self) -> Option<Pound> {
-        support::token(&self.syntax)
-    }
-    pub fn excl(&self) -> Option<Excl> {
-        support::token(&self.syntax)
-    }
-    pub fn l_brack(&self) -> Option<LBrack> {
-        support::token(&self.syntax)
-    }
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
-    }
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn input(&self) -> Option<AttrInput> {
-        support::child(&self.syntax)
-    }
-    pub fn r_brack(&self) -> Option<RBrack> {
-        support::token(&self.syntax)
-    }
+    pub fn pound(&self) -> Option<Pound> { support::token(&self.syntax) }
+    pub fn excl(&self) -> Option<Excl> { support::token(&self.syntax) }
+    pub fn l_brack(&self) -> Option<LBrack> { support::token(&self.syntax) }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
+    pub fn r_brack(&self) -> Option<RBrack> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TokenTree {
@@ -3446,9 +2788,7 @@ impl AstNode for TokenTree {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TokenTree {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -3474,29 +2814,15 @@ impl AstNode for TypeParamList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TypeParamList {
-    pub fn l_angle(&self) -> Option<LAngle> {
-        support::token(&self.syntax)
-    }
-    pub fn generic_params(&self) -> AstChildren<GenericParam> {
-        support::children(&self.syntax)
-    }
-    pub fn type_params(&self) -> AstChildren<TypeParam> {
-        support::children(&self.syntax)
-    }
-    pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> {
-        support::children(&self.syntax)
-    }
-    pub fn const_params(&self) -> AstChildren<ConstParam> {
-        support::children(&self.syntax)
-    }
-    pub fn r_angle(&self) -> Option<RAngle> {
-        support::token(&self.syntax)
-    }
+    pub fn l_angle(&self) -> Option<LAngle> { support::token(&self.syntax) }
+    pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) }
+    pub fn type_params(&self) -> AstChildren<TypeParam> { support::children(&self.syntax) }
+    pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> { support::children(&self.syntax) }
+    pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) }
+    pub fn r_angle(&self) -> Option<RAngle> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeParam {
@@ -3521,20 +2847,14 @@ impl AstNode for TypeParam {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::NameOwner for TypeParam {}
 impl ast::AttrsOwner for TypeParam {}
 impl ast::TypeBoundsOwner for TypeParam {}
 impl TypeParam {
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn default_type(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ConstParam {
@@ -3559,20 +2879,14 @@ impl AstNode for ConstParam {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::NameOwner for ConstParam {}
 impl ast::AttrsOwner for ConstParam {}
 impl ast::TypeAscriptionOwner for ConstParam {}
 impl ConstParam {
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn default_val(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LifetimeParam {
@@ -3597,15 +2911,11 @@ impl AstNode for LifetimeParam {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for LifetimeParam {}
 impl LifetimeParam {
-    pub fn lifetime(&self) -> Option<Lifetime> {
-        support::token(&self.syntax)
-    }
+    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeBound {
@@ -3630,20 +2940,12 @@ impl AstNode for TypeBound {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TypeBound {
-    pub fn lifetime(&self) -> Option<Lifetime> {
-        support::token(&self.syntax)
-    }
-    pub fn const_kw(&self) -> Option<ConstKw> {
-        support::token(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
+    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn const_kw(&self) -> Option<ConstKw> { support::token(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeBoundList {
@@ -3668,14 +2970,10 @@ impl AstNode for TypeBoundList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TypeBoundList {
-    pub fn bounds(&self) -> AstChildren<TypeBound> {
-        support::children(&self.syntax)
-    }
+    pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct WherePred {
@@ -3700,18 +2998,12 @@ impl AstNode for WherePred {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::TypeBoundsOwner for WherePred {}
 impl WherePred {
-    pub fn lifetime(&self) -> Option<Lifetime> {
-        support::token(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
+    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct WhereClause {
@@ -3736,17 +3028,11 @@ impl AstNode for WhereClause {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl WhereClause {
-    pub fn where_kw(&self) -> Option<WhereKw> {
-        support::token(&self.syntax)
-    }
-    pub fn predicates(&self) -> AstChildren<WherePred> {
-        support::children(&self.syntax)
-    }
+    pub fn where_kw(&self) -> Option<WhereKw> { support::token(&self.syntax) }
+    pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Abi {
@@ -3771,14 +3057,10 @@ impl AstNode for Abi {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Abi {
-    pub fn string(&self) -> Option<String> {
-        support::token(&self.syntax)
-    }
+    pub fn string(&self) -> Option<String> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExprStmt {
@@ -3803,18 +3085,12 @@ impl AstNode for ExprStmt {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for ExprStmt {}
 impl ExprStmt {
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn semi(&self) -> Option<Semi> {
-        support::token(&self.syntax)
-    }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn semi(&self) -> Option<Semi> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LetStmt {
@@ -3839,25 +3115,15 @@ impl AstNode for LetStmt {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for LetStmt {}
 impl ast::TypeAscriptionOwner for LetStmt {}
 impl LetStmt {
-    pub fn let_kw(&self) -> Option<LetKw> {
-        support::token(&self.syntax)
-    }
-    pub fn pat(&self) -> Option<Pat> {
-        support::child(&self.syntax)
-    }
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn initializer(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn let_kw(&self) -> Option<LetKw> { support::token(&self.syntax) }
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Condition {
@@ -3882,23 +3148,13 @@ impl AstNode for Condition {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Condition {
-    pub fn let_kw(&self) -> Option<LetKw> {
-        support::token(&self.syntax)
-    }
-    pub fn pat(&self) -> Option<Pat> {
-        support::child(&self.syntax)
-    }
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn let_kw(&self) -> Option<LetKw> { support::token(&self.syntax) }
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Block {
@@ -3923,25 +3179,15 @@ impl AstNode for Block {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for Block {}
 impl ast::ModuleItemOwner for Block {}
 impl Block {
-    pub fn l_curly(&self) -> Option<LCurly> {
-        support::token(&self.syntax)
-    }
-    pub fn statements(&self) -> AstChildren<Stmt> {
-        support::children(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
-    pub fn r_curly(&self) -> Option<RCurly> {
-        support::token(&self.syntax)
-    }
+    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ParamList {
@@ -3966,23 +3212,13 @@ impl AstNode for ParamList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ParamList {
-    pub fn l_paren(&self) -> Option<LParen> {
-        support::token(&self.syntax)
-    }
-    pub fn self_param(&self) -> Option<SelfParam> {
-        support::child(&self.syntax)
-    }
-    pub fn params(&self) -> AstChildren<Param> {
-        support::children(&self.syntax)
-    }
-    pub fn r_paren(&self) -> Option<RParen> {
-        support::token(&self.syntax)
-    }
+    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) }
+    pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
+    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SelfParam {
@@ -4007,22 +3243,14 @@ impl AstNode for SelfParam {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::TypeAscriptionOwner for SelfParam {}
 impl ast::AttrsOwner for SelfParam {}
 impl SelfParam {
-    pub fn amp(&self) -> Option<Amp> {
-        support::token(&self.syntax)
-    }
-    pub fn lifetime(&self) -> Option<Lifetime> {
-        support::token(&self.syntax)
-    }
-    pub fn self_kw(&self) -> Option<SelfKw> {
-        support::token(&self.syntax)
-    }
+    pub fn amp(&self) -> Option<Amp> { support::token(&self.syntax) }
+    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
+    pub fn self_kw(&self) -> Option<SelfKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Param {
@@ -4047,19 +3275,13 @@ impl AstNode for Param {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::TypeAscriptionOwner for Param {}
 impl ast::AttrsOwner for Param {}
 impl Param {
-    pub fn pat(&self) -> Option<Pat> {
-        support::child(&self.syntax)
-    }
-    pub fn dotdotdot(&self) -> Option<Dotdotdot> {
-        support::token(&self.syntax)
-    }
+    pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
+    pub fn dotdotdot(&self) -> Option<Dotdotdot> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UseItem {
@@ -4084,19 +3306,13 @@ impl AstNode for UseItem {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for UseItem {}
 impl ast::VisibilityOwner for UseItem {}
 impl UseItem {
-    pub fn use_kw(&self) -> Option<UseKw> {
-        support::token(&self.syntax)
-    }
-    pub fn use_tree(&self) -> Option<UseTree> {
-        support::child(&self.syntax)
-    }
+    pub fn use_kw(&self) -> Option<UseKw> { support::token(&self.syntax) }
+    pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UseTree {
@@ -4121,23 +3337,13 @@ impl AstNode for UseTree {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl UseTree {
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
-    }
-    pub fn star(&self) -> Option<Star> {
-        support::token(&self.syntax)
-    }
-    pub fn use_tree_list(&self) -> Option<UseTreeList> {
-        support::child(&self.syntax)
-    }
-    pub fn alias(&self) -> Option<Alias> {
-        support::child(&self.syntax)
-    }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
+    pub fn star(&self) -> Option<Star> { support::token(&self.syntax) }
+    pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
+    pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Alias {
@@ -4162,15 +3368,11 @@ impl AstNode for Alias {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::NameOwner for Alias {}
 impl Alias {
-    pub fn as_kw(&self) -> Option<AsKw> {
-        support::token(&self.syntax)
-    }
+    pub fn as_kw(&self) -> Option<AsKw> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UseTreeList {
@@ -4195,20 +3397,12 @@ impl AstNode for UseTreeList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl UseTreeList {
-    pub fn l_curly(&self) -> Option<LCurly> {
-        support::token(&self.syntax)
-    }
-    pub fn use_trees(&self) -> AstChildren<UseTree> {
-        support::children(&self.syntax)
-    }
-    pub fn r_curly(&self) -> Option<RCurly> {
-        support::token(&self.syntax)
-    }
+    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) }
+    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExternCrateItem {
@@ -4233,25 +3427,15 @@ impl AstNode for ExternCrateItem {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::AttrsOwner for ExternCrateItem {}
 impl ast::VisibilityOwner for ExternCrateItem {}
 impl ExternCrateItem {
-    pub fn extern_kw(&self) -> Option<ExternKw> {
-        support::token(&self.syntax)
-    }
-    pub fn crate_kw(&self) -> Option<CrateKw> {
-        support::token(&self.syntax)
-    }
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
-    }
-    pub fn alias(&self) -> Option<Alias> {
-        support::child(&self.syntax)
-    }
+    pub fn extern_kw(&self) -> Option<ExternKw> { support::token(&self.syntax) }
+    pub fn crate_kw(&self) -> Option<CrateKw> { support::token(&self.syntax) }
+    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
+    pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ArgList {
@@ -4276,20 +3460,12 @@ impl AstNode for ArgList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ArgList {
-    pub fn l_paren(&self) -> Option<LParen> {
-        support::token(&self.syntax)
-    }
-    pub fn args(&self) -> AstChildren<Expr> {
-        support::children(&self.syntax)
-    }
-    pub fn r_paren(&self) -> Option<RParen> {
-        support::token(&self.syntax)
-    }
+    pub fn l_paren(&self) -> Option<LParen> { support::token(&self.syntax) }
+    pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
+    pub fn r_paren(&self) -> Option<RParen> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Path {
@@ -4314,17 +3490,11 @@ impl AstNode for Path {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl Path {
-    pub fn segment(&self) -> Option<PathSegment> {
-        support::child(&self.syntax)
-    }
-    pub fn qualifier(&self) -> Option<Path> {
-        support::child(&self.syntax)
-    }
+    pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) }
+    pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PathSegment {
@@ -4349,35 +3519,17 @@ impl AstNode for PathSegment {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl PathSegment {
-    pub fn coloncolon(&self) -> Option<Coloncolon> {
-        support::token(&self.syntax)
-    }
-    pub fn l_angle(&self) -> Option<LAngle> {
-        support::token(&self.syntax)
-    }
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
-    }
-    pub fn type_arg_list(&self) -> Option<TypeArgList> {
-        support::child(&self.syntax)
-    }
-    pub fn param_list(&self) -> Option<ParamList> {
-        support::child(&self.syntax)
-    }
-    pub fn ret_type(&self) -> Option<RetType> {
-        support::child(&self.syntax)
-    }
-    pub fn path_type(&self) -> Option<PathType> {
-        support::child(&self.syntax)
-    }
-    pub fn r_angle(&self) -> Option<RAngle> {
-        support::token(&self.syntax)
-    }
+    pub fn coloncolon(&self) -> Option<Coloncolon> { support::token(&self.syntax) }
+    pub fn l_angle(&self) -> Option<LAngle> { support::token(&self.syntax) }
+    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
+    pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) }
+    pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
+    pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
+    pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }
+    pub fn r_angle(&self) -> Option<RAngle> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeArgList {
@@ -4402,35 +3554,17 @@ impl AstNode for TypeArgList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TypeArgList {
-    pub fn coloncolon(&self) -> Option<Coloncolon> {
-        support::token(&self.syntax)
-    }
-    pub fn l_angle(&self) -> Option<LAngle> {
-        support::token(&self.syntax)
-    }
-    pub fn generic_args(&self) -> AstChildren<GenericArg> {
-        support::children(&self.syntax)
-    }
-    pub fn type_args(&self) -> AstChildren<TypeArg> {
-        support::children(&self.syntax)
-    }
-    pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> {
-        support::children(&self.syntax)
-    }
-    pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> {
-        support::children(&self.syntax)
-    }
-    pub fn const_args(&self) -> AstChildren<ConstArg> {
-        support::children(&self.syntax)
-    }
-    pub fn r_angle(&self) -> Option<RAngle> {
-        support::token(&self.syntax)
-    }
+    pub fn coloncolon(&self) -> Option<Coloncolon> { support::token(&self.syntax) }
+    pub fn l_angle(&self) -> Option<LAngle> { support::token(&self.syntax) }
+    pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) }
+    pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) }
+    pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> { support::children(&self.syntax) }
+    pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> { support::children(&self.syntax) }
+    pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) }
+    pub fn r_angle(&self) -> Option<RAngle> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeArg {
@@ -4455,14 +3589,10 @@ impl AstNode for TypeArg {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl TypeArg {
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AssocTypeArg {
@@ -4487,21 +3617,13 @@ impl AstNode for AssocTypeArg {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::TypeBoundsOwner for AssocTypeArg {}
 impl AssocTypeArg {
-    pub fn name_ref(&self) -> Option<NameRef> {
-        support::child(&self.syntax)
-    }
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn type_ref(&self) -> Option<TypeRef> {
-        support::child(&self.syntax)
-    }
+    pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LifetimeArg {
@@ -4526,14 +3648,10 @@ impl AstNode for LifetimeArg {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl LifetimeArg {
-    pub fn lifetime(&self) -> Option<Lifetime> {
-        support::token(&self.syntax)
-    }
+    pub fn lifetime(&self) -> Option<Lifetime> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ConstArg {
@@ -4558,20 +3676,12 @@ impl AstNode for ConstArg {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ConstArg {
-    pub fn literal(&self) -> Option<Literal> {
-        support::child(&self.syntax)
-    }
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn block_expr(&self) -> Option<BlockExpr> {
-        support::child(&self.syntax)
-    }
+    pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MacroItems {
@@ -4596,9 +3706,7 @@ impl AstNode for MacroItems {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::ModuleItemOwner for MacroItems {}
 impl ast::FnDefOwner for MacroItems {}
@@ -4626,17 +3734,11 @@ impl AstNode for MacroStmts {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl MacroStmts {
-    pub fn statements(&self) -> AstChildren<Stmt> {
-        support::children(&self.syntax)
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        support::child(&self.syntax)
-    }
+    pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExternItemList {
@@ -4661,22 +3763,14 @@ impl AstNode for ExternItemList {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ast::FnDefOwner for ExternItemList {}
 impl ast::ModuleItemOwner for ExternItemList {}
 impl ExternItemList {
-    pub fn l_curly(&self) -> Option<LCurly> {
-        support::token(&self.syntax)
-    }
-    pub fn extern_items(&self) -> AstChildren<ExternItem> {
-        support::children(&self.syntax)
-    }
-    pub fn r_curly(&self) -> Option<RCurly> {
-        support::token(&self.syntax)
-    }
+    pub fn l_curly(&self) -> Option<LCurly> { support::token(&self.syntax) }
+    pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }
+    pub fn r_curly(&self) -> Option<RCurly> { support::token(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExternBlock {
@@ -4701,17 +3795,11 @@ impl AstNode for ExternBlock {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl ExternBlock {
-    pub fn abi(&self) -> Option<Abi> {
-        support::child(&self.syntax)
-    }
-    pub fn extern_item_list(&self) -> Option<ExternItemList> {
-        support::child(&self.syntax)
-    }
+    pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
+    pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MetaItem {
@@ -4736,23 +3824,13 @@ impl AstNode for MetaItem {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl MetaItem {
-    pub fn path(&self) -> Option<Path> {
-        support::child(&self.syntax)
-    }
-    pub fn eq(&self) -> Option<Eq> {
-        support::token(&self.syntax)
-    }
-    pub fn attr_input(&self) -> Option<AttrInput> {
-        support::child(&self.syntax)
-    }
-    pub fn nested_meta_items(&self) -> AstChildren<MetaItem> {
-        support::children(&self.syntax)
-    }
+    pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
+    pub fn eq(&self) -> Option<Eq> { support::token(&self.syntax) }
+    pub fn attr_input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
+    pub fn nested_meta_items(&self) -> AstChildren<MetaItem> { support::children(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MacroDef {
@@ -4777,17 +3855,11 @@ impl AstNode for MacroDef {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
 impl MacroDef {
-    pub fn name(&self) -> Option<Name> {
-        support::child(&self.syntax)
-    }
-    pub fn token_tree(&self) -> Option<TokenTree> {
-        support::child(&self.syntax)
-    }
+    pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }
+    pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum NominalDef {
@@ -4796,19 +3868,13 @@ pub enum NominalDef {
     UnionDef(UnionDef),
 }
 impl From<StructDef> for NominalDef {
-    fn from(node: StructDef) -> NominalDef {
-        NominalDef::StructDef(node)
-    }
+    fn from(node: StructDef) -> NominalDef { NominalDef::StructDef(node) }
 }
 impl From<EnumDef> for NominalDef {
-    fn from(node: EnumDef) -> NominalDef {
-        NominalDef::EnumDef(node)
-    }
+    fn from(node: EnumDef) -> NominalDef { NominalDef::EnumDef(node) }
 }
 impl From<UnionDef> for NominalDef {
-    fn from(node: UnionDef) -> NominalDef {
-        NominalDef::UnionDef(node)
-    }
+    fn from(node: UnionDef) -> NominalDef { NominalDef::UnionDef(node) }
 }
 impl std::fmt::Display for NominalDef {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -4849,19 +3915,13 @@ pub enum GenericParam {
     ConstParam(ConstParam),
 }
 impl From<LifetimeParam> for GenericParam {
-    fn from(node: LifetimeParam) -> GenericParam {
-        GenericParam::LifetimeParam(node)
-    }
+    fn from(node: LifetimeParam) -> GenericParam { GenericParam::LifetimeParam(node) }
 }
 impl From<TypeParam> for GenericParam {
-    fn from(node: TypeParam) -> GenericParam {
-        GenericParam::TypeParam(node)
-    }
+    fn from(node: TypeParam) -> GenericParam { GenericParam::TypeParam(node) }
 }
 impl From<ConstParam> for GenericParam {
-    fn from(node: ConstParam) -> GenericParam {
-        GenericParam::ConstParam(node)
-    }
+    fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) }
 }
 impl std::fmt::Display for GenericParam {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -4900,24 +3960,16 @@ pub enum GenericArg {
     AssocTypeArg(AssocTypeArg),
 }
 impl From<LifetimeArg> for GenericArg {
-    fn from(node: LifetimeArg) -> GenericArg {
-        GenericArg::LifetimeArg(node)
-    }
+    fn from(node: LifetimeArg) -> GenericArg { GenericArg::LifetimeArg(node) }
 }
 impl From<TypeArg> for GenericArg {
-    fn from(node: TypeArg) -> GenericArg {
-        GenericArg::TypeArg(node)
-    }
+    fn from(node: TypeArg) -> GenericArg { GenericArg::TypeArg(node) }
 }
 impl From<ConstArg> for GenericArg {
-    fn from(node: ConstArg) -> GenericArg {
-        GenericArg::ConstArg(node)
-    }
+    fn from(node: ConstArg) -> GenericArg { GenericArg::ConstArg(node) }
 }
 impl From<AssocTypeArg> for GenericArg {
-    fn from(node: AssocTypeArg) -> GenericArg {
-        GenericArg::AssocTypeArg(node)
-    }
+    fn from(node: AssocTypeArg) -> GenericArg { GenericArg::AssocTypeArg(node) }
 }
 impl std::fmt::Display for GenericArg {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -4967,69 +4019,43 @@ pub enum TypeRef {
     DynTraitType(DynTraitType),
 }
 impl From<ParenType> for TypeRef {
-    fn from(node: ParenType) -> TypeRef {
-        TypeRef::ParenType(node)
-    }
+    fn from(node: ParenType) -> TypeRef { TypeRef::ParenType(node) }
 }
 impl From<TupleType> for TypeRef {
-    fn from(node: TupleType) -> TypeRef {
-        TypeRef::TupleType(node)
-    }
+    fn from(node: TupleType) -> TypeRef { TypeRef::TupleType(node) }
 }
 impl From<NeverType> for TypeRef {
-    fn from(node: NeverType) -> TypeRef {
-        TypeRef::NeverType(node)
-    }
+    fn from(node: NeverType) -> TypeRef { TypeRef::NeverType(node) }
 }
 impl From<PathType> for TypeRef {
-    fn from(node: PathType) -> TypeRef {
-        TypeRef::PathType(node)
-    }
+    fn from(node: PathType) -> TypeRef { TypeRef::PathType(node) }
 }
 impl From<PointerType> for TypeRef {
-    fn from(node: PointerType) -> TypeRef {
-        TypeRef::PointerType(node)
-    }
+    fn from(node: PointerType) -> TypeRef { TypeRef::PointerType(node) }
 }
 impl From<ArrayType> for TypeRef {
-    fn from(node: ArrayType) -> TypeRef {
-        TypeRef::ArrayType(node)
-    }
+    fn from(node: ArrayType) -> TypeRef { TypeRef::ArrayType(node) }
 }
 impl From<SliceType> for TypeRef {
-    fn from(node: SliceType) -> TypeRef {
-        TypeRef::SliceType(node)
-    }
+    fn from(node: SliceType) -> TypeRef { TypeRef::SliceType(node) }
 }
 impl From<ReferenceType> for TypeRef {
-    fn from(node: ReferenceType) -> TypeRef {
-        TypeRef::ReferenceType(node)
-    }
+    fn from(node: ReferenceType) -> TypeRef { TypeRef::ReferenceType(node) }
 }
 impl From<PlaceholderType> for TypeRef {
-    fn from(node: PlaceholderType) -> TypeRef {
-        TypeRef::PlaceholderType(node)
-    }
+    fn from(node: PlaceholderType) -> TypeRef { TypeRef::PlaceholderType(node) }
 }
 impl From<FnPointerType> for TypeRef {
-    fn from(node: FnPointerType) -> TypeRef {
-        TypeRef::FnPointerType(node)
-    }
+    fn from(node: FnPointerType) -> TypeRef { TypeRef::FnPointerType(node) }
 }
 impl From<ForType> for TypeRef {
-    fn from(node: ForType) -> TypeRef {
-        TypeRef::ForType(node)
-    }
+    fn from(node: ForType) -> TypeRef { TypeRef::ForType(node) }
 }
 impl From<ImplTraitType> for TypeRef {
-    fn from(node: ImplTraitType) -> TypeRef {
-        TypeRef::ImplTraitType(node)
-    }
+    fn from(node: ImplTraitType) -> TypeRef { TypeRef::ImplTraitType(node) }
 }
 impl From<DynTraitType> for TypeRef {
-    fn from(node: DynTraitType) -> TypeRef {
-        TypeRef::DynTraitType(node)
-    }
+    fn from(node: DynTraitType) -> TypeRef { TypeRef::DynTraitType(node) }
 }
 impl std::fmt::Display for TypeRef {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -5100,74 +4126,46 @@ pub enum ModuleItem {
     ExternBlock(ExternBlock),
 }
 impl From<StructDef> for ModuleItem {
-    fn from(node: StructDef) -> ModuleItem {
-        ModuleItem::StructDef(node)
-    }
+    fn from(node: StructDef) -> ModuleItem { ModuleItem::StructDef(node) }
 }
 impl From<UnionDef> for ModuleItem {
-    fn from(node: UnionDef) -> ModuleItem {
-        ModuleItem::UnionDef(node)
-    }
+    fn from(node: UnionDef) -> ModuleItem { ModuleItem::UnionDef(node) }
 }
 impl From<EnumDef> for ModuleItem {
-    fn from(node: EnumDef) -> ModuleItem {
-        ModuleItem::EnumDef(node)
-    }
+    fn from(node: EnumDef) -> ModuleItem { ModuleItem::EnumDef(node) }
 }
 impl From<FnDef> for ModuleItem {
-    fn from(node: FnDef) -> ModuleItem {
-        ModuleItem::FnDef(node)
-    }
+    fn from(node: FnDef) -> ModuleItem { ModuleItem::FnDef(node) }
 }
 impl From<TraitDef> for ModuleItem {
-    fn from(node: TraitDef) -> ModuleItem {
-        ModuleItem::TraitDef(node)
-    }
+    fn from(node: TraitDef) -> ModuleItem { ModuleItem::TraitDef(node) }
 }
 impl From<TypeAliasDef> for ModuleItem {
-    fn from(node: TypeAliasDef) -> ModuleItem {
-        ModuleItem::TypeAliasDef(node)
-    }
+    fn from(node: TypeAliasDef) -> ModuleItem { ModuleItem::TypeAliasDef(node) }
 }
 impl From<ImplDef> for ModuleItem {
-    fn from(node: ImplDef) -> ModuleItem {
-        ModuleItem::ImplDef(node)
-    }
+    fn from(node: ImplDef) -> ModuleItem { ModuleItem::ImplDef(node) }
 }
 impl From<UseItem> for ModuleItem {
-    fn from(node: UseItem) -> ModuleItem {
-        ModuleItem::UseItem(node)
-    }
+    fn from(node: UseItem) -> ModuleItem { ModuleItem::UseItem(node) }
 }
 impl From<ExternCrateItem> for ModuleItem {
-    fn from(node: ExternCrateItem) -> ModuleItem {
-        ModuleItem::ExternCrateItem(node)
-    }
+    fn from(node: ExternCrateItem) -> ModuleItem { ModuleItem::ExternCrateItem(node) }
 }
 impl From<ConstDef> for ModuleItem {
-    fn from(node: ConstDef) -> ModuleItem {
-        ModuleItem::ConstDef(node)
-    }
+    fn from(node: ConstDef) -> ModuleItem { ModuleItem::ConstDef(node) }
 }
 impl From<StaticDef> for ModuleItem {
-    fn from(node: StaticDef) -> ModuleItem {
-        ModuleItem::StaticDef(node)
-    }
+    fn from(node: StaticDef) -> ModuleItem { ModuleItem::StaticDef(node) }
 }
 impl From<Module> for ModuleItem {
-    fn from(node: Module) -> ModuleItem {
-        ModuleItem::Module(node)
-    }
+    fn from(node: Module) -> ModuleItem { ModuleItem::Module(node) }
 }
 impl From<MacroCall> for ModuleItem {
-    fn from(node: MacroCall) -> ModuleItem {
-        ModuleItem::MacroCall(node)
-    }
+    fn from(node: MacroCall) -> ModuleItem { ModuleItem::MacroCall(node) }
 }
 impl From<ExternBlock> for ModuleItem {
-    fn from(node: ExternBlock) -> ModuleItem {
-        ModuleItem::ExternBlock(node)
-    }
+    fn from(node: ExternBlock) -> ModuleItem { ModuleItem::ExternBlock(node) }
 }
 impl std::fmt::Display for ModuleItem {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -5232,19 +4230,13 @@ pub enum ImplItem {
     ConstDef(ConstDef),
 }
 impl From<FnDef> for ImplItem {
-    fn from(node: FnDef) -> ImplItem {
-        ImplItem::FnDef(node)
-    }
+    fn from(node: FnDef) -> ImplItem { ImplItem::FnDef(node) }
 }
 impl From<TypeAliasDef> for ImplItem {
-    fn from(node: TypeAliasDef) -> ImplItem {
-        ImplItem::TypeAliasDef(node)
-    }
+    fn from(node: TypeAliasDef) -> ImplItem { ImplItem::TypeAliasDef(node) }
 }
 impl From<ConstDef> for ImplItem {
-    fn from(node: ConstDef) -> ImplItem {
-        ImplItem::ConstDef(node)
-    }
+    fn from(node: ConstDef) -> ImplItem { ImplItem::ConstDef(node) }
 }
 impl std::fmt::Display for ImplItem {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -5283,14 +4275,10 @@ pub enum ExternItem {
     StaticDef(StaticDef),
 }
 impl From<FnDef> for ExternItem {
-    fn from(node: FnDef) -> ExternItem {
-        ExternItem::FnDef(node)
-    }
+    fn from(node: FnDef) -> ExternItem { ExternItem::FnDef(node) }
 }
 impl From<StaticDef> for ExternItem {
-    fn from(node: StaticDef) -> ExternItem {
-        ExternItem::StaticDef(node)
-    }
+    fn from(node: StaticDef) -> ExternItem { ExternItem::StaticDef(node) }
 }
 impl std::fmt::Display for ExternItem {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -5357,159 +4345,97 @@ pub enum Expr {
     BoxExpr(BoxExpr),
 }
 impl From<TupleExpr> for Expr {
-    fn from(node: TupleExpr) -> Expr {
-        Expr::TupleExpr(node)
-    }
+    fn from(node: TupleExpr) -> Expr { Expr::TupleExpr(node) }
 }
 impl From<ArrayExpr> for Expr {
-    fn from(node: ArrayExpr) -> Expr {
-        Expr::ArrayExpr(node)
-    }
+    fn from(node: ArrayExpr) -> Expr { Expr::ArrayExpr(node) }
 }
 impl From<ParenExpr> for Expr {
-    fn from(node: ParenExpr) -> Expr {
-        Expr::ParenExpr(node)
-    }
+    fn from(node: ParenExpr) -> Expr { Expr::ParenExpr(node) }
 }
 impl From<PathExpr> for Expr {
-    fn from(node: PathExpr) -> Expr {
-        Expr::PathExpr(node)
-    }
+    fn from(node: PathExpr) -> Expr { Expr::PathExpr(node) }
 }
 impl From<LambdaExpr> for Expr {
-    fn from(node: LambdaExpr) -> Expr {
-        Expr::LambdaExpr(node)
-    }
+    fn from(node: LambdaExpr) -> Expr { Expr::LambdaExpr(node) }
 }
 impl From<IfExpr> for Expr {
-    fn from(node: IfExpr) -> Expr {
-        Expr::IfExpr(node)
-    }
+    fn from(node: IfExpr) -> Expr { Expr::IfExpr(node) }
 }
 impl From<LoopExpr> for Expr {
-    fn from(node: LoopExpr) -> Expr {
-        Expr::LoopExpr(node)
-    }
+    fn from(node: LoopExpr) -> Expr { Expr::LoopExpr(node) }
 }
 impl From<ForExpr> for Expr {
-    fn from(node: ForExpr) -> Expr {
-        Expr::ForExpr(node)
-    }
+    fn from(node: ForExpr) -> Expr { Expr::ForExpr(node) }
 }
 impl From<WhileExpr> for Expr {
-    fn from(node: WhileExpr) -> Expr {
-        Expr::WhileExpr(node)
-    }
+    fn from(node: WhileExpr) -> Expr { Expr::WhileExpr(node) }
 }
 impl From<ContinueExpr> for Expr {
-    fn from(node: ContinueExpr) -> Expr {
-        Expr::ContinueExpr(node)
-    }
+    fn from(node: ContinueExpr) -> Expr { Expr::ContinueExpr(node) }
 }
 impl From<BreakExpr> for Expr {
-    fn from(node: BreakExpr) -> Expr {
-        Expr::BreakExpr(node)
-    }
+    fn from(node: BreakExpr) -> Expr { Expr::BreakExpr(node) }
 }
 impl From<Label> for Expr {
-    fn from(node: Label) -> Expr {
-        Expr::Label(node)
-    }
+    fn from(node: Label) -> Expr { Expr::Label(node) }
 }
 impl From<BlockExpr> for Expr {
-    fn from(node: BlockExpr) -> Expr {
-        Expr::BlockExpr(node)
-    }
+    fn from(node: BlockExpr) -> Expr { Expr::BlockExpr(node) }
 }
 impl From<ReturnExpr> for Expr {
-    fn from(node: ReturnExpr) -> Expr {
-        Expr::ReturnExpr(node)
-    }
+    fn from(node: ReturnExpr) -> Expr { Expr::ReturnExpr(node) }
 }
 impl From<MatchExpr> for Expr {
-    fn from(node: MatchExpr) -> Expr {
-        Expr::MatchExpr(node)
-    }
+    fn from(node: MatchExpr) -> Expr { Expr::MatchExpr(node) }
 }
 impl From<RecordLit> for Expr {
-    fn from(node: RecordLit) -> Expr {
-        Expr::RecordLit(node)
-    }
+    fn from(node: RecordLit) -> Expr { Expr::RecordLit(node) }
 }
 impl From<CallExpr> for Expr {
-    fn from(node: CallExpr) -> Expr {
-        Expr::CallExpr(node)
-    }
+    fn from(node: CallExpr) -> Expr { Expr::CallExpr(node) }
 }
 impl From<IndexExpr> for Expr {
-    fn from(node: IndexExpr) -> Expr {
-        Expr::IndexExpr(node)
-    }
+    fn from(node: IndexExpr) -> Expr { Expr::IndexExpr(node) }
 }
 impl From<MethodCallExpr> for Expr {
-    fn from(node: MethodCallExpr) -> Expr {
-        Expr::MethodCallExpr(node)
-    }
+    fn from(node: MethodCallExpr) -> Expr { Expr::MethodCallExpr(node) }
 }
 impl From<FieldExpr> for Expr {
-    fn from(node: FieldExpr) -> Expr {
-        Expr::FieldExpr(node)
-    }
+    fn from(node: FieldExpr) -> Expr { Expr::FieldExpr(node) }
 }
 impl From<AwaitExpr> for Expr {
-    fn from(node: AwaitExpr) -> Expr {
-        Expr::AwaitExpr(node)
-    }
+    fn from(node: AwaitExpr) -> Expr { Expr::AwaitExpr(node) }
 }
 impl From<TryExpr> for Expr {
-    fn from(node: TryExpr) -> Expr {
-        Expr::TryExpr(node)
-    }
+    fn from(node: TryExpr) -> Expr { Expr::TryExpr(node) }
 }
 impl From<TryBlockExpr> for Expr {
-    fn from(node: TryBlockExpr) -> Expr {
-        Expr::TryBlockExpr(node)
-    }
+    fn from(node: TryBlockExpr) -> Expr { Expr::TryBlockExpr(node) }
 }
 impl From<CastExpr> for Expr {
-    fn from(node: CastExpr) -> Expr {
-        Expr::CastExpr(node)
-    }
+    fn from(node: CastExpr) -> Expr { Expr::CastExpr(node) }
 }
 impl From<RefExpr> for Expr {
-    fn from(node: RefExpr) -> Expr {
-        Expr::RefExpr(node)
-    }
+    fn from(node: RefExpr) -> Expr { Expr::RefExpr(node) }
 }
 impl From<PrefixExpr> for Expr {
-    fn from(node: PrefixExpr) -> Expr {
-        Expr::PrefixExpr(node)
-    }
+    fn from(node: PrefixExpr) -> Expr { Expr::PrefixExpr(node) }
 }
 impl From<RangeExpr> for Expr {
-    fn from(node: RangeExpr) -> Expr {
-        Expr::RangeExpr(node)
-    }
+    fn from(node: RangeExpr) -> Expr { Expr::RangeExpr(node) }
 }
 impl From<BinExpr> for Expr {
-    fn from(node: BinExpr) -> Expr {
-        Expr::BinExpr(node)
-    }
+    fn from(node: BinExpr) -> Expr { Expr::BinExpr(node) }
 }
 impl From<Literal> for Expr {
-    fn from(node: Literal) -> Expr {
-        Expr::Literal(node)
-    }
+    fn from(node: Literal) -> Expr { Expr::Literal(node) }
 }
 impl From<MacroCall> for Expr {
-    fn from(node: MacroCall) -> Expr {
-        Expr::MacroCall(node)
-    }
+    fn from(node: MacroCall) -> Expr { Expr::MacroCall(node) }
 }
 impl From<BoxExpr> for Expr {
-    fn from(node: BoxExpr) -> Expr {
-        Expr::BoxExpr(node)
-    }
+    fn from(node: BoxExpr) -> Expr { Expr::BoxExpr(node) }
 }
 impl std::fmt::Display for Expr {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -5621,79 +4547,49 @@ pub enum Pat {
     MacroPat(MacroPat),
 }
 impl From<OrPat> for Pat {
-    fn from(node: OrPat) -> Pat {
-        Pat::OrPat(node)
-    }
+    fn from(node: OrPat) -> Pat { Pat::OrPat(node) }
 }
 impl From<ParenPat> for Pat {
-    fn from(node: ParenPat) -> Pat {
-        Pat::ParenPat(node)
-    }
+    fn from(node: ParenPat) -> Pat { Pat::ParenPat(node) }
 }
 impl From<RefPat> for Pat {
-    fn from(node: RefPat) -> Pat {
-        Pat::RefPat(node)
-    }
+    fn from(node: RefPat) -> Pat { Pat::RefPat(node) }
 }
 impl From<BoxPat> for Pat {
-    fn from(node: BoxPat) -> Pat {
-        Pat::BoxPat(node)
-    }
+    fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) }
 }
 impl From<BindPat> for Pat {
-    fn from(node: BindPat) -> Pat {
-        Pat::BindPat(node)
-    }
+    fn from(node: BindPat) -> Pat { Pat::BindPat(node) }
 }
 impl From<PlaceholderPat> for Pat {
-    fn from(node: PlaceholderPat) -> Pat {
-        Pat::PlaceholderPat(node)
-    }
+    fn from(node: PlaceholderPat) -> Pat { Pat::PlaceholderPat(node) }
 }
 impl From<DotDotPat> for Pat {
-    fn from(node: DotDotPat) -> Pat {
-        Pat::DotDotPat(node)
-    }
+    fn from(node: DotDotPat) -> Pat { Pat::DotDotPat(node) }
 }
 impl From<PathPat> for Pat {
-    fn from(node: PathPat) -> Pat {
-        Pat::PathPat(node)
-    }
+    fn from(node: PathPat) -> Pat { Pat::PathPat(node) }
 }
 impl From<RecordPat> for Pat {
-    fn from(node: RecordPat) -> Pat {
-        Pat::RecordPat(node)
-    }
+    fn from(node: RecordPat) -> Pat { Pat::RecordPat(node) }
 }
 impl From<TupleStructPat> for Pat {
-    fn from(node: TupleStructPat) -> Pat {
-        Pat::TupleStructPat(node)
-    }
+    fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) }
 }
 impl From<TuplePat> for Pat {
-    fn from(node: TuplePat) -> Pat {
-        Pat::TuplePat(node)
-    }
+    fn from(node: TuplePat) -> Pat { Pat::TuplePat(node) }
 }
 impl From<SlicePat> for Pat {
-    fn from(node: SlicePat) -> Pat {
-        Pat::SlicePat(node)
-    }
+    fn from(node: SlicePat) -> Pat { Pat::SlicePat(node) }
 }
 impl From<RangePat> for Pat {
-    fn from(node: RangePat) -> Pat {
-        Pat::RangePat(node)
-    }
+    fn from(node: RangePat) -> Pat { Pat::RangePat(node) }
 }
 impl From<LiteralPat> for Pat {
-    fn from(node: LiteralPat) -> Pat {
-        Pat::LiteralPat(node)
-    }
+    fn from(node: LiteralPat) -> Pat { Pat::LiteralPat(node) }
 }
 impl From<MacroPat> for Pat {
-    fn from(node: MacroPat) -> Pat {
-        Pat::MacroPat(node)
-    }
+    fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) }
 }
 impl std::fmt::Display for Pat {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -5756,14 +4652,10 @@ pub enum RecordInnerPat {
     BindPat(BindPat),
 }
 impl From<RecordFieldPat> for RecordInnerPat {
-    fn from(node: RecordFieldPat) -> RecordInnerPat {
-        RecordInnerPat::RecordFieldPat(node)
-    }
+    fn from(node: RecordFieldPat) -> RecordInnerPat { RecordInnerPat::RecordFieldPat(node) }
 }
 impl From<BindPat> for RecordInnerPat {
-    fn from(node: BindPat) -> RecordInnerPat {
-        RecordInnerPat::BindPat(node)
-    }
+    fn from(node: BindPat) -> RecordInnerPat { RecordInnerPat::BindPat(node) }
 }
 impl std::fmt::Display for RecordInnerPat {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -5798,14 +4690,10 @@ pub enum AttrInput {
     TokenTree(TokenTree),
 }
 impl From<Literal> for AttrInput {
-    fn from(node: Literal) -> AttrInput {
-        AttrInput::Literal(node)
-    }
+    fn from(node: Literal) -> AttrInput { AttrInput::Literal(node) }
 }
 impl From<TokenTree> for AttrInput {
-    fn from(node: TokenTree) -> AttrInput {
-        AttrInput::TokenTree(node)
-    }
+    fn from(node: TokenTree) -> AttrInput { AttrInput::TokenTree(node) }
 }
 impl std::fmt::Display for AttrInput {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -5840,14 +4728,10 @@ pub enum Stmt {
     ExprStmt(ExprStmt),
 }
 impl From<LetStmt> for Stmt {
-    fn from(node: LetStmt) -> Stmt {
-        Stmt::LetStmt(node)
-    }
+    fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) }
 }
 impl From<ExprStmt> for Stmt {
-    fn from(node: ExprStmt) -> Stmt {
-        Stmt::ExprStmt(node)
-    }
+    fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) }
 }
 impl std::fmt::Display for Stmt {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -5882,14 +4766,10 @@ pub enum FieldDefList {
     TupleFieldDefList(TupleFieldDefList),
 }
 impl From<RecordFieldDefList> for FieldDefList {
-    fn from(node: RecordFieldDefList) -> FieldDefList {
-        FieldDefList::RecordFieldDefList(node)
-    }
+    fn from(node: RecordFieldDefList) -> FieldDefList { FieldDefList::RecordFieldDefList(node) }
 }
 impl From<TupleFieldDefList> for FieldDefList {
-    fn from(node: TupleFieldDefList) -> FieldDefList {
-        FieldDefList::TupleFieldDefList(node)
-    }
+    fn from(node: TupleFieldDefList) -> FieldDefList { FieldDefList::TupleFieldDefList(node) }
 }
 impl std::fmt::Display for FieldDefList {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
diff --git a/crates/ra_syntax/src/ast/generated/tokens.rs b/crates/ra_syntax/src/ast/generated/tokens.rs
index 3aea5bef15..ec3ca4a5bb 100644
--- a/crates/ra_syntax/src/ast/generated/tokens.rs
+++ b/crates/ra_syntax/src/ast/generated/tokens.rs
@@ -28,9 +28,7 @@ impl AstToken for Semi {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Comma {
@@ -55,9 +53,7 @@ impl AstToken for Comma {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LParen {
@@ -82,9 +78,7 @@ impl AstToken for LParen {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RParen {
@@ -109,9 +103,7 @@ impl AstToken for RParen {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LCurly {
@@ -136,9 +128,7 @@ impl AstToken for LCurly {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RCurly {
@@ -163,9 +153,7 @@ impl AstToken for RCurly {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LBrack {
@@ -190,9 +178,7 @@ impl AstToken for LBrack {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RBrack {
@@ -217,9 +203,7 @@ impl AstToken for RBrack {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LAngle {
@@ -244,9 +228,7 @@ impl AstToken for LAngle {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RAngle {
@@ -271,9 +253,7 @@ impl AstToken for RAngle {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct At {
@@ -298,9 +278,7 @@ impl AstToken for At {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Pound {
@@ -325,9 +303,7 @@ impl AstToken for Pound {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Tilde {
@@ -352,9 +328,7 @@ impl AstToken for Tilde {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Question {
@@ -379,9 +353,7 @@ impl AstToken for Question {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Dollar {
@@ -406,9 +378,7 @@ impl AstToken for Dollar {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Amp {
@@ -433,9 +403,7 @@ impl AstToken for Amp {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Pipe {
@@ -460,9 +428,7 @@ impl AstToken for Pipe {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Plus {
@@ -487,9 +453,7 @@ impl AstToken for Plus {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Star {
@@ -514,9 +478,7 @@ impl AstToken for Star {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Slash {
@@ -541,9 +503,7 @@ impl AstToken for Slash {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Caret {
@@ -568,9 +528,7 @@ impl AstToken for Caret {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Percent {
@@ -595,9 +553,7 @@ impl AstToken for Percent {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Underscore {
@@ -622,9 +578,7 @@ impl AstToken for Underscore {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Dot {
@@ -649,9 +603,7 @@ impl AstToken for Dot {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Dotdot {
@@ -676,9 +628,7 @@ impl AstToken for Dotdot {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Dotdotdot {
@@ -703,9 +653,7 @@ impl AstToken for Dotdotdot {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Dotdoteq {
@@ -730,9 +678,7 @@ impl AstToken for Dotdoteq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Colon {
@@ -757,9 +703,7 @@ impl AstToken for Colon {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Coloncolon {
@@ -784,9 +728,7 @@ impl AstToken for Coloncolon {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Eq {
@@ -811,9 +753,7 @@ impl AstToken for Eq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Eqeq {
@@ -838,9 +778,7 @@ impl AstToken for Eqeq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FatArrow {
@@ -865,9 +803,7 @@ impl AstToken for FatArrow {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Excl {
@@ -892,9 +828,7 @@ impl AstToken for Excl {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Neq {
@@ -919,9 +853,7 @@ impl AstToken for Neq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Minus {
@@ -946,9 +878,7 @@ impl AstToken for Minus {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ThinArrow {
@@ -973,9 +903,7 @@ impl AstToken for ThinArrow {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Lteq {
@@ -1000,9 +928,7 @@ impl AstToken for Lteq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Gteq {
@@ -1027,9 +953,7 @@ impl AstToken for Gteq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Pluseq {
@@ -1054,9 +978,7 @@ impl AstToken for Pluseq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Minuseq {
@@ -1081,9 +1003,7 @@ impl AstToken for Minuseq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Pipeeq {
@@ -1108,9 +1028,7 @@ impl AstToken for Pipeeq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Ampeq {
@@ -1135,9 +1053,7 @@ impl AstToken for Ampeq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Careteq {
@@ -1162,9 +1078,7 @@ impl AstToken for Careteq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Slasheq {
@@ -1189,9 +1103,7 @@ impl AstToken for Slasheq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Stareq {
@@ -1216,9 +1128,7 @@ impl AstToken for Stareq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Percenteq {
@@ -1243,9 +1153,7 @@ impl AstToken for Percenteq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Ampamp {
@@ -1270,9 +1178,7 @@ impl AstToken for Ampamp {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Pipepipe {
@@ -1297,9 +1203,7 @@ impl AstToken for Pipepipe {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Shl {
@@ -1324,9 +1228,7 @@ impl AstToken for Shl {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Shr {
@@ -1351,9 +1253,7 @@ impl AstToken for Shr {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Shleq {
@@ -1378,9 +1278,7 @@ impl AstToken for Shleq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Shreq {
@@ -1405,9 +1303,7 @@ impl AstToken for Shreq {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AsKw {
@@ -1432,9 +1328,7 @@ impl AstToken for AsKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AsyncKw {
@@ -1459,9 +1353,7 @@ impl AstToken for AsyncKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AwaitKw {
@@ -1486,9 +1378,7 @@ impl AstToken for AwaitKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BoxKw {
@@ -1513,9 +1403,7 @@ impl AstToken for BoxKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct BreakKw {
@@ -1540,9 +1428,7 @@ impl AstToken for BreakKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ConstKw {
@@ -1567,9 +1453,7 @@ impl AstToken for ConstKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ContinueKw {
@@ -1594,9 +1478,7 @@ impl AstToken for ContinueKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct CrateKw {
@@ -1621,9 +1503,7 @@ impl AstToken for CrateKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DynKw {
@@ -1648,9 +1528,7 @@ impl AstToken for DynKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ElseKw {
@@ -1675,9 +1553,7 @@ impl AstToken for ElseKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EnumKw {
@@ -1702,9 +1578,7 @@ impl AstToken for EnumKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExternKw {
@@ -1729,9 +1603,7 @@ impl AstToken for ExternKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FalseKw {
@@ -1756,9 +1628,7 @@ impl AstToken for FalseKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FnKw {
@@ -1783,9 +1653,7 @@ impl AstToken for FnKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ForKw {
@@ -1810,9 +1678,7 @@ impl AstToken for ForKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct IfKw {
@@ -1837,9 +1703,7 @@ impl AstToken for IfKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ImplKw {
@@ -1864,9 +1728,7 @@ impl AstToken for ImplKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct InKw {
@@ -1891,9 +1753,7 @@ impl AstToken for InKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LetKw {
@@ -1918,9 +1778,7 @@ impl AstToken for LetKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LoopKw {
@@ -1945,9 +1803,7 @@ impl AstToken for LoopKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MacroKw {
@@ -1972,9 +1828,7 @@ impl AstToken for MacroKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MatchKw {
@@ -1999,9 +1853,7 @@ impl AstToken for MatchKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ModKw {
@@ -2026,9 +1878,7 @@ impl AstToken for ModKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MoveKw {
@@ -2053,9 +1903,7 @@ impl AstToken for MoveKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct MutKw {
@@ -2080,9 +1928,7 @@ impl AstToken for MutKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PubKw {
@@ -2107,9 +1953,7 @@ impl AstToken for PubKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RefKw {
@@ -2134,9 +1978,7 @@ impl AstToken for RefKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ReturnKw {
@@ -2161,9 +2003,7 @@ impl AstToken for ReturnKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SelfKw {
@@ -2188,9 +2028,7 @@ impl AstToken for SelfKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StaticKw {
@@ -2215,9 +2053,7 @@ impl AstToken for StaticKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct StructKw {
@@ -2242,9 +2078,7 @@ impl AstToken for StructKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct SuperKw {
@@ -2269,9 +2103,7 @@ impl AstToken for SuperKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TraitKw {
@@ -2296,9 +2128,7 @@ impl AstToken for TraitKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TrueKw {
@@ -2323,9 +2153,7 @@ impl AstToken for TrueKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TryKw {
@@ -2350,9 +2178,7 @@ impl AstToken for TryKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TypeKw {
@@ -2377,9 +2203,7 @@ impl AstToken for TypeKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UnsafeKw {
@@ -2404,9 +2228,7 @@ impl AstToken for UnsafeKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UseKw {
@@ -2431,9 +2253,7 @@ impl AstToken for UseKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct WhereKw {
@@ -2458,9 +2278,7 @@ impl AstToken for WhereKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct WhileKw {
@@ -2485,9 +2303,7 @@ impl AstToken for WhileKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AutoKw {
@@ -2512,9 +2328,7 @@ impl AstToken for AutoKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct DefaultKw {
@@ -2539,9 +2353,7 @@ impl AstToken for DefaultKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ExistentialKw {
@@ -2566,9 +2378,7 @@ impl AstToken for ExistentialKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UnionKw {
@@ -2593,9 +2403,7 @@ impl AstToken for UnionKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RawKw {
@@ -2620,9 +2428,7 @@ impl AstToken for RawKw {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct IntNumber {
@@ -2647,9 +2453,7 @@ impl AstToken for IntNumber {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FloatNumber {
@@ -2674,9 +2478,7 @@ impl AstToken for FloatNumber {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Char {
@@ -2701,9 +2503,7 @@ impl AstToken for Char {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Byte {
@@ -2728,9 +2528,7 @@ impl AstToken for Byte {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct String {
@@ -2755,9 +2553,7 @@ impl AstToken for String {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RawString {
@@ -2782,9 +2578,7 @@ impl AstToken for RawString {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ByteString {
@@ -2809,9 +2603,7 @@ impl AstToken for ByteString {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RawByteString {
@@ -2836,9 +2628,7 @@ impl AstToken for RawByteString {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Error {
@@ -2863,9 +2653,7 @@ impl AstToken for Error {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Ident {
@@ -2890,9 +2678,7 @@ impl AstToken for Ident {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Whitespace {
@@ -2917,9 +2703,7 @@ impl AstToken for Whitespace {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Lifetime {
@@ -2944,9 +2728,7 @@ impl AstToken for Lifetime {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Comment {
@@ -2971,9 +2753,7 @@ impl AstToken for Comment {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Shebang {
@@ -2998,9 +2778,7 @@ impl AstToken for Shebang {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct LDollar {
@@ -3025,9 +2803,7 @@ impl AstToken for LDollar {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RDollar {
@@ -3052,9 +2828,7 @@ impl AstToken for RDollar {
             None
         }
     }
-    fn syntax(&self) -> &SyntaxToken {
-        &self.syntax
-    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum LeftDelimiter {
@@ -3063,19 +2837,13 @@ pub enum LeftDelimiter {
     LCurly(LCurly),
 }
 impl From<LParen> for LeftDelimiter {
-    fn from(node: LParen) -> LeftDelimiter {
-        LeftDelimiter::LParen(node)
-    }
+    fn from(node: LParen) -> LeftDelimiter { LeftDelimiter::LParen(node) }
 }
 impl From<LBrack> for LeftDelimiter {
-    fn from(node: LBrack) -> LeftDelimiter {
-        LeftDelimiter::LBrack(node)
-    }
+    fn from(node: LBrack) -> LeftDelimiter { LeftDelimiter::LBrack(node) }
 }
 impl From<LCurly> for LeftDelimiter {
-    fn from(node: LCurly) -> LeftDelimiter {
-        LeftDelimiter::LCurly(node)
-    }
+    fn from(node: LCurly) -> LeftDelimiter { LeftDelimiter::LCurly(node) }
 }
 impl std::fmt::Display for LeftDelimiter {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -3113,19 +2881,13 @@ pub enum RightDelimiter {
     RCurly(RCurly),
 }
 impl From<RParen> for RightDelimiter {
-    fn from(node: RParen) -> RightDelimiter {
-        RightDelimiter::RParen(node)
-    }
+    fn from(node: RParen) -> RightDelimiter { RightDelimiter::RParen(node) }
 }
 impl From<RBrack> for RightDelimiter {
-    fn from(node: RBrack) -> RightDelimiter {
-        RightDelimiter::RBrack(node)
-    }
+    fn from(node: RBrack) -> RightDelimiter { RightDelimiter::RBrack(node) }
 }
 impl From<RCurly> for RightDelimiter {
-    fn from(node: RCurly) -> RightDelimiter {
-        RightDelimiter::RCurly(node)
-    }
+    fn from(node: RCurly) -> RightDelimiter { RightDelimiter::RCurly(node) }
 }
 impl std::fmt::Display for RightDelimiter {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -3163,19 +2925,13 @@ pub enum RangeSeparator {
     Dotdoteq(Dotdoteq),
 }
 impl From<Dotdot> for RangeSeparator {
-    fn from(node: Dotdot) -> RangeSeparator {
-        RangeSeparator::Dotdot(node)
-    }
+    fn from(node: Dotdot) -> RangeSeparator { RangeSeparator::Dotdot(node) }
 }
 impl From<Dotdotdot> for RangeSeparator {
-    fn from(node: Dotdotdot) -> RangeSeparator {
-        RangeSeparator::Dotdotdot(node)
-    }
+    fn from(node: Dotdotdot) -> RangeSeparator { RangeSeparator::Dotdotdot(node) }
 }
 impl From<Dotdoteq> for RangeSeparator {
-    fn from(node: Dotdoteq) -> RangeSeparator {
-        RangeSeparator::Dotdoteq(node)
-    }
+    fn from(node: Dotdoteq) -> RangeSeparator { RangeSeparator::Dotdoteq(node) }
 }
 impl std::fmt::Display for RangeSeparator {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -3239,149 +2995,91 @@ pub enum BinOp {
     Careteq(Careteq),
 }
 impl From<Pipepipe> for BinOp {
-    fn from(node: Pipepipe) -> BinOp {
-        BinOp::Pipepipe(node)
-    }
+    fn from(node: Pipepipe) -> BinOp { BinOp::Pipepipe(node) }
 }
 impl From<Ampamp> for BinOp {
-    fn from(node: Ampamp) -> BinOp {
-        BinOp::Ampamp(node)
-    }
+    fn from(node: Ampamp) -> BinOp { BinOp::Ampamp(node) }
 }
 impl From<Eqeq> for BinOp {
-    fn from(node: Eqeq) -> BinOp {
-        BinOp::Eqeq(node)
-    }
+    fn from(node: Eqeq) -> BinOp { BinOp::Eqeq(node) }
 }
 impl From<Neq> for BinOp {
-    fn from(node: Neq) -> BinOp {
-        BinOp::Neq(node)
-    }
+    fn from(node: Neq) -> BinOp { BinOp::Neq(node) }
 }
 impl From<Lteq> for BinOp {
-    fn from(node: Lteq) -> BinOp {
-        BinOp::Lteq(node)
-    }
+    fn from(node: Lteq) -> BinOp { BinOp::Lteq(node) }
 }
 impl From<Gteq> for BinOp {
-    fn from(node: Gteq) -> BinOp {
-        BinOp::Gteq(node)
-    }
+    fn from(node: Gteq) -> BinOp { BinOp::Gteq(node) }
 }
 impl From<LAngle> for BinOp {
-    fn from(node: LAngle) -> BinOp {
-        BinOp::LAngle(node)
-    }
+    fn from(node: LAngle) -> BinOp { BinOp::LAngle(node) }
 }
 impl From<RAngle> for BinOp {
-    fn from(node: RAngle) -> BinOp {
-        BinOp::RAngle(node)
-    }
+    fn from(node: RAngle) -> BinOp { BinOp::RAngle(node) }
 }
 impl From<Plus> for BinOp {
-    fn from(node: Plus) -> BinOp {
-        BinOp::Plus(node)
-    }
+    fn from(node: Plus) -> BinOp { BinOp::Plus(node) }
 }
 impl From<Star> for BinOp {
-    fn from(node: Star) -> BinOp {
-        BinOp::Star(node)
-    }
+    fn from(node: Star) -> BinOp { BinOp::Star(node) }
 }
 impl From<Minus> for BinOp {
-    fn from(node: Minus) -> BinOp {
-        BinOp::Minus(node)
-    }
+    fn from(node: Minus) -> BinOp { BinOp::Minus(node) }
 }
 impl From<Slash> for BinOp {
-    fn from(node: Slash) -> BinOp {
-        BinOp::Slash(node)
-    }
+    fn from(node: Slash) -> BinOp { BinOp::Slash(node) }
 }
 impl From<Percent> for BinOp {
-    fn from(node: Percent) -> BinOp {
-        BinOp::Percent(node)
-    }
+    fn from(node: Percent) -> BinOp { BinOp::Percent(node) }
 }
 impl From<Shl> for BinOp {
-    fn from(node: Shl) -> BinOp {
-        BinOp::Shl(node)
-    }
+    fn from(node: Shl) -> BinOp { BinOp::Shl(node) }
 }
 impl From<Shr> for BinOp {
-    fn from(node: Shr) -> BinOp {
-        BinOp::Shr(node)
-    }
+    fn from(node: Shr) -> BinOp { BinOp::Shr(node) }
 }
 impl From<Caret> for BinOp {
-    fn from(node: Caret) -> BinOp {
-        BinOp::Caret(node)
-    }
+    fn from(node: Caret) -> BinOp { BinOp::Caret(node) }
 }
 impl From<Pipe> for BinOp {
-    fn from(node: Pipe) -> BinOp {
-        BinOp::Pipe(node)
-    }
+    fn from(node: Pipe) -> BinOp { BinOp::Pipe(node) }
 }
 impl From<Amp> for BinOp {
-    fn from(node: Amp) -> BinOp {
-        BinOp::Amp(node)
-    }
+    fn from(node: Amp) -> BinOp { BinOp::Amp(node) }
 }
 impl From<Eq> for BinOp {
-    fn from(node: Eq) -> BinOp {
-        BinOp::Eq(node)
-    }
+    fn from(node: Eq) -> BinOp { BinOp::Eq(node) }
 }
 impl From<Pluseq> for BinOp {
-    fn from(node: Pluseq) -> BinOp {
-        BinOp::Pluseq(node)
-    }
+    fn from(node: Pluseq) -> BinOp { BinOp::Pluseq(node) }
 }
 impl From<Slasheq> for BinOp {
-    fn from(node: Slasheq) -> BinOp {
-        BinOp::Slasheq(node)
-    }
+    fn from(node: Slasheq) -> BinOp { BinOp::Slasheq(node) }
 }
 impl From<Stareq> for BinOp {
-    fn from(node: Stareq) -> BinOp {
-        BinOp::Stareq(node)
-    }
+    fn from(node: Stareq) -> BinOp { BinOp::Stareq(node) }
 }
 impl From<Percenteq> for BinOp {
-    fn from(node: Percenteq) -> BinOp {
-        BinOp::Percenteq(node)
-    }
+    fn from(node: Percenteq) -> BinOp { BinOp::Percenteq(node) }
 }
 impl From<Shreq> for BinOp {
-    fn from(node: Shreq) -> BinOp {
-        BinOp::Shreq(node)
-    }
+    fn from(node: Shreq) -> BinOp { BinOp::Shreq(node) }
 }
 impl From<Shleq> for BinOp {
-    fn from(node: Shleq) -> BinOp {
-        BinOp::Shleq(node)
-    }
+    fn from(node: Shleq) -> BinOp { BinOp::Shleq(node) }
 }
 impl From<Minuseq> for BinOp {
-    fn from(node: Minuseq) -> BinOp {
-        BinOp::Minuseq(node)
-    }
+    fn from(node: Minuseq) -> BinOp { BinOp::Minuseq(node) }
 }
 impl From<Pipeeq> for BinOp {
-    fn from(node: Pipeeq) -> BinOp {
-        BinOp::Pipeeq(node)
-    }
+    fn from(node: Pipeeq) -> BinOp { BinOp::Pipeeq(node) }
 }
 impl From<Ampeq> for BinOp {
-    fn from(node: Ampeq) -> BinOp {
-        BinOp::Ampeq(node)
-    }
+    fn from(node: Ampeq) -> BinOp { BinOp::Ampeq(node) }
 }
 impl From<Careteq> for BinOp {
-    fn from(node: Careteq) -> BinOp {
-        BinOp::Careteq(node)
-    }
+    fn from(node: Careteq) -> BinOp { BinOp::Careteq(node) }
 }
 impl std::fmt::Display for BinOp {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -3473,19 +3171,13 @@ pub enum PrefixOp {
     Star(Star),
 }
 impl From<Minus> for PrefixOp {
-    fn from(node: Minus) -> PrefixOp {
-        PrefixOp::Minus(node)
-    }
+    fn from(node: Minus) -> PrefixOp { PrefixOp::Minus(node) }
 }
 impl From<Excl> for PrefixOp {
-    fn from(node: Excl) -> PrefixOp {
-        PrefixOp::Excl(node)
-    }
+    fn from(node: Excl) -> PrefixOp { PrefixOp::Excl(node) }
 }
 impl From<Star> for PrefixOp {
-    fn from(node: Star) -> PrefixOp {
-        PrefixOp::Star(node)
-    }
+    fn from(node: Star) -> PrefixOp { PrefixOp::Star(node) }
 }
 impl std::fmt::Display for PrefixOp {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -3522,14 +3214,10 @@ pub enum RangeOp {
     Dotdoteq(Dotdoteq),
 }
 impl From<Dotdot> for RangeOp {
-    fn from(node: Dotdot) -> RangeOp {
-        RangeOp::Dotdot(node)
-    }
+    fn from(node: Dotdot) -> RangeOp { RangeOp::Dotdot(node) }
 }
 impl From<Dotdoteq> for RangeOp {
-    fn from(node: Dotdoteq) -> RangeOp {
-        RangeOp::Dotdoteq(node)
-    }
+    fn from(node: Dotdoteq) -> RangeOp { RangeOp::Dotdoteq(node) }
 }
 impl std::fmt::Display for RangeOp {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -3572,54 +3260,34 @@ pub enum LiteralToken {
     Byte(Byte),
 }
 impl From<IntNumber> for LiteralToken {
-    fn from(node: IntNumber) -> LiteralToken {
-        LiteralToken::IntNumber(node)
-    }
+    fn from(node: IntNumber) -> LiteralToken { LiteralToken::IntNumber(node) }
 }
 impl From<FloatNumber> for LiteralToken {
-    fn from(node: FloatNumber) -> LiteralToken {
-        LiteralToken::FloatNumber(node)
-    }
+    fn from(node: FloatNumber) -> LiteralToken { LiteralToken::FloatNumber(node) }
 }
 impl From<String> for LiteralToken {
-    fn from(node: String) -> LiteralToken {
-        LiteralToken::String(node)
-    }
+    fn from(node: String) -> LiteralToken { LiteralToken::String(node) }
 }
 impl From<RawString> for LiteralToken {
-    fn from(node: RawString) -> LiteralToken {
-        LiteralToken::RawString(node)
-    }
+    fn from(node: RawString) -> LiteralToken { LiteralToken::RawString(node) }
 }
 impl From<TrueKw> for LiteralToken {
-    fn from(node: TrueKw) -> LiteralToken {
-        LiteralToken::TrueKw(node)
-    }
+    fn from(node: TrueKw) -> LiteralToken { LiteralToken::TrueKw(node) }
 }
 impl From<FalseKw> for LiteralToken {
-    fn from(node: FalseKw) -> LiteralToken {
-        LiteralToken::FalseKw(node)
-    }
+    fn from(node: FalseKw) -> LiteralToken { LiteralToken::FalseKw(node) }
 }
 impl From<ByteString> for LiteralToken {
-    fn from(node: ByteString) -> LiteralToken {
-        LiteralToken::ByteString(node)
-    }
+    fn from(node: ByteString) -> LiteralToken { LiteralToken::ByteString(node) }
 }
 impl From<RawByteString> for LiteralToken {
-    fn from(node: RawByteString) -> LiteralToken {
-        LiteralToken::RawByteString(node)
-    }
+    fn from(node: RawByteString) -> LiteralToken { LiteralToken::RawByteString(node) }
 }
 impl From<Char> for LiteralToken {
-    fn from(node: Char) -> LiteralToken {
-        LiteralToken::Char(node)
-    }
+    fn from(node: Char) -> LiteralToken { LiteralToken::Char(node) }
 }
 impl From<Byte> for LiteralToken {
-    fn from(node: Byte) -> LiteralToken {
-        LiteralToken::Byte(node)
-    }
+    fn from(node: Byte) -> LiteralToken { LiteralToken::Byte(node) }
 }
 impl std::fmt::Display for LiteralToken {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -3671,14 +3339,10 @@ pub enum NameRefToken {
     IntNumber(IntNumber),
 }
 impl From<Ident> for NameRefToken {
-    fn from(node: Ident) -> NameRefToken {
-        NameRefToken::Ident(node)
-    }
+    fn from(node: Ident) -> NameRefToken { NameRefToken::Ident(node) }
 }
 impl From<IntNumber> for NameRefToken {
-    fn from(node: IntNumber) -> NameRefToken {
-        NameRefToken::IntNumber(node)
-    }
+    fn from(node: IntNumber) -> NameRefToken { NameRefToken::IntNumber(node) }
 }
 impl std::fmt::Display for NameRefToken {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
diff --git a/xtask/src/lib.rs b/xtask/src/lib.rs
index 9d087daa24..ec824a5183 100644
--- a/xtask/src/lib.rs
+++ b/xtask/src/lib.rs
@@ -67,6 +67,7 @@ fn reformat(text: impl std::fmt::Display) -> Result<String> {
     let mut rustfmt = Command::new("rustup")
         .args(&["run", TOOLCHAIN, "--", "rustfmt", "--config-path"])
         .arg(project_root().join("rustfmt.toml"))
+        .args(&["--config", "fn_single_line=true"])
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .spawn()?;