2 files changed, 121 insertions, 126 deletions

diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs
index c77fc8a8d..e993a750c 100644
--- a/xtask/src/codegen/gen_syntax.rs
+++ b/xtask/src/codegen/gen_syntax.rs
@@ -13,7 +13,7 @@ use quote::{format_ident, quote};
 use ungrammar::{Grammar, Rule};
 
 use crate::{
-    ast_src::{AstEnumSrc, AstNodeSrc, AstSrc, Field, FieldSrc, KindsSrc, KINDS_SRC},
+    ast_src::{AstEnumSrc, AstNodeSrc, AstSrc, Cardinality, Field, KindsSrc, KINDS_SRC},
     codegen::{self, update, Mode},
     project_root, Result,
 };
@@ -307,7 +307,7 @@ fn generate_syntax_kinds(grammar: KindsSrc<'_>) -> Result<String> {
 
     let ast = quote! {
         #![allow(bad_style, missing_docs, unreachable_pub)]
-        /// The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT_DEF`.
+        /// The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT`.
         #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
         #[repr(u16)]
         pub enum SyntaxKind {
@@ -431,7 +431,7 @@ fn pluralize(s: &str) -> String {
 
 impl Field {
     fn is_many(&self) -> bool {
-        matches!(self, Field::Node { src: FieldSrc::Many(_), .. })
+        matches!(self, Field::Node { cardinality: Cardinality::Many, .. })
     }
     fn token_kind(&self) -> Option<proc_macro2::TokenStream> {
         match self {
@@ -471,23 +471,18 @@ impl Field {
                     "::" => "coloncolon",
                     "#" => "pound",
                     "?" => "question_mark",
+                    "," => "comma",
                     _ => name,
                 };
                 format_ident!("{}_token", name)
             }
-            Field::Node { name, src } => match src {
-                FieldSrc::Shorthand => format_ident!("{}", to_lower_snake_case(name)),
-                _ => format_ident!("{}", name),
-            },
+            Field::Node { name, .. } => format_ident!("{}", name),
         }
     }
     fn ty(&self) -> proc_macro2::Ident {
         match self {
             Field::Token(_) => format_ident!("SyntaxToken"),
-            Field::Node { name, src } => match src {
-                FieldSrc::Optional(ty) | FieldSrc::Many(ty) => format_ident!("{}", ty),
-                FieldSrc::Shorthand => format_ident!("{}", name),
-            },
+            Field::Node { ty, .. } => format_ident!("{}", ty),
         }
     }
 }
@@ -514,7 +509,7 @@ fn lower(grammar: &Grammar) -> AstSrc {
             }
             None => {
                 let mut fields = Vec::new();
-                lower_rule(&mut fields, grammar, rule);
+                lower_rule(&mut fields, grammar, None, rule);
                 res.nodes.push(AstNodeSrc { doc: Vec::new(), name, traits: Vec::new(), fields });
             }
         }
@@ -542,17 +537,20 @@ fn lower_enum(grammar: &Grammar, rule: &Rule) -> Option<Vec<String>> {
     Some(variants)
 }
 
-fn lower_rule(acc: &mut Vec<Field>, grammar: &Grammar, rule: &Rule) {
-    if lower_comma_list(acc, grammar, rule) {
+fn lower_rule(acc: &mut Vec<Field>, grammar: &Grammar, label: Option<&String>, rule: &Rule) {
+    if lower_comma_list(acc, grammar, label, rule) {
         return;
     }
 
     match rule {
         Rule::Node(node) => {
-            let field = Field::Node { name: grammar[*node].name.clone(), src: FieldSrc::Shorthand };
+            let ty = grammar[*node].name.clone();
+            let name = label.cloned().unwrap_or_else(|| to_lower_snake_case(&ty));
+            let field = Field::Node { name, ty, cardinality: Cardinality::Optional };
             acc.push(field);
         }
         Rule::Token(token) => {
+            assert!(label.is_none());
             let mut name = grammar[*token].name.clone();
             if name != "int_number" && name != "string" {
                 if "[]{}()".contains(&name) {
@@ -564,48 +562,35 @@ fn lower_rule(acc: &mut Vec<Field>, grammar: &Grammar, rule: &Rule) {
         }
         Rule::Rep(inner) => {
             if let Rule::Node(node) = &**inner {
-                let name = grammar[*node].name.clone();
-                let label = pluralize(&to_lower_snake_case(&name));
-                let field = Field::Node { name: label.clone(), src: FieldSrc::Many(name) };
+                let ty = grammar[*node].name.clone();
+                let name = label.cloned().unwrap_or_else(|| pluralize(&to_lower_snake_case(&ty)));
+                let field = Field::Node { name, ty, cardinality: Cardinality::Many };
                 acc.push(field);
                 return;
             }
             todo!("{:?}", rule)
         }
-        Rule::Labeled { label, rule } => {
-            let node = match &**rule {
-                Rule::Rep(inner) | Rule::Opt(inner) => match &**inner {
-                    Rule::Node(node) => node,
-                    _ => todo!("{:?}", rule),
-                },
-                Rule::Node(node) => node,
-                _ => todo!("{:?}", rule),
-            };
-            let field = Field::Node {
-                name: label.clone(),
-                src: match &**rule {
-                    Rule::Rep(_) => FieldSrc::Many(grammar[*node].name.clone()),
-                    _ => FieldSrc::Optional(grammar[*node].name.clone()),
-                },
-            };
-            acc.push(field);
+        Rule::Labeled { label: l, rule } => {
+            assert!(label.is_none());
+            lower_rule(acc, grammar, Some(l), rule);
         }
         Rule::Seq(rules) | Rule::Alt(rules) => {
             for rule in rules {
-                lower_rule(acc, grammar, rule)
+                lower_rule(acc, grammar, label, rule)
             }
         }
-        Rule::Opt(rule) => lower_rule(acc, grammar, rule),
+        Rule::Opt(rule) => lower_rule(acc, grammar, label, rule),
     }
 }
 
-// (T (',' T)* ','?)?
-fn lower_comma_list(acc: &mut Vec<Field>, grammar: &Grammar, rule: &Rule) -> bool {
+// (T (',' T)* ','?)
+fn lower_comma_list(
+    acc: &mut Vec<Field>,
+    grammar: &Grammar,
+    label: Option<&String>,
+    rule: &Rule,
+) -> bool {
     let rule = match rule {
-        Rule::Opt(it) => it,
-        _ => return false,
-    };
-    let rule = match &**rule {
         Rule::Seq(it) => it,
         _ => return false,
     };
@@ -623,9 +608,9 @@ fn lower_comma_list(acc: &mut Vec<Field>, grammar: &Grammar, rule: &Rule) -> boo
         [comma, Rule::Node(n)] if comma == &**trailing_comma && n == node => (),
         _ => return false,
     }
-    let name = grammar[*node].name.clone();
-    let label = pluralize(&to_lower_snake_case(&name));
-    let field = Field::Node { name: label.clone(), src: FieldSrc::Many(name) };
+    let ty = grammar[*node].name.clone();
+    let name = label.cloned().unwrap_or_else(|| pluralize(&to_lower_snake_case(&ty)));
+    let field = Field::Node { name, ty, cardinality: Cardinality::Many };
     acc.push(field);
     true
 }
@@ -659,7 +644,9 @@ fn extract_enums(ast: &mut AstSrc) {
             }
             if to_remove.len() == enm.variants.len() {
                 node.remove_field(to_remove);
-                node.fields.push(Field::Node { name: enm.name.clone(), src: FieldSrc::Shorthand });
+                let ty = enm.name.clone();
+                let name = to_lower_snake_case(&ty);
+                node.fields.push(Field::Node { name, ty, cardinality: Cardinality::Optional });
             }
         }
     }
@@ -670,7 +657,7 @@ fn extract_struct_traits(ast: &mut AstSrc) {
         ("AttrsOwner", &["attrs"]),
         ("NameOwner", &["name"]),
         ("VisibilityOwner", &["visibility"]),
-        ("TypeParamsOwner", &["type_param_list", "where_clause"]),
+        ("GenericParamsOwner", &["generic_param_list", "where_clause"]),
         ("TypeBoundsOwner", &["type_bound_list", "colon_token"]),
         ("ModuleItemOwner", &["items"]),
         ("TypeAscriptionOwner", &["ascribed_type"]),
diff --git a/xtask/src/codegen/rust.ungram b/xtask/src/codegen/rust.ungram
index 449b0242f..ef7c3e50e 100644
--- a/xtask/src/codegen/rust.ungram
+++ b/xtask/src/codegen/rust.ungram
@@ -4,19 +4,19 @@ SourceFile =
   Item*
 
 Item =
-  ConstDef
-| EnumDef
+  Const
+| Enum
 | ExternBlock
 | ExternCrate
-| FnDef
+| Fn
 | ImplDef
 | MacroCall
 | Module
-| StaticDef
-| StructDef
+| Static
+| Struct
 | TraitDef
-| TypeAliasDef
-| UnionDef
+| TypeAlias
+| Union
 | Use
 
 Module =
@@ -42,73 +42,94 @@ UseTree =
 UseTreeList =
   '{' (UseTree (',' UseTree)* ','?)? '}'
 
-FnDef =
- Attr* Visibility? Abi? 'const' 'default' 'async' 'unsafe' 'fn' Name TypeParamList?
- ParamList RetType?
+Fn =
+ Attr* Visibility?
+ 'default'? ('async' | 'const')? 'unsafe'? Abi?
+ 'fn' Name GenericParamList? ParamList RetType?
  WhereClause?
  (body:BlockExpr | ';')
 
+Abi =
+  'extern' 'string'?
+
+ParamList =
+  '('(
+    (Param (',' Param)* ','?)?
+  | SelfParam ','?
+  | SelfParam ',' (Param (',' Param)* ','?)
+  )')'
+
+SelfParam =
+  Attr* (
+    ('&' 'lifetime'?)? 'mut'? 'self'
+  | 'mut'? 'self' ':' ascribed_type:TypeRef
+  )
+
+Param =
+  Attr* Pat (':' ascribed_type:TypeRef)
+| '...'
+
 RetType =
   '->' TypeRef
 
-StructDef =
-  Attr* Visibility? 'struct' Name TypeParamList? (
-    WhereClause?  (RecordFieldDefList | ';')
-  | TupleFieldDefList WhereClause? ';'
-  )
+TypeAlias =
+  Attr* Visibility? 'default'? 'type' Name GenericParamList? (':' TypeBoundList?)? WhereClause?
+  '=' TypeRef ';'
 
-UnionDef =
-  Attr* Visibility? 'union' Name TypeParamList? WhereClause?
-  RecordFieldDefList
+Struct =
+  Attr* Visibility? 'struct' Name GenericParamList? (
+    WhereClause?  (RecordFieldList | ';')
+  | TupleFieldList WhereClause? ';'
+  )
 
-RecordFieldDefList =
- '{' fields:RecordFieldDef* '}'
+RecordFieldList =
+ '{' fields:(RecordField (',' RecordField)* ','?)? '}'
 
-RecordFieldDef =
+RecordField =
   Attr* Visibility? Name ':' ascribed_type:TypeRef
 
-TupleFieldDefList =
-  '(' fields:TupleFieldDef* ')'
+TupleFieldList =
+  '(' fields:(TupleField (',' TupleField)* ','?)? ')'
+
+TupleField =
+  Attr* Visibility? TypeRef
 
-TupleFieldDef =
-  Attr* Visibility? Name TypeRef
+FieldList =
+  RecordFieldList
+| TupleFieldList
 
-FieldDefList =
-  RecordFieldDefList
-| TupleFieldDefList
+Enum =
+  Attr* Visibility? 'enum' Name GenericParamList? WhereClause?
+  VariantList
 
-EnumDef =
-  Attr* Visibility? 'enum' Name TypeParamList? WhereClause?
-  variant_list:EnumVariantList
+VariantList =
+ '{' (Variant (',' Variant)* ','?)? '}'
 
-EnumVariantList =
- '{' variants:EnumVariant* '}'
+Variant =
+  Attr* Visibility? Name FieldList ('=' Expr)?
 
-EnumVariant =
-  Attr* Visibility? Name FieldDefList ('=' Expr)?
+Union =
+  Attr* Visibility? 'union' Name GenericParamList? WhereClause?
+  RecordFieldList
+
+Const =
+  Attr* Visibility? 'default'? 'const' (Name | '_') ':' ascribed_type:TypeRef
+  '=' body:Expr ';'
+
+Static =
+  Attr* Visibility? 'static'? 'mut'? Name ':' ascribed_type:TypeRef
+  '=' body:Expr ';'
 
 TraitDef =
-  Attr* Visibility? 'unsafe'? 'auto'? 'trait' Name TypeParamList
+  Attr* Visibility? 'unsafe'? 'auto'? 'trait' Name GenericParamList
   (':' TypeBoundList?)? WhereClause
   AssocItemList
 
 AssocItemList =
   '{' AssocItem* '}'
 
-ConstDef =
-  Attr* Visibility? 'default'? 'const' Name ':' ascribed_type:TypeRef
-  '=' body:Expr ';'
-
-StaticDef =
-  Attr* Visibility? 'static'? 'mut'? 'static' Name ':' ascribed_type:TypeRef
-  '=' body:Expr ';'
-
-TypeAliasDef =
-  Attr* Visibility? 'default'? 'type' Name TypeParamList? WhereClause? (':' TypeBoundList?)?
-  '=' TypeRef ';'
-
 ImplDef =
- Attr* Visibility? 'const'? 'default'? 'unsafe'? 'impl' TypeParamList? '!'? 'for'
+ Attr* Visibility? 'const'? 'default'? 'unsafe'? 'impl' GenericParamList? '!'? 'for'
  WhereClause?
  AssocItemList
 
@@ -143,7 +164,7 @@ FnPointerType =
    Abi 'unsafe'? 'fn' ParamList RetType?
 
 ForType =
-   'for' TypeParamList TypeRef
+   'for' GenericParamList TypeRef
 
 ImplTraitType =
   'impl' TypeBoundList
@@ -263,16 +284,16 @@ MatchArm =
 MatchGuard =
   'if' Expr
 
-RecordLit =
- Path RecordFieldList
+RecordExpr =
+ Path RecordExprFieldList
 
-RecordFieldList =
+RecordExprFieldList =
   '{'
-    fields:RecordField*
+    fields:RecordExprField*
     ('..' spread:Expr)?
   '}'
 
-RecordField =
+RecordExprField =
   Attr* NameRef (':' Expr)?
 
 OrPat =
@@ -358,7 +379,7 @@ MacroStmts =
 Attr =
   '#' '!'? '[' Path ('=' input:AttrInput)? ']'
 
-TypeParamList =
+GenericParamList =
   '<'
     TypeParam*
     LifetimeParam*
@@ -383,14 +404,11 @@ TypeBoundList =
    bounds:TypeBound*
 
 WherePred =
-  ('for' TypeParamList)?  ('lifetime' | TypeRef) ':' TypeBoundList
+  ('for' GenericParamList)?  ('lifetime' | TypeRef) ':' TypeBoundList
 
 WhereClause =
   'where' predicates:WherePred*
 
-Abi =
-  'string'
-
 ExprStmt =
   Attr* Expr ';'
 
@@ -398,16 +416,6 @@ LetStmt =
   Attr* 'let' Pat (':' ascribed_type:TypeRef)
   '=' initializer:Expr ';'
 
-ParamList =
-  '(' SelfParam Param* ')'
-
-SelfParam =
-  Attr* ('&' 'lifetime'?)? 'mut'? 'self' (':' ascribed_type:TypeRef)
-
-Param =
-  Attr* Pat (':' ascribed_type:TypeRef)
-| '...'
-
 Path =
   (qualifier:Path '::')? segment:PathSegment
 
@@ -445,9 +453,9 @@ MetaItem =
   Path '=' AttrInput nested_meta_items:MetaItem*
 
 AdtDef =
-  StructDef
-| EnumDef
-| UnionDef
+  Struct
+| Enum
+| Union
 
 TypeRef =
   ParenType
@@ -465,13 +473,13 @@ TypeRef =
 | DynTraitType
 
 AssocItem =
-  FnDef
-| TypeAliasDef
-| ConstDef
+  Fn
+| TypeAlias
+| Const
 | MacroCall
 
 ExternItem =
-  FnDef | StaticDef
+  Fn | Static
 
 AttrInput =
   Literal
@@ -514,7 +522,7 @@ Expr =
 | BlockExpr
 | ReturnExpr
 | MatchExpr
-| RecordLit
+| RecordExpr
 | CallExpr
 | IndexExpr
 | MethodCallExpr