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

6 files changed, 459 insertions, 338 deletions

diff --git a/xtask/src/codegen/gen_assists_docs.rs b/xtask/src/codegen/gen_assists_docs.rs
index 526941f73..f0ded8b87 100644
--- a/xtask/src/codegen/gen_assists_docs.rs
+++ b/xtask/src/codegen/gen_assists_docs.rs
@@ -3,7 +3,7 @@
 use std::{fmt, fs, path::Path};
 
 use crate::{
-    codegen::{self, extract_comment_blocks_with_empty_lines, Location, Mode},
+    codegen::{self, extract_comment_blocks_with_empty_lines, reformat, Location, Mode, PREAMBLE},
     project_root, rust_files, Result,
 };
 
@@ -15,7 +15,7 @@ pub fn generate_assists_tests(mode: Mode) -> Result<()> {
 pub fn generate_assists_docs(mode: Mode) -> Result<()> {
     let assists = Assist::collect()?;
     let contents = assists.into_iter().map(|it| it.to_string()).collect::<Vec<_>>().join("\n\n");
-    let contents = contents.trim().to_string() + "\n";
+    let contents = format!("//{}\n{}\n", PREAMBLE, contents.trim());
     let dst = project_root().join("docs/user/generated_assists.adoc");
     codegen::update(&dst, &contents, mode)
 }
@@ -32,7 +32,7 @@ struct Assist {
 impl Assist {
     fn collect() -> Result<Vec<Assist>> {
         let mut res = Vec::new();
-        for path in rust_files(&project_root().join(codegen::ASSISTS_DIR)) {
+        for path in rust_files(&project_root().join("crates/assists/src/handlers")) {
             collect_file(&mut res, path.as_path())?;
         }
         res.sort_by(|lhs, rhs| lhs.id.cmp(&rhs.id));
@@ -134,8 +134,8 @@ r#####"
 
         buf.push_str(&test)
     }
-    let buf = crate::reformat(buf)?;
-    codegen::update(&project_root().join(codegen::ASSISTS_TESTS), &buf, mode)
+    let buf = reformat(buf)?;
+    codegen::update(&project_root().join("crates/assists/src/tests/generated.rs"), &buf, mode)
 }
 
 fn hide_hash_comments(text: &str) -> String {
diff --git a/xtask/src/codegen/gen_feature_docs.rs b/xtask/src/codegen/gen_feature_docs.rs
index 31bc3839d..3f0013e82 100644
--- a/xtask/src/codegen/gen_feature_docs.rs
+++ b/xtask/src/codegen/gen_feature_docs.rs
@@ -3,14 +3,14 @@
 use std::{fmt, fs, path::PathBuf};
 
 use crate::{
-    codegen::{self, extract_comment_blocks_with_empty_lines, Location, Mode},
+    codegen::{self, extract_comment_blocks_with_empty_lines, Location, Mode, PREAMBLE},
     project_root, rust_files, Result,
 };
 
 pub fn generate_feature_docs(mode: Mode) -> Result<()> {
     let features = Feature::collect()?;
     let contents = features.into_iter().map(|it| it.to_string()).collect::<Vec<_>>().join("\n\n");
-    let contents = contents.trim().to_string() + "\n";
+    let contents = format!("//{}\n{}\n", PREAMBLE, contents.trim());
     let dst = project_root().join("docs/user/generated_features.adoc");
     codegen::update(&dst, &contents, mode)?;
     Ok(())
diff --git a/xtask/src/codegen/gen_features.rs b/xtask/src/codegen/gen_features.rs
new file mode 100644
index 000000000..78268308b
--- /dev/null
+++ b/xtask/src/codegen/gen_features.rs
@@ -0,0 +1,50 @@
+//! Generates descriptors structure for unstable feature from Unstable Book
+use std::path::{Path, PathBuf};
+
+use quote::quote;
+use walkdir::WalkDir;
+
+use crate::{
+    codegen::{project_root, reformat, update, Mode, Result},
+    not_bash::{fs2, run},
+};
+
+pub fn generate_features(mode: Mode) -> Result<()> {
+    if !Path::new("./target/rust").exists() {
+        run!("git clone https://github.com/rust-lang/rust ./target/rust")?;
+    }
+
+    let contents = generate_descriptor("./target/rust/src/doc/unstable-book/src".into())?;
+
+    let destination = project_root().join("crates/ide/src/completion/generated_features.rs");
+    update(destination.as_path(), &contents, mode)?;
+
+    Ok(())
+}
+
+fn generate_descriptor(src_dir: PathBuf) -> Result<String> {
+    let definitions = ["language-features", "library-features"]
+        .iter()
+        .flat_map(|it| WalkDir::new(src_dir.join(it)))
+        .filter_map(|e| e.ok())
+        .filter(|entry| {
+            // Get all `.md ` files
+            entry.file_type().is_file() && entry.path().extension().unwrap_or_default() == "md"
+        })
+        .map(|entry| {
+            let path = entry.path();
+            let feature_ident = path.file_stem().unwrap().to_str().unwrap().replace("-", "_");
+            let doc = fs2::read_to_string(path).unwrap();
+
+            quote! { LintCompletion { label: #feature_ident, description: #doc } }
+        });
+
+    let ts = quote! {
+        use crate::completion::complete_attribute::LintCompletion;
+
+        pub(super) const FEATURES:  &[LintCompletion] = &[
+            #(#definitions),*
+        ];
+    };
+    reformat(ts)
+}
diff --git a/xtask/src/codegen/gen_parser_tests.rs b/xtask/src/codegen/gen_parser_tests.rs
index 2977da2fa..96fdd9216 100644
--- a/xtask/src/codegen/gen_parser_tests.rs
+++ b/xtask/src/codegen/gen_parser_tests.rs
@@ -8,12 +8,12 @@ use std::{
 };
 
 use crate::{
-    codegen::{self, extract_comment_blocks, update, Mode},
+    codegen::{extract_comment_blocks, update, Mode},
     project_root, Result,
 };
 
 pub fn generate_parser_tests(mode: Mode) -> Result<()> {
-    let tests = tests_from_dir(&project_root().join(Path::new(codegen::GRAMMAR_DIR)))?;
+    let tests = tests_from_dir(&project_root().join(Path::new("crates/parser/src/grammar")))?;
     fn install_tests(tests: &HashMap<String, Test>, into: &str, mode: Mode) -> Result<()> {
         let tests_dir = project_root().join(into);
         if !tests_dir.is_dir() {
@@ -39,8 +39,8 @@ pub fn generate_parser_tests(mode: Mode) -> Result<()> {
         }
         Ok(())
     }
-    install_tests(&tests.ok, codegen::OK_INLINE_TESTS_DIR, mode)?;
-    install_tests(&tests.err, codegen::ERR_INLINE_TESTS_DIR, mode)
+    install_tests(&tests.ok, "crates/syntax/test_data/parser/inline/ok", mode)?;
+    install_tests(&tests.err, "crates/syntax/test_data/parser/inline/err", mode)
 }
 
 #[derive(Debug)]
diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs
index 45b788bdb..200e8aa50 100644
--- a/xtask/src/codegen/gen_syntax.rs
+++ b/xtask/src/codegen/gen_syntax.rs
@@ -1,7 +1,7 @@
 //! This module generates AST datatype used by rust-analyzer.
 //!
 //! Specifically, it generates the `SyntaxKind` enum and a number of newtype
-//! wrappers around `SyntaxNode` which implement `ra_syntax::AstNode`.
+//! wrappers around `SyntaxNode` which implement `syntax::AstNode`.
 
 use std::{
     collections::{BTreeSet, HashSet},
@@ -10,29 +10,27 @@ use std::{
 
 use proc_macro2::{Punct, Spacing};
 use quote::{format_ident, quote};
-use ungrammar::{Grammar, Rule};
+use ungrammar::{rust_grammar, Grammar, Rule};
 
 use crate::{
     ast_src::{AstEnumSrc, AstNodeSrc, AstSrc, Cardinality, Field, KindsSrc, KINDS_SRC},
-    codegen::{self, update, Mode},
+    codegen::{reformat, 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 grammar = rust_grammar();
     let ast = lower(&grammar);
 
-    let syntax_kinds_file = project_root().join(codegen::SYNTAX_KINDS);
+    let syntax_kinds_file = project_root().join("crates/parser/src/syntax_kind/generated.rs");
     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 ast_tokens_file = project_root().join("crates/syntax/src/ast/generated/tokens.rs");
     let contents = generate_tokens(&ast)?;
     update(ast_tokens_file.as_path(), &contents, mode)?;
 
-    let ast_nodes_file = project_root().join(codegen::AST_NODES);
+    let ast_nodes_file = project_root().join("crates/syntax/src/ast/generated/nodes.rs");
     let contents = generate_nodes(KINDS_SRC, &ast)?;
     update(ast_nodes_file.as_path(), &contents, mode)?;
 
@@ -63,7 +61,7 @@ fn generate_tokens(grammar: &AstSrc) -> Result<String> {
         }
     });
 
-    let pretty = crate::reformat(quote! {
+    let pretty = reformat(quote! {
         use crate::{SyntaxKind::{self, *}, SyntaxToken, ast::AstToken};
         #(#tokens)*
     })?
@@ -153,25 +151,10 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> Result<String> {
                 quote!(impl ast::#trait_name for #name {})
             });
 
-            (
+            let ast_node = if en.name == "Stmt" {
+                quote! {}
+            } else {
                 quote! {
-                    #[pretty_doc_comment_placeholder_workaround]
-                    #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-                    pub enum #name {
-                        #(#variants(#variants),)*
-                    }
-
-                    #(#traits)*
-                },
-                quote! {
-                    #(
-                    impl From<#variants> for #name {
-                        fn from(node: #variants) -> #name {
-                            #name::#variants(node)
-                        }
-                    }
-                    )*
-
                     impl AstNode for #name {
                         fn can_cast(kind: SyntaxKind) -> bool {
                             match kind {
@@ -196,6 +179,28 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> Result<String> {
                             }
                         }
                     }
+                }
+            };
+
+            (
+                quote! {
+                    #[pretty_doc_comment_placeholder_workaround]
+                    #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+                    pub enum #name {
+                        #(#variants(#variants),)*
+                    }
+
+                    #(#traits)*
+                },
+                quote! {
+                    #(
+                        impl From<#variants> for #name {
+                            fn from(node: #variants) -> #name {
+                                #name::#variants(node)
+                            }
+                        }
+                    )*
+                    #ast_node
                 },
             )
         })
@@ -256,7 +261,7 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> Result<String> {
         }
     }
 
-    let pretty = crate::reformat(res)?;
+    let pretty = reformat(res)?;
     Ok(pretty)
 }
 
@@ -378,7 +383,7 @@ fn generate_syntax_kinds(grammar: KindsSrc<'_>) -> Result<String> {
         }
     };
 
-    crate::reformat(ast)
+    reformat(ast)
 }
 
 fn to_upper_snake_case(s: &str) -> String {
@@ -472,11 +477,18 @@ impl Field {
                     "#" => "pound",
                     "?" => "question_mark",
                     "," => "comma",
+                    "|" => "pipe",
                     _ => name,
                 };
                 format_ident!("{}_token", name)
             }
-            Field::Node { name, .. } => format_ident!("{}", name),
+            Field::Node { name, .. } => {
+                if name == "type" {
+                    format_ident!("ty")
+                } else {
+                    format_ident!("{}", name)
+                }
+            }
         }
     }
     fn ty(&self) -> proc_macro2::Ident {
@@ -491,13 +503,7 @@ 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<_>>();
+    let nodes = grammar.iter().collect::<Vec<_>>();
 
     for &node in &nodes {
         let name = grammar[node].name.clone();
@@ -531,6 +537,7 @@ fn lower_enum(grammar: &Grammar, rule: &Rule) -> Option<Vec<String>> {
     for alternative in alternatives {
         match alternative {
             Rule::Node(it) => variants.push(grammar[*it].name.clone()),
+            Rule::Token(it) if grammar[*it].name == ";" => (),
             _ => return None,
         }
     }
@@ -572,6 +579,24 @@ fn lower_rule(acc: &mut Vec<Field>, grammar: &Grammar, label: Option<&String>, r
         }
         Rule::Labeled { label: l, rule } => {
             assert!(label.is_none());
+            let manually_implemented = matches!(
+                l.as_str(),
+                "lhs"
+                    | "rhs"
+                    | "then_branch"
+                    | "else_branch"
+                    | "start"
+                    | "end"
+                    | "op"
+                    | "index"
+                    | "base"
+                    | "value"
+                    | "trait"
+                    | "self_ty"
+            );
+            if manually_implemented {
+                return;
+            }
             lower_rule(acc, grammar, Some(l), rule);
         }
         Rule::Seq(rules) | Rule::Alt(rules) => {
@@ -687,6 +712,9 @@ fn extract_struct_trait(node: &mut AstNodeSrc, trait_name: &str, methods: &[&str
 
 fn extract_enum_traits(ast: &mut AstSrc) {
     for enm in &mut ast.enums {
+        if enm.name == "Stmt" {
+            continue;
+        }
         let nodes = &ast.nodes;
         let mut variant_traits = enm
             .variants
diff --git a/xtask/src/codegen/rust.ungram b/xtask/src/codegen/rust.ungram
index 375df301f..aca23890c 100644
--- a/xtask/src/codegen/rust.ungram
+++ b/xtask/src/codegen/rust.ungram
@@ -1,3 +1,63 @@
+//*************************//
+// Names, Paths and Macros //
+//*************************//
+
+Name =
+  'ident'
+
+NameRef =
+  'ident' | 'int_number'
+
+Path =
+  (qualifier:Path '::')? segment:PathSegment
+
+PathSegment =
+  'crate' | 'self' | 'super'
+| '::' NameRef
+| NameRef GenericArgList?
+| NameRef ParamList RetType?
+| '<' PathType ('as' PathType)? '>'
+
+GenericArgList =
+  '::'? '<' (GenericArg (',' GenericArg)* ','?)? '>'
+
+GenericArg =
+  TypeArg
+| AssocTypeArg
+| LifetimeArg
+| ConstArg
+
+TypeArg =
+  Type
+
+AssocTypeArg =
+  NameRef (':' TypeBoundList | '=' Type)
+
+LifetimeArg =
+  'lifetime'
+
+ConstArg =
+  Expr
+
+MacroCall =
+  Attr* Path '!' Name? TokenTree ';'?
+
+TokenTree =
+  '(' ')'
+| '{' '}'
+| '[' ']'
+
+MacroItems =
+  Item*
+
+MacroStmts =
+  statements:Stmt*
+  Expr?
+
+//*************************//
+//          Items          //
+//*************************//
+
 SourceFile =
   'shebang'?
   Attr*
@@ -61,22 +121,22 @@ ParamList =
 SelfParam =
   Attr* (
     ('&' 'lifetime'?)? 'mut'? 'self'
-  | 'mut'? 'self' ':' ty:TypeRef
+  | 'mut'? 'self' ':' Type
   )
 
 Param =
   Attr* (
-    Pat (':' ty:TypeRef)
-  | ty:TypeRef
+    Pat (':' Type)
+  | Type
   | '...'
   )
 
 RetType =
-  '->' ty:TypeRef
+  '->' Type
 
 TypeAlias =
   Attr* Visibility? 'default'? 'type' Name GenericParamList? (':' TypeBoundList?)? WhereClause?
-  '=' ty:TypeRef ';'
+  '=' Type ';'
 
 Struct =
   Attr* Visibility? 'struct' Name GenericParamList? (
@@ -88,13 +148,13 @@ RecordFieldList =
  '{' fields:(RecordField (',' RecordField)* ','?)? '}'
 
 RecordField =
-  Attr* Visibility? Name ':' ty:TypeRef
+  Attr* Visibility? Name ':' Type
 
 TupleFieldList =
   '(' fields:(TupleField (',' TupleField)* ','?)? ')'
 
 TupleField =
-  Attr* Visibility? ty:TypeRef
+  Attr* Visibility? Type
 
 FieldList =
   RecordFieldList
@@ -114,12 +174,17 @@ Union =
   Attr* Visibility? 'union' Name GenericParamList? WhereClause?
   RecordFieldList
 
+AdtDef =
+  Enum
+| Struct
+| Union
+
 Const =
-  Attr* Visibility? 'default'? 'const' (Name | '_') ':' ty:TypeRef
+  Attr* Visibility? 'default'? 'const' (Name | '_') ':' Type
   '=' body:Expr ';'
 
 Static =
-  Attr* Visibility? 'static'? 'mut'? Name ':' ty:TypeRef
+  Attr* Visibility? 'static'? 'mut'? Name ':' Type
   '=' body:Expr ';'
 
 Trait =
@@ -131,18 +196,17 @@ AssocItemList =
   '{' Attr* AssocItem* '}'
 
 AssocItem =
-  Fn
-| TypeAlias
-| Const
+  Const
+| Fn
 | MacroCall
+| TypeAlias
 
 Impl =
- Attr* Visibility?
- 'default'? 'unsafe'? 'impl' 'const'? GenericParamList? (
-   TypeRef
- | '!'? TypeRef 'for' TypeRef
- ) WhereClause?
- AssocItemList
+  Attr* Visibility?
+  'default'? 'unsafe'? 'impl' 'const'? GenericParamList?
+  ('!'? target_trait:Type 'for')? target_type:Type
+  WhereClause?
+  AssocItemList
 
 ExternBlock =
   Attr* Abi ExternItemList
@@ -157,20 +221,26 @@ GenericParamList =
   '<' (GenericParam (',' GenericParam)* ','?)? '>'
 
 GenericParam =
-  LifetimeParam
+  ConstParam
+| LifetimeParam
 | TypeParam
-| ConstParam
 
 TypeParam =
   Attr* Name (':' TypeBoundList?)?
-  ('=' default_type:TypeRef)?
+  ('=' default_type:Type)?
 
 ConstParam =
-  Attr* 'const' Name ':' ty:TypeRef
+  Attr* 'const' Name ':' Type
   ('=' default_val:Expr)?
 
 LifetimeParam =
-  Attr* 'lifetime'
+  Attr* 'lifetime' (':' TypeBoundList?)?
+
+WhereClause =
+  'where' predicates:(WherePred (',' WherePred)* ','?)
+
+WherePred =
+  ('for' GenericParamList)?  ('lifetime' | Type) ':' TypeBoundList
 
 Visibility =
   'pub' ('('
@@ -183,362 +253,335 @@ Visibility =
 Attr =
   '#' '!'? '[' Path ('=' Literal | TokenTree)? ']'
 
-ParenType =
-  '(' ty:TypeRef ')'
+//****************************//
+// Statements and Expressions //
+//****************************//
 
-TupleType =
-  '(' fields:TypeRef* ')'
+Stmt =
+  ExprStmt
+| Item
+| LetStmt
 
-NeverType =
-  '!'
+LetStmt =
+  Attr* 'let' Pat (':' Type)?
+  '=' initializer:Expr ';'
 
-PathType =
-  Path
+ExprStmt =
+  Attr* Expr ';'?
 
-PointerType =
-  '*' ('const' | 'mut') ty:TypeRef
+Expr =
+  ArrayExpr
+| AwaitExpr
+| BinExpr
+| BlockExpr
+| BoxExpr
+| BreakExpr
+| CallExpr
+| CastExpr
+| ClosureExpr
+| ContinueExpr
+| EffectExpr
+| FieldExpr
+| ForExpr
+| IfExpr
+| IndexExpr
+| Literal
+| LoopExpr
+| MacroCall
+| MatchExpr
+| MethodCallExpr
+| ParenExpr
+| PathExpr
+| PrefixExpr
+| RangeExpr
+| RecordExpr
+| RefExpr
+| ReturnExpr
+| TryExpr
+| TupleExpr
+| WhileExpr
 
-ArrayType =
-  '[' ty:TypeRef ';' Expr ']'
+Literal =
+  Attr* value:(
+    'int_number' | 'float_number'
+  | 'string' | 'raw_string'
+  | 'byte_string' | 'raw_byte_string'
+  | 'true' | 'false'
+  | 'char' | 'byte'
+  )
 
-SliceType =
-  '[' ty:TypeRef ']'
+PathExpr =
+  Attr* Path
 
-ReferenceType =
-  '&' 'lifetime'? 'mut'? ty:TypeRef
+BlockExpr =
+  '{'
+    Attr*
+    statements:Stmt*
+    Expr?
+  '}'
 
-PlaceholderType =
-   '_'
+RefExpr =
+  Attr* '&' ('raw' |'mut' | 'const') Expr
 
-FnPointerType =
-   Abi 'unsafe'? 'fn' ParamList RetType?
+TryExpr =
+  Attr* Expr '?'
 
-ForType =
-   'for' GenericParamList ty:TypeRef
+EffectExpr =
+  Attr* Label? ('try' | 'unsafe' | 'async') BlockExpr
 
-ImplTraitType =
-  'impl' TypeBoundList
+PrefixExpr =
+  Attr* op:('-' | '!' | '*') Expr
 
-DynTraitType =
-  'dyn' TypeBoundList
+BinExpr =
+  Attr*
+  lhs:Expr
+  op:(
+    '||' | '&&'
+    | '==' | '!=' | '<=' | '>=' | '<' | '>'
+    | '+' | '*' | '-' | '/' | '%' | '<<' | '>>' | '^' | '|' | '&'
+    | '=' | '+=' | '/=' | '*=' | '%=' | '>>=' | '<<=' | '-=' | '|=' | '&=' | '^='
+  )
+  rhs:Expr
 
-TupleExpr =
-  Attr* '(' Expr* ')'
+CastExpr =
+  Attr* Expr 'as' Type
+
+ParenExpr =
+  Attr* '(' Attr* Expr ')'
 
 ArrayExpr =
-  Attr* '[' (Expr* | Expr ';' Expr) ']'
+  Attr* '[' Attr* (
+    (Expr (',' Expr)* ','?)?
+  | Expr ';' Expr
+  ) ']'
 
-ParenExpr =
-  Attr* '(' Expr ')'
+IndexExpr =
+  Attr* base:Expr '[' index:Expr ']'
 
-PathExpr =
-  Path
+TupleExpr =
+  Attr* '(' Attr* fields:(Expr (',' Expr)* ','?)? ')'
+
+RecordExpr =
+  Path RecordExprFieldList
+
+RecordExprFieldList =
+  '{'
+    Attr*
+    fields:(RecordExprField (',' RecordExprField)* ','?)
+    ('..' spread:Expr)?
+  '}'
+
+RecordExprField =
+  Attr* NameRef (':' Expr)?
+
+CallExpr =
+  Attr* Expr ArgList
+
+ArgList =
+  '(' args:(Expr (',' Expr)* ','?)? ')'
+
+MethodCallExpr =
+  Attr* Expr '.' NameRef GenericArgList? ArgList
+
+FieldExpr =
+  Attr* Expr '.' NameRef
 
-LambdaExpr =
+ClosureExpr =
   Attr* 'static'? 'async'? 'move'?  ParamList RetType?
   body:Expr
 
 IfExpr =
-  Attr* 'if' Condition
+  Attr* 'if' Condition then_branch:BlockExpr
+  ('else' else_branch:(IfExpr | BlockExpr))?
 
 Condition =
   'let' Pat '=' Expr
 | Expr
 
-EffectExpr =
-  Attr* Label? ('try' | 'unsafe' | 'async') BlockExpr
-
 LoopExpr =
   Attr* Label? 'loop'
-  loop_body:BlockExpr?
+  loop_body:BlockExpr
 
 ForExpr =
   Attr* Label? 'for' Pat 'in' iterable:Expr
-  loop_body:BlockExpr?
+  loop_body:BlockExpr
 
 WhileExpr =
   Attr* Label? 'while' Condition
-  loop_body:BlockExpr?
+  loop_body:BlockExpr
 
-ContinueExpr =
-  Attr* 'continue' 'lifetime'?
+Label =
+  'lifetime'
 
 BreakExpr =
   Attr* 'break' 'lifetime'? Expr?
 
-Label =
-  'lifetime'
-
-BlockExpr =
-  Attr* Label
-  '{'
-    Item*
-    statements:Stmt*
-    Expr?
-  '}'
+ContinueExpr =
+  Attr* 'continue' 'lifetime'?
 
-ReturnExpr =
-  Attr* 'return' Expr
+RangeExpr =
+  Attr* start:Expr? op:('..' | '..=') end:Expr?
 
-CallExpr =
-  Attr* Expr ArgList
+MatchExpr =
+  Attr* 'match' Expr MatchArmList
 
-MethodCallExpr =
-  Attr* Expr '.' NameRef TypeArgList? ArgList
+MatchArmList =
+  '{'
+    Attr*
+    arms:MatchArm*
+  '}'
 
-ArgList =
-  '(' args:Expr* ')'
+MatchArm =
+  Attr* Pat guard:MatchGuard? '=>' Expr ','?
 
-FieldExpr =
-  Attr* Expr '.' NameRef
+MatchGuard =
+  'if' Expr
 
-IndexExpr =
-  Attr* '[' ']'
+ReturnExpr =
+  Attr* 'return' Expr?
 
 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*
+//*************************//
+//          Types          //
+//*************************//
 
-BinExpr =
-  Attr*
-
-Literal =
-  'int_number'
+Type =
+  ArrayType
+| DynTraitType
+| FnPointerType
+| ForType
+| ImplTraitType
+| InferType
+| NeverType
+| ParenType
+| PathType
+| PointerType
+| ReferenceType
+| SliceType
+| TupleType
 
-MatchExpr =
-  Attr* 'match' Expr MatchArmList
+ParenType =
+  '(' Type ')'
 
-MatchArmList =
-  '{' arms:MatchArm* '}'
+NeverType =
+  '!'
 
-MatchArm =
-  Attr* Pat guard:MatchGuard? '=>' Expr
+PathType =
+  Path
 
-MatchGuard =
-  'if' Expr
+TupleType =
+  '(' fields:(Type (',' Type)* ','?)? ')'
 
-RecordExpr =
- Path RecordExprFieldList
+PointerType =
+  '*' ('const' | 'mut') Type
 
-RecordExprFieldList =
-  '{'
-    fields:RecordExprField*
-    ('..' spread:Expr)?
-  '}'
+ReferenceType =
+  '&' 'lifetime'? 'mut'? Type
 
-RecordExprField =
-  Attr* NameRef (':' Expr)?
+ArrayType =
+  '[' Type ';' Expr ']'
 
-OrPat =
-  Pat*
+SliceType =
+  '[' Type ']'
 
-ParenPat =
-  '(' Pat ')'
+InferType =
+  '_'
 
-RefPat =
-  '&' 'mut'? Pat
+FnPointerType =
+  'const'? 'async'? 'unsafe'? Abi? 'fn' ParamList RetType?
 
-BoxPat =
-  'box' Path
+ForType =
+  'for' GenericParamList Type
 
-BindPat =
-  Attr* 'ref'? 'mut'? Name ('@' Pat)?
+ImplTraitType =
+  'impl' TypeBoundList
 
-PlaceholderPat =
-  '_'
+DynTraitType =
+  'dyn' TypeBoundList
 
-DotDotPat =
-  '..'
+TypeBoundList =
+  bounds:(TypeBound ('+' TypeBound)* '+'?)
 
-PathPat =
-  Path
+TypeBound =
+  'lifetime'
+| '?'? Type
 
-SlicePat =
-  '[' args:Pat* ']'
+//************************//
+//        Patterns        //
+//************************//
 
-RangePat =
-  '..' | '..='
+Pat =
+  IdentPat
+| BoxPat
+| RestPat
+| LiteralPat
+| MacroPat
+| OrPat
+| ParenPat
+| PathPat
+| WildcardPat
+| RangePat
+| RecordPat
+| RefPat
+| SlicePat
+| TuplePat
+| TupleStructPat
 
 LiteralPat =
   Literal
 
-MacroPat =
-  MacroCall
+IdentPat =
+  Attr* 'ref'? 'mut'? Name ('@' Pat)?
+
+WildcardPat =
+  '_'
+
+RangePat =
+  start:Pat op:('..' | '..=') end:Pat
+
+RefPat =
+  '&' 'mut'? Pat
 
 RecordPat =
-  Path RecordFieldPatList
+  Path RecordPatFieldList
 
-RecordFieldPatList =
+RecordPatFieldList =
   '{'
-    record_field_pats:RecordFieldPat*
-    BindPat*
+    fields:(RecordPatField (',' RecordPatField)* ','?)
     '..'?
   '}'
 
-RecordFieldPat =
-  Attr* NameRef ':' Pat
+RecordPatField =
+  Attr* (NameRef ':')? Pat
 
 TupleStructPat =
-   Path '(' args:Pat* ')'
+   Path '(' fields:(Pat (',' 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*
-  '>'
+   '(' fields:(Pat (',' Pat)* ','?)? ')'
 
-TypeArg =
-  TypeRef
-
-AssocTypeArg =
-  NameRef (':' TypeBoundList | '=' TypeRef)
-
-LifetimeArg =
-  'lifetime'
+ParenPat =
+  '(' Pat ')'
 
-ConstArg =
-  Literal | BlockExpr BlockExpr
+SlicePat =
+  '[' (Pat (',' Pat)* ','?)? ']'
 
-AdtDef =
-  Struct
-| Enum
-| Union
+PathPat =
+  Path
 
-TypeRef =
-  ParenType
-| TupleType
-| NeverType
-| PathType
-| PointerType
-| ArrayType
-| SliceType
-| ReferenceType
-| PlaceholderType
-| FnPointerType
-| ForType
-| ImplTraitType
-| DynTraitType
+OrPat =
+  (Pat ('|' Pat)* '|'?)
 
-Stmt =
-  LetStmt
-| ExprStmt
+BoxPat =
+  'box' Pat
 
-Pat =
-  OrPat
-| ParenPat
-| RefPat
-| BoxPat
-| BindPat
-| PlaceholderPat
-| DotDotPat
-| PathPat
-| RecordPat
-| TupleStructPat
-| TuplePat
-| SlicePat
-| RangePat
-| LiteralPat
-| MacroPat
+RestPat =
+  '..'
 
-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
+MacroPat =
+  MacroCall