9 files changed, 68 insertions, 40 deletions

diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs
index be0cd5661..caedeead0 100644
--- a/crates/ra_parser/src/grammar.rs
+++ b/crates/ra_parser/src/grammar.rs
@@ -18,9 +18,10 @@
 //! // fn foo() {}
 //! ```
 //!
-//! After adding a new inline-test, run `cargo collect-tests` to extract
-//! it as a standalone text-fixture into `tests/data/parser/inline`, and
-//! run `cargo test` once to create the "gold" value.
+//! After adding a new inline-test, run `cargo xtask codegen` to
+//! extract it as a standalone text-fixture into
+//! `crates/ra_syntax/test_data/parser/`, and run `cargo test` once to
+//! create the "gold" value.
 //!
 //! Coding convention: rules like `where_clause` always produce either a
 //! node or an error, rules like `opt_where_clause` may produce nothing.
@@ -72,10 +73,7 @@ pub(crate) mod fragments {
     // Parse a meta item , which excluded [], e.g : #[ MetaItem ]
     pub(crate) fn meta_item(p: &mut Parser) {
         fn is_delimiter(p: &mut Parser) -> bool {
-            match p.current() {
-                T!['{'] | T!['('] | T!['['] => true,
-                _ => false,
-            }
+            matches!(p.current(), T!['{'] | T!['('] | T!['['])
         }
 
         if is_delimiter(p) {
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index d6e8df32a..6e72eea66 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -50,10 +50,8 @@ fn expr_no_struct(p: &mut Parser) {
 }
 
 fn is_expr_stmt_attr_allowed(kind: SyntaxKind) -> bool {
-    match kind {
-        BIN_EXPR | RANGE_EXPR | IF_EXPR => false,
-        _ => true,
-    }
+    let forbid = matches!(kind, BIN_EXPR | RANGE_EXPR);
+    !forbid
 }
 
 pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
diff --git a/crates/ra_parser/src/grammar/items.rs b/crates/ra_parser/src/grammar/items.rs
index 67a924de5..97642bc24 100644
--- a/crates/ra_parser/src/grammar/items.rs
+++ b/crates/ra_parser/src/grammar/items.rs
@@ -118,7 +118,22 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker, flavor: ItemFlavor) -> Resul
         && p.at_contextual_kw("default")
         && (match p.nth(1) {
             T![impl] => true,
-            T![fn] | T![type] => {
+            T![unsafe] => {
+                // test default_unsafe_impl
+                // default unsafe impl Foo {}
+
+                // test default_unsafe_fn
+                // impl T for Foo {
+                //     default unsafe fn foo() {}
+                // }
+                if p.nth(2) == T![impl] || p.nth(2) == T![fn] {
+                    p.bump_remap(T![default]);
+                    p.bump(T![unsafe]);
+                    has_mods = true;
+                }
+                false
+            }
+            T![fn] | T![type] | T![const] => {
                 if let ItemFlavor::Mod = flavor {
                     true
                 } else {
@@ -198,6 +213,9 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker, flavor: ItemFlavor) -> Resul
         //     default type T = Bar;
         //     default fn foo() {}
         // }
+        T![const] => {
+            consts::const_def(p, m);
+        }
 
         // test unsafe_default_impl
         // unsafe default impl Foo {}
diff --git a/crates/ra_parser/src/grammar/paths.rs b/crates/ra_parser/src/grammar/paths.rs
index 332acc1a0..b503af1dc 100644
--- a/crates/ra_parser/src/grammar/paths.rs
+++ b/crates/ra_parser/src/grammar/paths.rs
@@ -3,7 +3,7 @@
 use super::*;
 
 pub(super) const PATH_FIRST: TokenSet =
-    token_set![IDENT, SELF_KW, SUPER_KW, CRATE_KW, COLON, L_ANGLE];
+    token_set![IDENT, T![self], T![super], T![crate], T![:], T![<]];
 
 pub(super) fn is_path_start(p: &Parser) -> bool {
     is_use_path_start(p) || p.at(T![<])
@@ -41,10 +41,7 @@ fn path(p: &mut Parser, mode: Mode) {
     path_segment(p, mode, true);
     let mut qual = path.complete(p, PATH);
     loop {
-        let use_tree = match p.nth(2) {
-            T![*] | T!['{'] => true,
-            _ => false,
-        };
+        let use_tree = matches!(p.nth(2), T![*] | T!['{']);
         if p.at(T![::]) && !use_tree {
             let path = qual.precede(p);
             p.bump(T![::]);
@@ -73,8 +70,10 @@ fn path_segment(p: &mut Parser, mode: Mode, first: bool) {
         }
         p.expect(T![>]);
     } else {
+        let mut empty = true;
         if first {
             p.eat(T![::]);
+            empty = false;
         }
         match p.current() {
             IDENT => {
@@ -86,6 +85,12 @@ fn path_segment(p: &mut Parser, mode: Mode, first: bool) {
             T![self] | T![super] | T![crate] => p.bump_any(),
             _ => {
                 p.err_recover("expected identifier", items::ITEM_RECOVERY_SET);
+                if empty {
+                    // test_err empty_segment
+                    // use crate::;
+                    m.abandon(p);
+                    return;
+                }
             }
         };
     }
diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs
index 68fb2fc73..427c0eb49 100644
--- a/crates/ra_parser/src/grammar/patterns.rs
+++ b/crates/ra_parser/src/grammar/patterns.rs
@@ -4,7 +4,7 @@ use super::*;
 
 pub(super) const PATTERN_FIRST: TokenSet = expressions::LITERAL_FIRST
     .union(paths::PATH_FIRST)
-    .union(token_set![BOX_KW, REF_KW, MUT_KW, L_PAREN, L_BRACK, AMP, UNDERSCORE, MINUS, DOT]);
+    .union(token_set![T![box], T![ref], T![mut], T!['('], T!['['], T![&], T![_], T![-], T![.]]);
 
 pub(crate) fn pattern(p: &mut Parser) {
     pattern_r(p, PAT_RECOVERY_SET);
@@ -88,7 +88,9 @@ fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
             _ => bind_pat(p, true),
         },
 
-        _ if paths::is_use_path_start(p) => path_or_macro_pat(p),
+        // test type_path_in_pattern
+        // fn main() { let <_>::Foo = (); }
+        _ if paths::is_path_start(p) => path_or_macro_pat(p),
         _ if is_literal_pat_start(p) => literal_pat(p),
 
         T![.] if p.at(T![..]) => dot_dot_pat(p),
@@ -138,7 +140,7 @@ fn literal_pat(p: &mut Parser) -> CompletedMarker {
 //     let Bar(..) = ();
 // }
 fn path_or_macro_pat(p: &mut Parser) -> CompletedMarker {
-    assert!(paths::is_use_path_start(p));
+    assert!(paths::is_path_start(p));
     let m = p.start();
     paths::expr_path(p);
     let kind = match p.current() {
diff --git a/crates/ra_parser/src/grammar/type_params.rs b/crates/ra_parser/src/grammar/type_params.rs
index 50e4900c3..d1330d4b9 100644
--- a/crates/ra_parser/src/grammar/type_params.rs
+++ b/crates/ra_parser/src/grammar/type_params.rs
@@ -169,10 +169,7 @@ fn is_where_predicate(p: &mut Parser) -> bool {
 }
 
 fn is_where_clause_end(p: &mut Parser) -> bool {
-    match p.current() {
-        T!['{'] | T![;] | T![=] => true,
-        _ => false,
-    }
+    matches!(p.current(), T!['{'] | T![;] | T![=])
 }
 
 fn where_predicate(p: &mut Parser) {
@@ -191,10 +188,14 @@ fn where_predicate(p: &mut Parser) {
         }
         _ => {
             // test where_pred_for
-            // fn test<F>()
+            // fn for_trait<F>()
             // where
             //    for<'a> F: Fn(&'a str)
             // { }
+            if p.at(T![for]) {
+                types::for_binder(p);
+            }
+
             types::type_(p);
 
             if p.at(T![:]) {
diff --git a/crates/ra_parser/src/grammar/types.rs b/crates/ra_parser/src/grammar/types.rs
index fe1a039cb..9e8e3bd97 100644
--- a/crates/ra_parser/src/grammar/types.rs
+++ b/crates/ra_parser/src/grammar/types.rs
@@ -216,19 +216,21 @@ pub(super) fn for_binder(p: &mut Parser) {
 
 // test for_type
 // type A = for<'a> fn() -> ();
-// fn foo<T>(_t: &T) where for<'a> &'a T: Iterator {}
-// fn bar<T>(_t: &T) where for<'a> &'a mut T: Iterator {}
-// fn baz<T>(_t: &T) where for<'a> <&'a T as Baz>::Foo: Iterator {}
+// type B = for<'a> unsafe extern "C" fn(&'a ()) -> ();
+// type Obj = for<'a> PartialEq<&'a i32>;
 pub(super) fn for_type(p: &mut Parser) {
     assert!(p.at(T![for]));
     let m = p.start();
     for_binder(p);
     match p.current() {
-        T![fn] | T![unsafe] | T![extern] => fn_pointer_type(p),
-        T![&] => reference_type(p),
-        _ if paths::is_path_start(p) => path_type_(p, false),
-        _ => p.error("expected a path"),
+        T![fn] | T![unsafe] | T![extern] => {}
+        // OK: legacy trait object format
+        _ if paths::is_use_path_start(p) => {}
+        _ => {
+            p.error("expected a function pointer or path");
+        }
     }
+    type_no_bounds(p);
     m.complete(p, FOR_TYPE);
 }
 
diff --git a/crates/ra_parser/src/parser.rs b/crates/ra_parser/src/parser.rs
index 4f59b0a23..d797f2cc9 100644
--- a/crates/ra_parser/src/parser.rs
+++ b/crates/ra_parser/src/parser.rs
@@ -127,17 +127,24 @@ impl<'t> Parser<'t> {
 
     fn at_composite2(&self, n: usize, k1: SyntaxKind, k2: SyntaxKind) -> bool {
         let t1 = self.token_source.lookahead_nth(n);
+        if t1.kind != k1 || !t1.is_jointed_to_next {
+            return false;
+        }
         let t2 = self.token_source.lookahead_nth(n + 1);
-        t1.kind == k1 && t1.is_jointed_to_next && t2.kind == k2
+        t2.kind == k2
     }
 
     fn at_composite3(&self, n: usize, k1: SyntaxKind, k2: SyntaxKind, k3: SyntaxKind) -> bool {
         let t1 = self.token_source.lookahead_nth(n);
+        if t1.kind != k1 || !t1.is_jointed_to_next {
+            return false;
+        }
         let t2 = self.token_source.lookahead_nth(n + 1);
+        if t2.kind != k2 || !t2.is_jointed_to_next {
+            return false;
+        }
         let t3 = self.token_source.lookahead_nth(n + 2);
-        (t1.kind == k1 && t1.is_jointed_to_next)
-            && (t2.kind == k2 && t2.is_jointed_to_next)
-            && t3.kind == k3
+        t3.kind == k3
     }
 
     /// Checks if the current token is in `kinds`.
diff --git a/crates/ra_parser/src/syntax_kind.rs b/crates/ra_parser/src/syntax_kind.rs
index 8d6bd057b..63204436c 100644
--- a/crates/ra_parser/src/syntax_kind.rs
+++ b/crates/ra_parser/src/syntax_kind.rs
@@ -20,9 +20,6 @@ impl From<SyntaxKind> for u16 {
 
 impl SyntaxKind {
     pub fn is_trivia(self) -> bool {
-        match self {
-            SyntaxKind::WHITESPACE | SyntaxKind::COMMENT => true,
-            _ => false,
-        }
+        matches!(self, SyntaxKind::WHITESPACE | SyntaxKind::COMMENT)
     }
 }