4 files changed, 70 insertions, 37 deletions

diff --git a/crates/ra_syntax/src/grammar/mod.rs b/crates/ra_syntax/src/grammar/mod.rs
index c87564073..95c437983 100644
--- a/crates/ra_syntax/src/grammar/mod.rs
+++ b/crates/ra_syntax/src/grammar/mod.rs
@@ -21,6 +21,11 @@
 //! 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.
+//!
+//! Coding convention: rules like `where_clause` always produce either a
+//! node or an error, rules like `opt_where_clause` may produce nothing.
+//! Non-opt rules typically start with `assert!(p.at(FIRST_TOKEN))`, the
+//! caller is responsible for branching on the first token.
 mod attributes;
 mod expressions;
 mod items;
diff --git a/crates/ra_syntax/src/grammar/type_params.rs b/crates/ra_syntax/src/grammar/type_params.rs
index 79f5036b4..68eca0ce8 100644
--- a/crates/ra_syntax/src/grammar/type_params.rs
+++ b/crates/ra_syntax/src/grammar/type_params.rs
@@ -4,6 +4,11 @@ pub(super) fn opt_type_param_list(p: &mut Parser) {
     if !p.at(L_ANGLE) {
         return;
     }
+    type_param_list(p);
+}
+
+fn type_param_list(p: &mut Parser) {
+    assert!(p.at(L_ANGLE));
     let m = p.start();
     p.bump();
 
@@ -19,32 +24,32 @@ pub(super) fn opt_type_param_list(p: &mut Parser) {
     }
     p.expect(R_ANGLE);
     m.complete(p, TYPE_PARAM_LIST);
+}
 
-    fn lifetime_param(p: &mut Parser) {
-        assert!(p.at(LIFETIME));
-        let m = p.start();
-        p.bump();
-        if p.at(COLON) {
-            lifetime_bounds(p);
-        }
-        m.complete(p, LIFETIME_PARAM);
+fn lifetime_param(p: &mut Parser) {
+    assert!(p.at(LIFETIME));
+    let m = p.start();
+    p.bump();
+    if p.at(COLON) {
+        lifetime_bounds(p);
     }
+    m.complete(p, LIFETIME_PARAM);
+}
 
-    fn type_param(p: &mut Parser) {
-        assert!(p.at(IDENT));
-        let m = p.start();
-        name(p);
-        if p.at(COLON) {
-            bounds(p);
-        }
-        // test type_param_default
-        // struct S<T = i32>;
-        if p.at(EQ) {
-            p.bump();
-            types::type_(p)
-        }
-        m.complete(p, TYPE_PARAM);
+fn type_param(p: &mut Parser) {
+    assert!(p.at(IDENT));
+    let m = p.start();
+    name(p);
+    if p.at(COLON) {
+        bounds(p);
     }
+    // test type_param_default
+    // struct S<T = i32>;
+    if p.at(EQ) {
+        p.bump();
+        types::type_(p)
+    }
+    m.complete(p, TYPE_PARAM);
 }
 
 // test type_param_bounds
@@ -99,7 +104,7 @@ pub(super) fn opt_where_clause(p: &mut Parser) {
     let m = p.start();
     p.bump();
     loop {
-        if !(paths::is_path_start(p) || p.current() == LIFETIME) {
+        if !(paths::is_path_start(p) || p.current() == LIFETIME || p.current() == FOR_KW) {
             break;
         }
         where_predicate(p);
@@ -112,19 +117,30 @@ pub(super) fn opt_where_clause(p: &mut Parser) {
 
 fn where_predicate(p: &mut Parser) {
     let m = p.start();
-    if p.at(LIFETIME) {
-        p.eat(LIFETIME);
-        if p.at(COLON) {
-            lifetime_bounds(p)
-        } else {
-            p.error("expected colon")
+    match p.current() {
+        LIFETIME => {
+            p.bump();
+            if p.at(COLON) {
+                lifetime_bounds(p);
+            } else {
+                p.error("expected colon");
+            }
         }
-    } else {
-        types::path_type(p);
-        if p.at(COLON) {
-            bounds(p);
-        } else {
-            p.error("expected colon")
+        _ => {
+            // test where_pred_for
+            // fn test<F>()
+            // where
+            //    for<'a> F: Fn(&'a str)
+            // { }
+            if p.at(FOR_KW) {
+                types::for_binder(p);
+            }
+            types::path_type(p);
+            if p.at(COLON) {
+                bounds(p);
+            } else {
+                p.error("expected colon");
+            }
         }
     }
     m.complete(p, WHERE_PRED);
diff --git a/crates/ra_syntax/src/grammar/types.rs b/crates/ra_syntax/src/grammar/types.rs
index f308aef89..ed2718e73 100644
--- a/crates/ra_syntax/src/grammar/types.rs
+++ b/crates/ra_syntax/src/grammar/types.rs
@@ -188,13 +188,22 @@ fn fn_pointer_type(p: &mut Parser) {
     m.complete(p, FN_POINTER_TYPE);
 }
 
+pub(super) fn for_binder(p: &mut Parser) {
+    assert!(p.at(FOR_KW));
+    p.bump();
+    if p.at(L_ANGLE) {
+        type_params::opt_type_param_list(p);
+    } else {
+        p.error("expected `<`");
+    }
+}
+
 // test for_type
 // type A = for<'a> fn() -> ();
 pub(super) fn for_type(p: &mut Parser) {
     assert!(p.at(FOR_KW));
     let m = p.start();
-    p.bump();
-    type_params::opt_type_param_list(p);
+    for_binder(p);
     match p.current() {
         FN_KW | UNSAFE_KW | EXTERN_KW => fn_pointer_type(p),
         _ if paths::is_path_start(p) => path_type_(p, false),
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 69a679d04..123002825 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -60,6 +60,7 @@ pub use crate::{
 
 use crate::yellow::GreenNode;
 
+/// File represents a parse tree for a single Rust file.
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct File {
     root: SyntaxNode,
@@ -92,9 +93,11 @@ impl File {
             text_utils::replace_range(self.syntax().text().to_string(), edit.delete, &edit.insert);
         File::parse(&text)
     }
+    /// Typed AST representation of the parse tree.
     pub fn ast(&self) -> ast::Root {
         ast::Root::cast(self.syntax()).unwrap()
     }
+    /// Untyped homogeneous representation of the parse tree.
     pub fn syntax(&self) -> SyntaxNodeRef {
         self.root.borrowed()
     }