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

Hasn't fixed tests yet.

2 files changed, 808 insertions, 26 deletions

diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs
index 745a25862..45b788bdb 100644
--- a/xtask/src/codegen/gen_syntax.rs
+++ b/xtask/src/codegen/gen_syntax.rs
@@ -3,34 +3,43 @@
 //! Specifically, it generates the `SyntaxKind` enum and a number of newtype
 //! wrappers around `SyntaxNode` which implement `ra_syntax::AstNode`.
 
-use std::{collections::HashSet, fmt::Write};
+use std::{
+    collections::{BTreeSet, HashSet},
+    fmt::Write,
+};
 
 use proc_macro2::{Punct, Spacing};
 use quote::{format_ident, quote};
+use ungrammar::{Grammar, Rule};
 
 use crate::{
-    ast_src::{AstSrc, Field, FieldSrc, KindsSrc, AST_SRC, KINDS_SRC},
+    ast_src::{AstEnumSrc, AstNodeSrc, AstSrc, Cardinality, Field, KindsSrc, KINDS_SRC},
     codegen::{self, update, Mode},
     project_root, Result,
 };
 
 pub fn generate_syntax(mode: Mode) -> Result<()> {
+    let grammar = include_str!("rust.ungram")
+        .parse::<Grammar>()
+        .unwrap_or_else(|err| panic!("\n    \x1b[91merror\x1b[0m: {}\n", err));
+    let ast = lower(&grammar);
+
     let syntax_kinds_file = project_root().join(codegen::SYNTAX_KINDS);
     let syntax_kinds = generate_syntax_kinds(KINDS_SRC)?;
     update(syntax_kinds_file.as_path(), &syntax_kinds, mode)?;
 
     let ast_tokens_file = project_root().join(codegen::AST_TOKENS);
-    let contents = generate_tokens(AST_SRC)?;
+    let contents = generate_tokens(&ast)?;
     update(ast_tokens_file.as_path(), &contents, mode)?;
 
     let ast_nodes_file = project_root().join(codegen::AST_NODES);
-    let contents = generate_nodes(KINDS_SRC, AST_SRC)?;
+    let contents = generate_nodes(KINDS_SRC, &ast)?;
     update(ast_nodes_file.as_path(), &contents, mode)?;
 
     Ok(())
 }
 
-fn generate_tokens(grammar: AstSrc<'_>) -> Result<String> {
+fn generate_tokens(grammar: &AstSrc) -> Result<String> {
     let tokens = grammar.tokens.iter().map(|token| {
         let name = format_ident!("{}", token);
         let kind = format_ident!("{}", to_upper_snake_case(token));
@@ -62,13 +71,13 @@ fn generate_tokens(grammar: AstSrc<'_>) -> Result<String> {
     Ok(pretty)
 }
 
-fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
+fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> Result<String> {
     let (node_defs, node_boilerplate_impls): (Vec<_>, Vec<_>) = grammar
         .nodes
         .iter()
         .map(|node| {
             let name = format_ident!("{}", node.name);
-            let kind = format_ident!("{}", to_upper_snake_case(node.name));
+            let kind = format_ident!("{}", to_upper_snake_case(&node.name));
             let traits = node.traits.iter().map(|trait_name| {
                 let trait_name = format_ident!("{}", trait_name);
                 quote!(impl ast::#trait_name for #name {})
@@ -192,8 +201,8 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
         })
         .unzip();
 
-    let enum_names = grammar.enums.iter().map(|it| it.name);
-    let node_names = grammar.nodes.iter().map(|it| it.name);
+    let enum_names = grammar.enums.iter().map(|it| &it.name);
+    let node_names = grammar.nodes.iter().map(|it| &it.name);
 
     let display_impls =
         enum_names.chain(node_names.clone()).map(|it| format_ident!("{}", it)).map(|name| {
@@ -212,9 +221,11 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
         .nodes
         .iter()
         .map(|kind| to_pascal_case(kind))
-        .filter(|name| !defined_nodes.contains(name.as_str()))
+        .filter(|name| !defined_nodes.iter().any(|&it| it == name))
     {
-        eprintln!("Warning: node {} not defined in ast source", node);
+        drop(node)
+        // TODO: restore this
+        // eprintln!("Warning: node {} not defined in ast source", node);
     }
 
     let ast = quote! {
@@ -236,12 +247,12 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
     let mut res = String::with_capacity(ast.len() * 2);
 
     let mut docs =
-        grammar.nodes.iter().map(|it| it.doc).chain(grammar.enums.iter().map(|it| it.doc));
+        grammar.nodes.iter().map(|it| &it.doc).chain(grammar.enums.iter().map(|it| &it.doc));
 
     for chunk in ast.split("# [ pretty_doc_comment_placeholder_workaround ]") {
         res.push_str(chunk);
         if let Some(doc) = docs.next() {
-            write_doc_comment(doc, &mut res);
+            write_doc_comment(&doc, &mut res);
         }
     }
 
@@ -249,7 +260,7 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> {
     Ok(pretty)
 }
 
-fn write_doc_comment(contents: &[&str], dest: &mut String) {
+fn write_doc_comment(contents: &[String], dest: &mut String) {
     for line in contents {
         writeln!(dest, "///{}", line).unwrap();
     }
@@ -296,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 {
@@ -363,6 +374,7 @@ fn generate_syntax_kinds(grammar: KindsSrc<'_>) -> Result<String> {
             #([#all_keywords_idents] => { $crate::SyntaxKind::#all_keywords };)*
             [lifetime] => { $crate::SyntaxKind::LIFETIME };
             [ident] => { $crate::SyntaxKind::IDENT };
+            [shebang] => { $crate::SyntaxKind::SHEBANG };
         }
     };
 
@@ -413,9 +425,13 @@ fn to_pascal_case(s: &str) -> String {
     buf
 }
 
-impl Field<'_> {
+fn pluralize(s: &str) -> String {
+    format!("{}s", s)
+}
+
+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 {
@@ -429,7 +445,7 @@ impl Field<'_> {
     fn method_name(&self) -> proc_macro2::Ident {
         match self {
             Field::Token(name) => {
-                let name = match *name {
+                let name = match name.as_str() {
                     ";" => "semicolon",
                     "->" => "thin_arrow",
                     "'{'" => "l_curly",
@@ -448,29 +464,251 @@ impl Field<'_> {
                     "." => "dot",
                     ".." => "dotdot",
                     "..." => "dotdotdot",
+                    "..=" => "dotdoteq",
                     "=>" => "fat_arrow",
                     "@" => "at",
                     ":" => "colon",
                     "::" => "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),
         }
     }
 }
+
+fn lower(grammar: &Grammar) -> AstSrc {
+    let mut res = AstSrc::default();
+    res.tokens = vec!["Whitespace".into(), "Comment".into(), "String".into(), "RawString".into()];
+
+    let nodes = grammar
+        .iter()
+        .filter(|&node| match grammar[node].rule {
+            Rule::Node(it) if it == node => false,
+            _ => true,
+        })
+        .collect::<Vec<_>>();
+
+    for &node in &nodes {
+        let name = grammar[node].name.clone();
+        let rule = &grammar[node].rule;
+        match lower_enum(grammar, rule) {
+            Some(variants) => {
+                let enum_src = AstEnumSrc { doc: Vec::new(), name, traits: Vec::new(), variants };
+                res.enums.push(enum_src);
+            }
+            None => {
+                let mut fields = Vec::new();
+                lower_rule(&mut fields, grammar, None, rule);
+                res.nodes.push(AstNodeSrc { doc: Vec::new(), name, traits: Vec::new(), fields });
+            }
+        }
+    }
+
+    deduplicate_fields(&mut res);
+    extract_enums(&mut res);
+    extract_struct_traits(&mut res);
+    extract_enum_traits(&mut res);
+    res
+}
+
+fn lower_enum(grammar: &Grammar, rule: &Rule) -> Option<Vec<String>> {
+    let alternatives = match rule {
+        Rule::Alt(it) => it,
+        _ => return None,
+    };
+    let mut variants = Vec::new();
+    for alternative in alternatives {
+        match alternative {
+            Rule::Node(it) => variants.push(grammar[*it].name.clone()),
+            _ => return None,
+        }
+    }
+    Some(variants)
+}
+
+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 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) {
+                    name = format!("'{}'", name);
+                }
+                let field = Field::Token(name);
+                acc.push(field);
+            }
+        }
+        Rule::Rep(inner) => {
+            if let Rule::Node(node) = &**inner {
+                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: 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, label, rule)
+            }
+        }
+        Rule::Opt(rule) => lower_rule(acc, grammar, label, rule),
+    }
+}
+
+// (T (',' T)* ','?)
+fn lower_comma_list(
+    acc: &mut Vec<Field>,
+    grammar: &Grammar,
+    label: Option<&String>,
+    rule: &Rule,
+) -> bool {
+    let rule = match rule {
+        Rule::Seq(it) => it,
+        _ => return false,
+    };
+    let (node, repeat, trailing_comma) = match rule.as_slice() {
+        [Rule::Node(node), Rule::Rep(repeat), Rule::Opt(trailing_comma)] => {
+            (node, repeat, trailing_comma)
+        }
+        _ => return false,
+    };
+    let repeat = match &**repeat {
+        Rule::Seq(it) => it,
+        _ => return false,
+    };
+    match repeat.as_slice() {
+        [comma, Rule::Node(n)] if comma == &**trailing_comma && n == node => (),
+        _ => return false,
+    }
+    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
+}
+
+fn deduplicate_fields(ast: &mut AstSrc) {
+    for node in &mut ast.nodes {
+        let mut i = 0;
+        'outer: while i < node.fields.len() {
+            for j in 0..i {
+                let f1 = &node.fields[i];
+                let f2 = &node.fields[j];
+                if f1 == f2 {
+                    node.fields.remove(i);
+                    continue 'outer;
+                }
+            }
+            i += 1;
+        }
+    }
+}
+
+fn extract_enums(ast: &mut AstSrc) {
+    for node in &mut ast.nodes {
+        for enm in &ast.enums {
+            let mut to_remove = Vec::new();
+            for (i, field) in node.fields.iter().enumerate() {
+                let ty = field.ty().to_string();
+                if enm.variants.iter().any(|it| it == &ty) {
+                    to_remove.push(i);
+                }
+            }
+            if to_remove.len() == enm.variants.len() {
+                node.remove_field(to_remove);
+                let ty = enm.name.clone();
+                let name = to_lower_snake_case(&ty);
+                node.fields.push(Field::Node { name, ty, cardinality: Cardinality::Optional });
+            }
+        }
+    }
+}
+
+fn extract_struct_traits(ast: &mut AstSrc) {
+    let traits: &[(&str, &[&str])] = &[
+        ("AttrsOwner", &["attrs"]),
+        ("NameOwner", &["name"]),
+        ("VisibilityOwner", &["visibility"]),
+        ("GenericParamsOwner", &["generic_param_list", "where_clause"]),
+        ("TypeBoundsOwner", &["type_bound_list", "colon_token"]),
+        ("ModuleItemOwner", &["items"]),
+        ("LoopBodyOwner", &["label", "loop_body"]),
+        ("ArgListOwner", &["arg_list"]),
+    ];
+
+    for node in &mut ast.nodes {
+        for (name, methods) in traits {
+            extract_struct_trait(node, name, methods);
+        }
+    }
+}
+
+fn extract_struct_trait(node: &mut AstNodeSrc, trait_name: &str, methods: &[&str]) {
+    let mut to_remove = Vec::new();
+    for (i, field) in node.fields.iter().enumerate() {
+        let method_name = field.method_name().to_string();
+        if methods.iter().any(|&it| it == &method_name) {
+            to_remove.push(i);
+        }
+    }
+    if to_remove.len() == methods.len() {
+        node.traits.push(trait_name.to_string());
+        node.remove_field(to_remove);
+    }
+}
+
+fn extract_enum_traits(ast: &mut AstSrc) {
+    for enm in &mut ast.enums {
+        let nodes = &ast.nodes;
+        let mut variant_traits = enm
+            .variants
+            .iter()
+            .map(|var| nodes.iter().find(|it| &it.name == var).unwrap())
+            .map(|node| node.traits.iter().cloned().collect::<BTreeSet<_>>());
+
+        let mut enum_traits = match variant_traits.next() {
+            Some(it) => it,
+            None => continue,
+        };
+        for traits in variant_traits {
+            enum_traits = enum_traits.intersection(&traits).cloned().collect();
+        }
+        enm.traits = enum_traits.into_iter().collect();
+    }
+}
+
+impl AstNodeSrc {
+    fn remove_field(&mut self, to_remove: Vec<usize>) {
+        to_remove.into_iter().rev().for_each(|idx| {
+            self.fields.remove(idx);
+        });
+    }
+}
diff --git a/xtask/src/codegen/rust.ungram b/xtask/src/codegen/rust.ungram
new file mode 100644
index 000000000..375df301f
--- /dev/null
+++ b/xtask/src/codegen/rust.ungram
@@ -0,0 +1,544 @@
+SourceFile =
+  'shebang'?
+  Attr*
+  Item*
+
+Item =
+  Const
+| Enum
+| ExternBlock
+| ExternCrate
+| Fn
+| Impl
+| MacroCall
+| Module
+| Static
+| Struct
+| Trait
+| TypeAlias
+| Union
+| Use
+
+Module =
+  Attr* Visibility? 'mod' Name
+  (ItemList | ';')
+
+ItemList =
+  '{' Attr* Item* '}'
+
+ExternCrate =
+  Attr* Visibility? 'extern' 'crate' (NameRef | 'self') Rename? ';'
+
+Rename =
+  'as' (Name | '_')
+
+Use =
+  Attr* Visibility? 'use' UseTree ';'
+
+UseTree =
+  (Path? '::')? ('*' | UseTreeList )
+| Path Rename?
+
+UseTreeList =
+  '{' (UseTree (',' UseTree)* ','?)? '}'
+
+Fn =
+ Attr* Visibility?
+ 'default'? ('async' | 'const')? 'unsafe'? Abi?
+ 'fn' Name GenericParamList? ParamList RetType?
+ WhereClause?
+ (body:BlockExpr | ';')
+
+Abi =
+  'extern' 'string'?
+
+ParamList =
+  '('(
+    SelfParam
+  | (SelfParam ',')? (Param (',' Param)* ','?)?
+  )')'
+
+SelfParam =
+  Attr* (
+    ('&' 'lifetime'?)? 'mut'? 'self'
+  | 'mut'? 'self' ':' ty:TypeRef
+  )
+
+Param =
+  Attr* (
+    Pat (':' ty:TypeRef)
+  | ty:TypeRef
+  | '...'
+  )
+
+RetType =
+  '->' ty:TypeRef
+
+TypeAlias =
+  Attr* Visibility? 'default'? 'type' Name GenericParamList? (':' TypeBoundList?)? WhereClause?
+  '=' ty:TypeRef ';'
+
+Struct =
+  Attr* Visibility? 'struct' Name GenericParamList? (
+    WhereClause?  (RecordFieldList | ';')
+  | TupleFieldList WhereClause? ';'
+  )
+
+RecordFieldList =
+ '{' fields:(RecordField (',' RecordField)* ','?)? '}'
+
+RecordField =
+  Attr* Visibility? Name ':' ty:TypeRef
+
+TupleFieldList =
+  '(' fields:(TupleField (',' TupleField)* ','?)? ')'
+
+TupleField =
+  Attr* Visibility? ty:TypeRef
+
+FieldList =
+  RecordFieldList
+| TupleFieldList
+
+Enum =
+  Attr* Visibility? 'enum' Name GenericParamList? WhereClause?
+  VariantList
+
+VariantList =
+ '{' (Variant (',' Variant)* ','?)? '}'
+
+Variant =
+  Attr* Visibility? Name FieldList ('=' Expr)?
+
+Union =
+  Attr* Visibility? 'union' Name GenericParamList? WhereClause?
+  RecordFieldList
+
+Const =
+  Attr* Visibility? 'default'? 'const' (Name | '_') ':' ty:TypeRef
+  '=' body:Expr ';'
+
+Static =
+  Attr* Visibility? 'static'? 'mut'? Name ':' ty:TypeRef
+  '=' body:Expr ';'
+
+Trait =
+  Attr* Visibility? 'unsafe'? 'auto'? 'trait' Name GenericParamList
+  (':' TypeBoundList?)? WhereClause
+  AssocItemList
+
+AssocItemList =
+  '{' Attr* AssocItem* '}'
+
+AssocItem =
+  Fn
+| TypeAlias
+| Const
+| MacroCall
+
+Impl =
+ Attr* Visibility?
+ 'default'? 'unsafe'? 'impl' 'const'? GenericParamList? (
+   TypeRef
+ | '!'? TypeRef 'for' TypeRef
+ ) WhereClause?
+ AssocItemList
+
+ExternBlock =
+  Attr* Abi ExternItemList
+
+ExternItemList =
+  '{' Attr* ExternItem* '}'
+
+ExternItem =
+  Fn | Static | MacroCall
+
+GenericParamList =
+  '<' (GenericParam (',' GenericParam)* ','?)? '>'
+
+GenericParam =
+  LifetimeParam
+| TypeParam
+| ConstParam
+
+TypeParam =
+  Attr* Name (':' TypeBoundList?)?
+  ('=' default_type:TypeRef)?
+
+ConstParam =
+  Attr* 'const' Name ':' ty:TypeRef
+  ('=' default_val:Expr)?
+
+LifetimeParam =
+  Attr* 'lifetime'
+
+Visibility =
+  'pub' ('('
+    'super'
+  | 'self'
+  | 'crate'
+  | 'in' Path
+  ')')?
+
+Attr =
+  '#' '!'? '[' Path ('=' Literal | TokenTree)? ']'
+
+ParenType =
+  '(' ty:TypeRef ')'
+
+TupleType =
+  '(' fields:TypeRef* ')'
+
+NeverType =
+  '!'
+
+PathType =
+  Path
+
+PointerType =
+  '*' ('const' | 'mut') ty:TypeRef
+
+ArrayType =
+  '[' ty:TypeRef ';' Expr ']'
+
+SliceType =
+  '[' ty:TypeRef ']'
+
+ReferenceType =
+  '&' 'lifetime'? 'mut'? ty:TypeRef
+
+PlaceholderType =
+   '_'
+
+FnPointerType =
+   Abi 'unsafe'? 'fn' ParamList RetType?
+
+ForType =
+   'for' GenericParamList ty:TypeRef
+
+ImplTraitType =
+  'impl' TypeBoundList
+
+DynTraitType =
+  'dyn' TypeBoundList
+
+TupleExpr =
+  Attr* '(' Expr* ')'
+
+ArrayExpr =
+  Attr* '[' (Expr* | Expr ';' Expr) ']'
+
+ParenExpr =
+  Attr* '(' Expr ')'
+
+PathExpr =
+  Path
+
+LambdaExpr =
+  Attr* 'static'? 'async'? 'move'?  ParamList RetType?
+  body:Expr
+
+IfExpr =
+  Attr* 'if' Condition
+
+Condition =
+  'let' Pat '=' Expr
+| Expr
+
+EffectExpr =
+  Attr* Label? ('try' | 'unsafe' | 'async') BlockExpr
+
+LoopExpr =
+  Attr* Label? 'loop'
+  loop_body:BlockExpr?
+
+ForExpr =
+  Attr* Label? 'for' Pat 'in' iterable:Expr
+  loop_body:BlockExpr?
+
+WhileExpr =
+  Attr* Label? 'while' Condition
+  loop_body:BlockExpr?
+
+ContinueExpr =
+  Attr* 'continue' 'lifetime'?
+
+BreakExpr =
+  Attr* 'break' 'lifetime'? Expr?
+
+Label =
+  'lifetime'
+
+BlockExpr =
+  Attr* Label
+  '{'
+    Item*
+    statements:Stmt*
+    Expr?
+  '}'
+
+ReturnExpr =
+  Attr* 'return' Expr
+
+CallExpr =
+  Attr* Expr ArgList
+
+MethodCallExpr =
+  Attr* Expr '.' NameRef TypeArgList? ArgList
+
+ArgList =
+  '(' args:Expr* ')'
+
+FieldExpr =
+  Attr* Expr '.' NameRef
+
+IndexExpr =
+  Attr* '[' ']'
+
+AwaitExpr =
+  Attr* Expr '.' 'await'
+
+TryExpr =
+  Attr* Expr '?'
+
+CastExpr =
+  Attr* Expr 'as' ty:TypeRef
+
+RefExpr =
+  Attr* '&' ('raw' | 'mut' | 'const') Expr
+
+PrefixExpr =
+  Attr* Expr
+
+BoxExpr =
+  Attr* 'box' Expr
+
+RangeExpr =
+  Attr*
+
+BinExpr =
+  Attr*
+
+Literal =
+  'int_number'
+
+MatchExpr =
+  Attr* 'match' Expr MatchArmList
+
+MatchArmList =
+  '{' arms:MatchArm* '}'
+
+MatchArm =
+  Attr* Pat guard:MatchGuard? '=>' Expr
+
+MatchGuard =
+  'if' Expr
+
+RecordExpr =
+ Path RecordExprFieldList
+
+RecordExprFieldList =
+  '{'
+    fields:RecordExprField*
+    ('..' spread:Expr)?
+  '}'
+
+RecordExprField =
+  Attr* NameRef (':' Expr)?
+
+OrPat =
+  Pat*
+
+ParenPat =
+  '(' Pat ')'
+
+RefPat =
+  '&' 'mut'? Pat
+
+BoxPat =
+  'box' Path
+
+BindPat =
+  Attr* 'ref'? 'mut'? Name ('@' Pat)?
+
+PlaceholderPat =
+  '_'
+
+DotDotPat =
+  '..'
+
+PathPat =
+  Path
+
+SlicePat =
+  '[' args:Pat* ']'
+
+RangePat =
+  '..' | '..='
+
+LiteralPat =
+  Literal
+
+MacroPat =
+  MacroCall
+
+RecordPat =
+  Path RecordFieldPatList
+
+RecordFieldPatList =
+  '{'
+    record_field_pats:RecordFieldPat*
+    BindPat*
+    '..'?
+  '}'
+
+RecordFieldPat =
+  Attr* NameRef ':' Pat
+
+TupleStructPat =
+   Path '(' args:Pat* ')'
+
+TuplePat =
+   '(' args:Pat* ')'
+
+Name =
+  'ident'
+
+NameRef =
+  'ident' | 'int_number'
+
+MacroCall =
+  Attr* Path '!' Name? TokenTree ';'?
+
+MacroDef =
+  Name TokenTree
+
+TokenTree =
+  '(' ')' | '{' '}' | '[' ']'
+
+MacroItems =
+  Item*
+
+MacroStmts =
+  statements:Stmt*
+  Expr?
+
+TypeBound =
+  'lifetime' | 'const'? TypeRef
+
+TypeBoundList =
+   bounds:TypeBound*
+
+WherePred =
+  ('for' GenericParamList)?  ('lifetime' | TypeRef) ':' TypeBoundList
+
+WhereClause =
+  'where' predicates:WherePred*
+
+ExprStmt =
+  Attr* Expr ';'
+
+LetStmt =
+  Attr* 'let' Pat (':' ty:TypeRef)
+  '=' initializer:Expr ';'
+
+Path =
+  (qualifier:Path '::')? segment:PathSegment
+
+PathSegment =
+  '::' | 'crate' | 'self' | 'super'
+| '<' NameRef TypeArgList ParamList RetType PathType '>'
+
+TypeArgList =
+  '::'? '<'
+    TypeArg*
+    LifetimeArg*
+    AssocTypeArg*
+    ConstArg*
+  '>'
+
+TypeArg =
+  TypeRef
+
+AssocTypeArg =
+  NameRef (':' TypeBoundList | '=' TypeRef)
+
+LifetimeArg =
+  'lifetime'
+
+ConstArg =
+  Literal | BlockExpr BlockExpr
+
+AdtDef =
+  Struct
+| Enum
+| Union
+
+TypeRef =
+  ParenType
+| TupleType
+| NeverType
+| PathType
+| PointerType
+| ArrayType
+| SliceType
+| ReferenceType
+| PlaceholderType
+| FnPointerType
+| ForType
+| ImplTraitType
+| DynTraitType
+
+Stmt =
+  LetStmt
+| ExprStmt
+
+Pat =
+  OrPat
+| ParenPat
+| RefPat
+| BoxPat
+| BindPat
+| PlaceholderPat
+| DotDotPat
+| PathPat
+| RecordPat
+| TupleStructPat
+| TuplePat
+| SlicePat
+| RangePat
+| LiteralPat
+| MacroPat
+
+Expr =
+  TupleExpr
+| ArrayExpr
+| ParenExpr
+| PathExpr
+| LambdaExpr
+| IfExpr
+| LoopExpr
+| ForExpr
+| WhileExpr
+| ContinueExpr
+| BreakExpr
+| Label
+| BlockExpr
+| ReturnExpr
+| MatchExpr
+| RecordExpr
+| CallExpr
+| IndexExpr
+| MethodCallExpr
+| FieldExpr
+| AwaitExpr
+| TryExpr
+| EffectExpr
+| CastExpr
+| RefExpr
+| PrefixExpr
+| RangeExpr
+| BinExpr
+| Literal
+| MacroCall
+| BoxExpr