7 files changed, 81 insertions, 25 deletions

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..d0feed616 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -68,6 +68,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 +93,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 +191,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);
 }