10 files changed, 93 insertions, 32 deletions

diff --git a/crates/ra_parser/src/event.rs b/crates/ra_parser/src/event.rs
index c1773e8e0..87cf4eca0 100644
--- a/crates/ra_parser/src/event.rs
+++ b/crates/ra_parser/src/event.rs
@@ -116,12 +116,12 @@ pub(super) fn process(sink: &mut dyn TreeSink, mut events: Vec<Event>) {
                 }
 
                 for kind in forward_parents.drain(..).rev() {
-                    sink.start_branch(kind);
+                    sink.start_node(kind);
                 }
             }
-            Event::Finish => sink.finish_branch(),
+            Event::Finish => sink.finish_node(),
             Event::Token { kind, n_raw_tokens } => {
-                sink.leaf(kind, n_raw_tokens);
+                sink.token(kind, n_raw_tokens);
             }
             Event::Error { msg } => sink.error(msg),
         }
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 73e1acd5a..bf5d6544d 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -410,6 +410,7 @@ fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 //     82 as i32;
 //     81 as i8 + 1;
 //     79 as i16 - 1;
+//     0x36 as u8 <= 0x37;
 // }
 fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
     assert!(p.at(AS_KW));
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index a23977bfb..8dc7e44a9 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -51,6 +51,7 @@ pub(super) const ATOM_EXPR_FIRST: TokenSet =
         BREAK_KW,
         CONTINUE_KW,
         LIFETIME,
+        ASYNC_KW,
     ]);
 
 const EXPR_RECOVERY_SET: TokenSet = token_set![LET_KW];
@@ -68,6 +69,7 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
         L_BRACK => array_expr(p),
         PIPE => lambda_expr(p),
         MOVE_KW if la == PIPE => lambda_expr(p),
+        ASYNC_KW if la == PIPE || (la == MOVE_KW && p.nth(2) == PIPE) => lambda_expr(p),
         IF_KW => if_expr(p),
 
         LOOP_KW => loop_expr(p, None),
@@ -92,10 +94,10 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
                 }
             }
         }
-
-        ASYNC_KW if la == L_CURLY => {
+        ASYNC_KW if la == L_CURLY || (la == MOVE_KW && p.nth(2) == L_CURLY) => {
             let m = p.start();
             p.bump();
+            p.eat(MOVE_KW);
             block_expr(p, Some(m))
         }
         MATCH_KW => match_expr(p),
@@ -190,10 +192,19 @@ fn array_expr(p: &mut Parser) -> CompletedMarker {
 //     || -> i32 { 92 };
 //     |x| x;
 //     move |x: i32,| x;
+//     async || {};
+//     move || {};
+//     async move || {};
 // }
 fn lambda_expr(p: &mut Parser) -> CompletedMarker {
-    assert!(p.at(PIPE) || (p.at(MOVE_KW) && p.nth(1) == PIPE));
+    assert!(
+        p.at(PIPE)
+            || (p.at(MOVE_KW) && p.nth(1) == PIPE)
+            || (p.at(ASYNC_KW) && p.nth(1) == PIPE)
+            || (p.at(ASYNC_KW) && p.nth(1) == MOVE_KW && p.nth(2) == PIPE)
+    );
     let m = p.start();
+    p.eat(ASYNC_KW);
     p.eat(MOVE_KW);
     params::param_list_opt_types(p);
     if opt_fn_ret_type(p) {
diff --git a/crates/ra_parser/src/grammar/items.rs b/crates/ra_parser/src/grammar/items.rs
index c24e6d1e0..c4b8ef3c7 100644
--- a/crates/ra_parser/src/grammar/items.rs
+++ b/crates/ra_parser/src/grammar/items.rs
@@ -82,7 +82,7 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker, flavor: ItemFlavor) -> Resul
     // test_err async_without_semicolon
     // fn foo() { let _ = async {} }
     has_mods |= p.eat(CONST_KW);
-    if p.at(ASYNC_KW) && p.nth(1) != L_CURLY {
+    if p.at(ASYNC_KW) && p.nth(1) != L_CURLY && p.nth(1) != MOVE_KW && p.nth(1) != PIPE {
         p.eat(ASYNC_KW);
         has_mods = true;
     }
diff --git a/crates/ra_parser/src/grammar/items/traits.rs b/crates/ra_parser/src/grammar/items/traits.rs
index f49615f6b..d03a6be0d 100644
--- a/crates/ra_parser/src/grammar/items/traits.rs
+++ b/crates/ra_parser/src/grammar/items/traits.rs
@@ -2,6 +2,7 @@ use super::*;
 
 // test trait_item
 // trait T<U>: Hash + Clone where U: Copy {}
+// trait X<U: Debug + Display>: Hash + Clone where U: Copy {}
 pub(super) fn trait_def(p: &mut Parser) {
     assert!(p.at(TRAIT_KW));
     p.bump();
diff --git a/crates/ra_parser/src/grammar/type_args.rs b/crates/ra_parser/src/grammar/type_args.rs
index f889419c5..684976b99 100644
--- a/crates/ra_parser/src/grammar/type_args.rs
+++ b/crates/ra_parser/src/grammar/type_args.rs
@@ -8,6 +8,7 @@ pub(super) fn opt_type_arg_list(p: &mut Parser, colon_colon_required: bool) {
             p.bump();
             p.bump();
         }
+        (false, L_ANGLE, EQ) => return,
         (false, L_ANGLE, _) => {
             m = p.start();
             p.bump();
diff --git a/crates/ra_parser/src/grammar/type_params.rs b/crates/ra_parser/src/grammar/type_params.rs
index 40f998682..07d9b0792 100644
--- a/crates/ra_parser/src/grammar/type_params.rs
+++ b/crates/ra_parser/src/grammar/type_params.rs
@@ -79,23 +79,40 @@ fn lifetime_bounds(p: &mut Parser) {
     }
 }
 
-pub(super) fn bounds_without_colon(p: &mut Parser) {
-    loop {
-        let has_paren = p.eat(L_PAREN);
-        p.eat(QUESTION);
-        match p.current() {
-            LIFETIME => p.bump(),
-            FOR_KW => types::for_type(p),
-            _ if paths::is_path_start(p) => types::path_type(p),
-            _ => break,
-        }
-        if has_paren {
-            p.expect(R_PAREN);
-        }
+pub(super) fn bounds_without_colon_m(p: &mut Parser, marker: Marker) -> CompletedMarker {
+    while type_bound(p) {
         if !p.eat(PLUS) {
             break;
         }
     }
+
+    marker.complete(p, TYPE_BOUND_LIST)
+}
+
+pub(super) fn bounds_without_colon(p: &mut Parser) {
+    let m = p.start();
+    bounds_without_colon_m(p, m);
+}
+
+fn type_bound(p: &mut Parser) -> bool {
+    let m = p.start();
+    let has_paren = p.eat(L_PAREN);
+    p.eat(QUESTION);
+    match p.current() {
+        LIFETIME => p.bump(),
+        FOR_KW => types::for_type(p),
+        _ if paths::is_path_start(p) => types::path_type_(p, false),
+        _ => {
+            m.abandon(p);
+            return false;
+        }
+    }
+    if has_paren {
+        p.expect(R_PAREN);
+    }
+    m.complete(p, TYPE_BOUND);
+
+    true
 }
 
 // test where_clause
@@ -148,7 +165,7 @@ fn where_predicate(p: &mut Parser) {
         LIFETIME => {
             p.bump();
             if p.at(COLON) {
-                lifetime_bounds(p);
+                bounds(p);
             } else {
                 p.error("expected colon");
             }
diff --git a/crates/ra_parser/src/grammar/types.rs b/crates/ra_parser/src/grammar/types.rs
index fdd4f2c52..a46da9b44 100644
--- a/crates/ra_parser/src/grammar/types.rs
+++ b/crates/ra_parser/src/grammar/types.rs
@@ -261,21 +261,47 @@ fn path_or_macro_type_(p: &mut Parser, allow_bounds: bool) {
         PATH_TYPE
     };
 
-    if allow_bounds && p.eat(PLUS) {
-        type_params::bounds_without_colon(p);
-    }
+    let path = m.complete(p, kind);
 
-    m.complete(p, kind);
+    if allow_bounds {
+        opt_path_type_bounds_as_dyn_trait_type(p, path);
+    }
 }
 
 pub(super) fn path_type_(p: &mut Parser, allow_bounds: bool) {
     assert!(paths::is_path_start(p) || p.at(L_ANGLE));
     let m = p.start();
     paths::type_path(p);
+
     // test path_type_with_bounds
     // fn foo() -> Box<T + 'f> {}
-    if allow_bounds && p.eat(PLUS) {
-        type_params::bounds_without_colon(p);
+    // fn foo() -> Box<dyn T + 'f> {}
+    let path = m.complete(p, PATH_TYPE);
+    if allow_bounds {
+        opt_path_type_bounds_as_dyn_trait_type(p, path);
     }
-    m.complete(p, PATH_TYPE);
+}
+
+/// This turns a parsed PATH_TYPE optionally into a DYN_TRAIT_TYPE
+/// with a TYPE_BOUND_LIST
+fn opt_path_type_bounds_as_dyn_trait_type(p: &mut Parser, path_type_marker: CompletedMarker) {
+    if !p.at(PLUS) {
+        return;
+    }
+
+    // First create a TYPE_BOUND from the completed PATH_TYPE
+    let m = path_type_marker.precede(p).complete(p, TYPE_BOUND);
+
+    // Next setup a marker for the TYPE_BOUND_LIST
+    let m = m.precede(p);
+
+    // This gets consumed here so it gets properly set
+    // in the TYPE_BOUND_LIST
+    p.eat(PLUS);
+
+    // Parse rest of the bounds into the TYPE_BOUND_LIST
+    let m = type_params::bounds_without_colon_m(p, m);
+
+    // Finally precede everything with DYN_TRAIT_TYPE
+    m.precede(p).complete(p, DYN_TRAIT_TYPE);
 }
diff --git a/crates/ra_parser/src/lib.rs b/crates/ra_parser/src/lib.rs
index ddc08e462..30ba06aac 100644
--- a/crates/ra_parser/src/lib.rs
+++ b/crates/ra_parser/src/lib.rs
@@ -40,15 +40,15 @@ pub trait TokenSource {
 
 /// `TreeSink` abstracts details of a particular syntax tree implementation.
 pub trait TreeSink {
-    /// Adds new leaf to the current branch.
-    fn leaf(&mut self, kind: SyntaxKind, n_tokens: u8);
+    /// Adds new token to the current branch.
+    fn token(&mut self, kind: SyntaxKind, n_tokens: u8);
 
     /// Start new branch and make it current.
-    fn start_branch(&mut self, kind: SyntaxKind);
+    fn start_node(&mut self, kind: SyntaxKind);
 
     /// Finish current branch and restore previous
     /// branch as current.
-    fn finish_branch(&mut self);
+    fn finish_node(&mut self);
 
     fn error(&mut self, error: ParseError);
 }
diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs
index 03247ae38..547af1b27 100644
--- a/crates/ra_parser/src/syntax_kind/generated.rs
+++ b/crates/ra_parser/src/syntax_kind/generated.rs
@@ -228,6 +228,8 @@ pub enum SyntaxKind {
     PARAM,
     SELF_PARAM,
     ARG_LIST,
+    TYPE_BOUND,
+    TYPE_BOUND_LIST,
 }
 use self::SyntaxKind::*;
 
@@ -567,6 +569,8 @@ impl SyntaxKind {
             PARAM => &SyntaxInfo { name: "PARAM" },
             SELF_PARAM => &SyntaxInfo { name: "SELF_PARAM" },
             ARG_LIST => &SyntaxInfo { name: "ARG_LIST" },
+            TYPE_BOUND => &SyntaxInfo { name: "TYPE_BOUND" },
+            TYPE_BOUND_LIST => &SyntaxInfo { name: "TYPE_BOUND_LIST" },
             TOMBSTONE => &SyntaxInfo { name: "TOMBSTONE" },
             EOF => &SyntaxInfo { name: "EOF" },
         }