Separating parsing of for in predicates and types

Author: matthewjasper

crates/ra_parser/src/grammar/type_params.rs

@@ -191,10 +191,30 @@ fn where_predicate(p: &mut Parser) {
         }
         _ => {
             // test where_pred_for
-            // fn test<F>()
+            // fn for_trait<F>()
             // where
             //    for<'a> F: Fn(&'a str)
             // { }
+            // fn for_ref<F>()
+            // where
+            //    for<'a> &'a F: Debug
+            // { }
+            // fn for_parens<F>()
+            // where
+            //    for<'a> (&'a F): Fn(&'a str)
+            // { }
+            // fn for_slice<F>()
+            // where
+            //    for<'a> [&'a F]: Eq
+            // { }
+            // fn for_qpath<T>(_t: &T)
+            // where
+            //     for<'a> <&'a T as Baz>::Foo: Iterator
+            // { }
+            if p.at(T![for]) {
+                types::for_binder(p);
+            }
+
             types::type_(p);
 
             if p.at(T![:]) {

crates/ra_parser/src/grammar/types.rs

@@ -216,19 +216,20 @@ 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 ()) -> ();
 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);
 }
 

crates/ra_syntax/src/ast.rs

@@ -285,6 +285,8 @@ where
     let pred = predicates.next().unwrap();
     let mut bounds = pred.type_bound_list().unwrap().bounds();
 
+    assert!(pred.for_token().is_none());
+    assert!(pred.type_param_list().is_none());
     assert_eq!("T", pred.type_ref().unwrap().syntax().text().to_string());
     assert_bound("Clone", bounds.next());
     assert_bound("Copy", bounds.next());
@@ -322,6 +324,8 @@ where
     let pred = predicates.next().unwrap();
     let mut bounds = pred.type_bound_list().unwrap().bounds();
 
-    assert_eq!("for<'a> F", pred.type_ref().unwrap().syntax().text().to_string());
+    assert!(pred.for_token().is_some());
+    assert_eq!("<'a>", pred.type_param_list().unwrap().syntax().text().to_string());
+    assert_eq!("F", pred.type_ref().unwrap().syntax().text().to_string());
     assert_bound("Fn(&'a str)", bounds.next());
 }

crates/ra_syntax/src/ast/generated/nodes.rs

@@ -2052,6 +2052,8 @@ pub struct WherePred {
 }
 impl ast::TypeBoundsOwner for WherePred {}
 impl WherePred {
+    pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
+    pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) }
     pub fn lifetime_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, T![lifetime])
     }

crates/ra_syntax/test_data/parser/err/0027_incomplere_where_for.rast

@@ -12,17 +12,16 @@ SOURCE_FILE@0..30
       WHERE_KW@13..18 "where"
       WHITESPACE@18..19 " "
       WHERE_PRED@19..26
-        FOR_TYPE@19..26
-          FOR_KW@19..22 "for"
-          TYPE_PARAM_LIST@22..26
-            L_ANGLE@22..23 "<"
-            LIFETIME_PARAM@23..25
-              LIFETIME@23..25 "\'a"
-            R_ANGLE@25..26 ">"
+        FOR_KW@19..22 "for"
+        TYPE_PARAM_LIST@22..26
+          L_ANGLE@22..23 "<"
+          LIFETIME_PARAM@23..25
+            LIFETIME@23..25 "\'a"
+          R_ANGLE@25..26 ">"
     WHITESPACE@26..27 "\n"
     BLOCK_EXPR@27..29
       L_CURLY@27..28 "{"
       R_CURLY@28..29 "}"
   WHITESPACE@29..30 "\n"
-error 26..26: expected a path
+error 26..26: expected type
 error 26..26: expected colon

crates/ra_syntax/test_data/parser/err/0044_unexpected_for_type.rast

@@ -0,0 +1,88 @@
+SOURCE_FILE@0..79
+  TYPE_ALIAS_DEF@0..25
+    TYPE_KW@0..4 "type"
+    WHITESPACE@4..5 " "
+    NAME@5..6
+      IDENT@5..6 "A"
+    WHITESPACE@6..7 " "
+    EQ@7..8 "="
+    WHITESPACE@8..9 " "
+    FOR_TYPE@9..24
+      FOR_KW@9..12 "for"
+      TYPE_PARAM_LIST@12..16
+        L_ANGLE@12..13 "<"
+        LIFETIME_PARAM@13..15
+          LIFETIME@13..15 "\'a"
+        R_ANGLE@15..16 ">"
+      WHITESPACE@16..17 " "
+      REFERENCE_TYPE@17..24
+        AMP@17..18 "&"
+        LIFETIME@18..20 "\'a"
+        WHITESPACE@20..21 " "
+        PATH_TYPE@21..24
+          PATH@21..24
+            PATH_SEGMENT@21..24
+              NAME_REF@21..24
+                IDENT@21..24 "u32"
+    SEMICOLON@24..25 ";"
+  WHITESPACE@25..26 "\n"
+  TYPE_ALIAS_DEF@26..54
+    TYPE_KW@26..30 "type"
+    WHITESPACE@30..31 " "
+    NAME@31..32
+      IDENT@31..32 "B"
+    WHITESPACE@32..33 " "
+    EQ@33..34 "="
+    WHITESPACE@34..35 " "
+    FOR_TYPE@35..53
+      FOR_KW@35..38 "for"
+      TYPE_PARAM_LIST@38..42
+        L_ANGLE@38..39 "<"
+        LIFETIME_PARAM@39..41
+          LIFETIME@39..41 "\'a"
+        R_ANGLE@41..42 ">"
+      WHITESPACE@42..43 " "
+      TUPLE_TYPE@43..53
+        L_PAREN@43..44 "("
+        REFERENCE_TYPE@44..51
+          AMP@44..45 "&"
+          LIFETIME@45..47 "\'a"
+          WHITESPACE@47..48 " "
+          PATH_TYPE@48..51
+            PATH@48..51
+              PATH_SEGMENT@48..51
+                NAME_REF@48..51
+                  IDENT@48..51 "u32"
+        COMMA@51..52 ","
+        R_PAREN@52..53 ")"
+    SEMICOLON@53..54 ";"
+  WHITESPACE@54..55 "\n"
+  TYPE_ALIAS_DEF@55..78
+    TYPE_KW@55..59 "type"
+    WHITESPACE@59..60 " "
+    NAME@60..61
+      IDENT@60..61 "B"
+    WHITESPACE@61..62 " "
+    EQ@62..63 "="
+    WHITESPACE@63..64 " "
+    FOR_TYPE@64..77
+      FOR_KW@64..67 "for"
+      TYPE_PARAM_LIST@67..71
+        L_ANGLE@67..68 "<"
+        LIFETIME_PARAM@68..70
+          LIFETIME@68..70 "\'a"
+        R_ANGLE@70..71 ">"
+      WHITESPACE@71..72 " "
+      SLICE_TYPE@72..77
+        L_BRACK@72..73 "["
+        PATH_TYPE@73..76
+          PATH@73..76
+            PATH_SEGMENT@73..76
+              NAME_REF@73..76
+                IDENT@73..76 "u32"
+        R_BRACK@76..77 "]"
+    SEMICOLON@77..78 ";"
+  WHITESPACE@78..79 "\n"
+error 16..16: expected a function pointer or path
+error 42..42: expected a function pointer or path
+error 71..71: expected a function pointer or path

crates/ra_syntax/test_data/parser/err/0044_unexpected_for_type.rs

@@ -0,0 +1,3 @@
+type A = for<'a> &'a u32;
+type B = for<'a> (&'a u32,);
+type B = for<'a> [u32];