3 files changed, 268 insertions, 268 deletions

diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs
index cf5b6f251..d7ea4354d 100644
--- a/crates/ra_syntax/src/ast/expr_extensions.rs
+++ b/crates/ra_syntax/src/ast/expr_extensions.rs
@@ -296,8 +296,8 @@ fn test_literal_with_attr() {
     assert_eq!(lit.token().text(), r#""Hello""#);
 }
 
-impl ast::NamedField {
-    pub fn parent_struct_lit(&self) -> ast::StructLit {
-        self.syntax().ancestors().find_map(ast::StructLit::cast).unwrap()
+impl ast::RecordField {
+    pub fn parent_record_lit(&self) -> ast::RecordLit {
+        self.syntax().ancestors().find_map(ast::RecordLit::cast).unwrap()
     }
 }
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index e0ea3e5ab..d3a375f87 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -195,16 +195,16 @@ impl ast::ImplBlock {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum StructKind {
-    Tuple(ast::PosFieldDefList),
-    Named(ast::NamedFieldDefList),
+    Tuple(ast::TupleFieldDefList),
+    Named(ast::RecordFieldDefList),
     Unit,
 }
 
 impl StructKind {
     fn from_node<N: AstNode>(node: &N) -> StructKind {
-        if let Some(nfdl) = child_opt::<_, ast::NamedFieldDefList>(node) {
+        if let Some(nfdl) = child_opt::<_, ast::RecordFieldDefList>(node) {
             StructKind::Named(nfdl)
-        } else if let Some(pfl) = child_opt::<_, ast::PosFieldDefList>(node) {
+        } else if let Some(pfl) = child_opt::<_, ast::TupleFieldDefList>(node) {
             StructKind::Tuple(pfl)
         } else {
             StructKind::Unit
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 9c5789701..07cc3e0db 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -607,7 +607,7 @@ pub enum Expr {
     BlockExpr(BlockExpr),
     ReturnExpr(ReturnExpr),
     MatchExpr(MatchExpr),
-    StructLit(StructLit),
+    RecordLit(RecordLit),
     CallExpr(CallExpr),
     IndexExpr(IndexExpr),
     MethodCallExpr(MethodCallExpr),
@@ -698,9 +698,9 @@ impl From<MatchExpr> for Expr {
         Expr::MatchExpr(node)
     }
 }
-impl From<StructLit> for Expr {
-    fn from(node: StructLit) -> Expr {
-        Expr::StructLit(node)
+impl From<RecordLit> for Expr {
+    fn from(node: RecordLit) -> Expr {
+        Expr::RecordLit(node)
     }
 }
 impl From<CallExpr> for Expr {
@@ -778,7 +778,7 @@ impl AstNode for Expr {
         match kind {
             TUPLE_EXPR | ARRAY_EXPR | PAREN_EXPR | PATH_EXPR | LAMBDA_EXPR | IF_EXPR
             | LOOP_EXPR | FOR_EXPR | WHILE_EXPR | CONTINUE_EXPR | BREAK_EXPR | LABEL
-            | BLOCK_EXPR | RETURN_EXPR | MATCH_EXPR | STRUCT_LIT | CALL_EXPR | INDEX_EXPR
+            | BLOCK_EXPR | RETURN_EXPR | MATCH_EXPR | RECORD_LIT | CALL_EXPR | INDEX_EXPR
             | METHOD_CALL_EXPR | FIELD_EXPR | AWAIT_EXPR | TRY_EXPR | TRY_BLOCK_EXPR
             | CAST_EXPR | REF_EXPR | PREFIX_EXPR | RANGE_EXPR | BIN_EXPR | LITERAL | MACRO_CALL => {
                 true
@@ -803,7 +803,7 @@ impl AstNode for Expr {
             BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }),
             RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }),
             MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
-            STRUCT_LIT => Expr::StructLit(StructLit { syntax }),
+            RECORD_LIT => Expr::RecordLit(RecordLit { syntax }),
             CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
             INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
             METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
@@ -839,7 +839,7 @@ impl AstNode for Expr {
             Expr::BlockExpr(it) => &it.syntax,
             Expr::ReturnExpr(it) => &it.syntax,
             Expr::MatchExpr(it) => &it.syntax,
-            Expr::StructLit(it) => &it.syntax,
+            Expr::RecordLit(it) => &it.syntax,
             Expr::CallExpr(it) => &it.syntax,
             Expr::IndexExpr(it) => &it.syntax,
             Expr::MethodCallExpr(it) => &it.syntax,
@@ -946,64 +946,6 @@ impl FieldExpr {
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct FieldPat {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for FieldPat {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            FIELD_PAT => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-impl ast::NameOwner for FieldPat {}
-impl FieldPat {
-    pub fn pat(&self) -> Option<Pat> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct FieldPatList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for FieldPatList {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            FIELD_PAT_LIST => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-impl FieldPatList {
-    pub fn field_pats(&self) -> AstChildren<FieldPat> {
-        AstChildren::new(&self.syntax)
-    }
-    pub fn bind_pats(&self) -> AstChildren<BindPat> {
-        AstChildren::new(&self.syntax)
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct FnDef {
     pub(crate) syntax: SyntaxNode,
 }
@@ -1942,121 +1884,6 @@ impl AstNode for NameRef {
 }
 impl NameRef {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NamedField {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for NamedField {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            NAMED_FIELD => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-impl NamedField {
-    pub fn name_ref(&self) -> Option<NameRef> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn expr(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NamedFieldDef {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for NamedFieldDef {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            NAMED_FIELD_DEF => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-impl ast::VisibilityOwner for NamedFieldDef {}
-impl ast::NameOwner for NamedFieldDef {}
-impl ast::AttrsOwner for NamedFieldDef {}
-impl ast::DocCommentsOwner for NamedFieldDef {}
-impl ast::TypeAscriptionOwner for NamedFieldDef {}
-impl NamedFieldDef {}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NamedFieldDefList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for NamedFieldDefList {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            NAMED_FIELD_DEF_LIST => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-impl NamedFieldDefList {
-    pub fn fields(&self) -> AstChildren<NamedFieldDef> {
-        AstChildren::new(&self.syntax)
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NamedFieldList {
-    pub(crate) syntax: SyntaxNode,
-}
-impl AstNode for NamedFieldList {
-    fn can_cast(kind: SyntaxKind) -> bool {
-        match kind {
-            NAMED_FIELD_LIST => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxNode) -> Option<Self> {
-        if Self::can_cast(syntax.kind()) {
-            Some(Self { syntax })
-        } else {
-            None
-        }
-    }
-    fn syntax(&self) -> &SyntaxNode {
-        &self.syntax
-    }
-}
-impl NamedFieldList {
-    pub fn fields(&self) -> AstChildren<NamedField> {
-        AstChildren::new(&self.syntax)
-    }
-    pub fn spread(&self) -> Option<Expr> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NeverType {
     pub(crate) syntax: SyntaxNode,
 }
@@ -2239,7 +2066,7 @@ pub enum Pat {
     BindPat(BindPat),
     PlaceholderPat(PlaceholderPat),
     PathPat(PathPat),
-    StructPat(StructPat),
+    RecordPat(RecordPat),
     TupleStructPat(TupleStructPat),
     TuplePat(TuplePat),
     SlicePat(SlicePat),
@@ -2266,9 +2093,9 @@ impl From<PathPat> for Pat {
         Pat::PathPat(node)
     }
 }
-impl From<StructPat> for Pat {
-    fn from(node: StructPat) -> Pat {
-        Pat::StructPat(node)
+impl From<RecordPat> for Pat {
+    fn from(node: RecordPat) -> Pat {
+        Pat::RecordPat(node)
     }
 }
 impl From<TupleStructPat> for Pat {
@@ -2299,7 +2126,7 @@ impl From<LiteralPat> for Pat {
 impl AstNode for Pat {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            REF_PAT | BIND_PAT | PLACEHOLDER_PAT | PATH_PAT | STRUCT_PAT | TUPLE_STRUCT_PAT
+            REF_PAT | BIND_PAT | PLACEHOLDER_PAT | PATH_PAT | RECORD_PAT | TUPLE_STRUCT_PAT
             | TUPLE_PAT | SLICE_PAT | RANGE_PAT | LITERAL_PAT => true,
             _ => false,
         }
@@ -2310,7 +2137,7 @@ impl AstNode for Pat {
             BIND_PAT => Pat::BindPat(BindPat { syntax }),
             PLACEHOLDER_PAT => Pat::PlaceholderPat(PlaceholderPat { syntax }),
             PATH_PAT => Pat::PathPat(PathPat { syntax }),
-            STRUCT_PAT => Pat::StructPat(StructPat { syntax }),
+            RECORD_PAT => Pat::RecordPat(RecordPat { syntax }),
             TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
             TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
             SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
@@ -2326,7 +2153,7 @@ impl AstNode for Pat {
             Pat::BindPat(it) => &it.syntax,
             Pat::PlaceholderPat(it) => &it.syntax,
             Pat::PathPat(it) => &it.syntax,
-            Pat::StructPat(it) => &it.syntax,
+            Pat::RecordPat(it) => &it.syntax,
             Pat::TupleStructPat(it) => &it.syntax,
             Pat::TuplePat(it) => &it.syntax,
             Pat::SlicePat(it) => &it.syntax,
@@ -2551,13 +2378,13 @@ impl PointerType {
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PosFieldDef {
+pub struct PrefixExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for PosFieldDef {
+impl AstNode for PrefixExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            POS_FIELD_DEF => true,
+            PREFIX_EXPR => true,
             _ => false,
         }
     }
@@ -2572,21 +2399,19 @@ impl AstNode for PosFieldDef {
         &self.syntax
     }
 }
-impl ast::VisibilityOwner for PosFieldDef {}
-impl ast::AttrsOwner for PosFieldDef {}
-impl PosFieldDef {
-    pub fn type_ref(&self) -> Option<TypeRef> {
+impl PrefixExpr {
+    pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PosFieldDefList {
+pub struct RangeExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for PosFieldDefList {
+impl AstNode for RangeExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            POS_FIELD_DEF_LIST => true,
+            RANGE_EXPR => true,
             _ => false,
         }
     }
@@ -2601,19 +2426,38 @@ impl AstNode for PosFieldDefList {
         &self.syntax
     }
 }
-impl PosFieldDefList {
-    pub fn fields(&self) -> AstChildren<PosFieldDef> {
-        AstChildren::new(&self.syntax)
+impl RangeExpr {}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RangePat {
+    pub(crate) syntax: SyntaxNode,
+}
+impl AstNode for RangePat {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            RANGE_PAT => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
     }
 }
+impl RangePat {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PrefixExpr {
+pub struct RecordField {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for PrefixExpr {
+impl AstNode for RecordField {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            PREFIX_EXPR => true,
+            RECORD_FIELD => true,
             _ => false,
         }
     }
@@ -2628,19 +2472,22 @@ impl AstNode for PrefixExpr {
         &self.syntax
     }
 }
-impl PrefixExpr {
+impl RecordField {
+    pub fn name_ref(&self) -> Option<NameRef> {
+        AstChildren::new(&self.syntax).next()
+    }
     pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RangeExpr {
+pub struct RecordFieldDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RangeExpr {
+impl AstNode for RecordFieldDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RANGE_EXPR => true,
+            RECORD_FIELD_DEF => true,
             _ => false,
         }
     }
@@ -2655,15 +2502,20 @@ impl AstNode for RangeExpr {
         &self.syntax
     }
 }
-impl RangeExpr {}
+impl ast::VisibilityOwner for RecordFieldDef {}
+impl ast::NameOwner for RecordFieldDef {}
+impl ast::AttrsOwner for RecordFieldDef {}
+impl ast::DocCommentsOwner for RecordFieldDef {}
+impl ast::TypeAscriptionOwner for RecordFieldDef {}
+impl RecordFieldDef {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RangePat {
+pub struct RecordFieldDefList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for RangePat {
+impl AstNode for RecordFieldDefList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            RANGE_PAT => true,
+            RECORD_FIELD_DEF_LIST => true,
             _ => false,
         }
     }
@@ -2678,7 +2530,159 @@ impl AstNode for RangePat {
         &self.syntax
     }
 }
-impl RangePat {}
+impl RecordFieldDefList {
+    pub fn fields(&self) -> AstChildren<RecordFieldDef> {
+        AstChildren::new(&self.syntax)
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RecordFieldList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl AstNode for RecordFieldList {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            RECORD_FIELD_LIST => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl RecordFieldList {
+    pub fn fields(&self) -> AstChildren<RecordField> {
+        AstChildren::new(&self.syntax)
+    }
+    pub fn spread(&self) -> Option<Expr> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RecordFieldPat {
+    pub(crate) syntax: SyntaxNode,
+}
+impl AstNode for RecordFieldPat {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            RECORD_FIELD_PAT => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl ast::NameOwner for RecordFieldPat {}
+impl RecordFieldPat {
+    pub fn pat(&self) -> Option<Pat> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RecordFieldPatList {
+    pub(crate) syntax: SyntaxNode,
+}
+impl AstNode for RecordFieldPatList {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            RECORD_FIELD_PAT_LIST => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl RecordFieldPatList {
+    pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> {
+        AstChildren::new(&self.syntax)
+    }
+    pub fn bind_pats(&self) -> AstChildren<BindPat> {
+        AstChildren::new(&self.syntax)
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RecordLit {
+    pub(crate) syntax: SyntaxNode,
+}
+impl AstNode for RecordLit {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            RECORD_LIT => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl RecordLit {
+    pub fn path(&self) -> Option<Path> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn record_field_list(&self) -> Option<RecordFieldList> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct RecordPat {
+    pub(crate) syntax: SyntaxNode,
+}
+impl AstNode for RecordPat {
+    fn can_cast(kind: SyntaxKind) -> bool {
+        match kind {
+            RECORD_PAT => true,
+            _ => false,
+        }
+    }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode {
+        &self.syntax
+    }
+}
+impl RecordPat {
+    pub fn record_field_pat_list(&self) -> Option<RecordFieldPatList> {
+        AstChildren::new(&self.syntax).next()
+    }
+    pub fn path(&self) -> Option<Path> {
+        AstChildren::new(&self.syntax).next()
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RefExpr {
     pub(crate) syntax: SyntaxNode,
@@ -3018,13 +3022,13 @@ impl ast::AttrsOwner for StructDef {}
 impl ast::DocCommentsOwner for StructDef {}
 impl StructDef {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct StructLit {
+pub struct TokenTree {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for StructLit {
+impl AstNode for TokenTree {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            STRUCT_LIT => true,
+            TOKEN_TREE => true,
             _ => false,
         }
     }
@@ -3039,22 +3043,15 @@ impl AstNode for StructLit {
         &self.syntax
     }
 }
-impl StructLit {
-    pub fn path(&self) -> Option<Path> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn named_field_list(&self) -> Option<NamedFieldList> {
-        AstChildren::new(&self.syntax).next()
-    }
-}
+impl TokenTree {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct StructPat {
+pub struct TraitDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for StructPat {
+impl AstNode for TraitDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            STRUCT_PAT => true,
+            TRAIT_DEF => true,
             _ => false,
         }
     }
@@ -3069,22 +3066,25 @@ impl AstNode for StructPat {
         &self.syntax
     }
 }
-impl StructPat {
-    pub fn field_pat_list(&self) -> Option<FieldPatList> {
-        AstChildren::new(&self.syntax).next()
-    }
-    pub fn path(&self) -> Option<Path> {
+impl ast::VisibilityOwner for TraitDef {}
+impl ast::NameOwner for TraitDef {}
+impl ast::AttrsOwner for TraitDef {}
+impl ast::DocCommentsOwner for TraitDef {}
+impl ast::TypeParamsOwner for TraitDef {}
+impl ast::TypeBoundsOwner for TraitDef {}
+impl TraitDef {
+    pub fn item_list(&self) -> Option<ItemList> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TokenTree {
+pub struct TryBlockExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TokenTree {
+impl AstNode for TryBlockExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TOKEN_TREE => true,
+            TRY_BLOCK_EXPR => true,
             _ => false,
         }
     }
@@ -3099,15 +3099,16 @@ impl AstNode for TokenTree {
         &self.syntax
     }
 }
-impl TokenTree {}
+impl ast::TryBlockBodyOwner for TryBlockExpr {}
+impl TryBlockExpr {}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TraitDef {
+pub struct TryExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TraitDef {
+impl AstNode for TryExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TRAIT_DEF => true,
+            TRY_EXPR => true,
             _ => false,
         }
     }
@@ -3122,25 +3123,19 @@ impl AstNode for TraitDef {
         &self.syntax
     }
 }
-impl ast::VisibilityOwner for TraitDef {}
-impl ast::NameOwner for TraitDef {}
-impl ast::AttrsOwner for TraitDef {}
-impl ast::DocCommentsOwner for TraitDef {}
-impl ast::TypeParamsOwner for TraitDef {}
-impl ast::TypeBoundsOwner for TraitDef {}
-impl TraitDef {
-    pub fn item_list(&self) -> Option<ItemList> {
+impl TryExpr {
+    pub fn expr(&self) -> Option<Expr> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TryBlockExpr {
+pub struct TupleExpr {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TryBlockExpr {
+impl AstNode for TupleExpr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TRY_BLOCK_EXPR => true,
+            TUPLE_EXPR => true,
             _ => false,
         }
     }
@@ -3155,16 +3150,19 @@ impl AstNode for TryBlockExpr {
         &self.syntax
     }
 }
-impl ast::TryBlockBodyOwner for TryBlockExpr {}
-impl TryBlockExpr {}
+impl TupleExpr {
+    pub fn exprs(&self) -> AstChildren<Expr> {
+        AstChildren::new(&self.syntax)
+    }
+}
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TryExpr {
+pub struct TupleFieldDef {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TryExpr {
+impl AstNode for TupleFieldDef {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TRY_EXPR => true,
+            TUPLE_FIELD_DEF => true,
             _ => false,
         }
     }
@@ -3179,19 +3177,21 @@ impl AstNode for TryExpr {
         &self.syntax
     }
 }
-impl TryExpr {
-    pub fn expr(&self) -> Option<Expr> {
+impl ast::VisibilityOwner for TupleFieldDef {}
+impl ast::AttrsOwner for TupleFieldDef {}
+impl TupleFieldDef {
+    pub fn type_ref(&self) -> Option<TypeRef> {
         AstChildren::new(&self.syntax).next()
     }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct TupleExpr {
+pub struct TupleFieldDefList {
     pub(crate) syntax: SyntaxNode,
 }
-impl AstNode for TupleExpr {
+impl AstNode for TupleFieldDefList {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
-            TUPLE_EXPR => true,
+            TUPLE_FIELD_DEF_LIST => true,
             _ => false,
         }
     }
@@ -3206,8 +3206,8 @@ impl AstNode for TupleExpr {
         &self.syntax
     }
 }
-impl TupleExpr {
-    pub fn exprs(&self) -> AstChildren<Expr> {
+impl TupleFieldDefList {
+    pub fn fields(&self) -> AstChildren<TupleFieldDef> {
         AstChildren::new(&self.syntax)
     }
 }