4 files changed, 55 insertions, 40 deletions

diff --git a/crates/ra_syntax/src/grammar/expressions.rs b/crates/ra_syntax/src/grammar/expressions.rs
index a9449c7bf..4f8c46ab3 100644
--- a/crates/ra_syntax/src/grammar/expressions.rs
+++ b/crates/ra_syntax/src/grammar/expressions.rs
@@ -64,6 +64,20 @@ pub(crate) fn block(p: &mut Parser) {
                         if p.at(R_CURLY) {
                             m.abandon(p);
                         } else {
+                            // test no_semi_after_block
+                            // fn foo() {
+                            //     if true {}
+                            //     loop {}
+                            //     match () {}
+                            //     while true {}
+                            //     for _ in () {}
+                            //     {}
+                            //     {}
+                            //     macro_rules! test {
+                            //          () => {}
+                            //     }
+                            //     test!{}
+                            // }
                             if is_blocklike {
                                 p.eat(SEMI);
                             } else {
@@ -143,7 +157,7 @@ fn current_op(p: &Parser) -> (u8, Op) {
 
     let bp = match p.current() {
         EQ => 1,
-        DOTDOT => 2,
+        DOTDOT | DOTDOTEQ => 2,
         EQEQ | NEQ | L_ANGLE | R_ANGLE => 5,
         PIPE => 6,
         CARET => 7,
@@ -158,13 +172,13 @@ fn current_op(p: &Parser) -> (u8, Op) {
 // Parses expression with binding power of at least bp.
 fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike {
     let mut lhs = match lhs(p, r) {
-        Some(lhs) => {
+        Some((lhs, blocklike)) => {
             // test stmt_bin_expr_ambiguity
             // fn foo() {
             //     let _ = {1} & 2;
             //     {1} &2;
             // }
-            if r.prefer_stmt && is_block(lhs.kind()) {
+            if r.prefer_stmt && blocklike.is_block() {
                 return BlockLike::Block;
             }
             lhs
@@ -173,7 +187,7 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike {
     };
 
     loop {
-        let is_range = p.current() == DOTDOT;
+        let is_range = p.current() == DOTDOT || p.current() == DOTDOTEQ;
         let (op_bp, op) = current_op(p);
         if op_bp < bp {
             break;
@@ -191,29 +205,12 @@ fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> BlockLike {
     BlockLike::NotBlock
 }
 
-// test no_semi_after_block
-// fn foo() {
-//     if true {}
-//     loop {}
-//     match () {}
-//     while true {}
-//     for _ in () {}
-//     {}
-//     {}
-// }
-fn is_block(kind: SyntaxKind) -> bool {
-    match kind {
-        IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR | BLOCK_EXPR => true,
-        _ => false,
-    }
-}
-
 const LHS_FIRST: TokenSet = token_set_union![
     token_set![AMP, STAR, EXCL, DOTDOT, MINUS],
     atom::ATOM_EXPR_FIRST,
 ];
 
-fn lhs(p: &mut Parser, r: Restrictions) -> Option<CompletedMarker> {
+fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
     let m;
     let kind = match p.current() {
         // test ref_expr
@@ -246,19 +243,28 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<CompletedMarker> {
             if p.at_ts(EXPR_FIRST) {
                 expr_bp(p, r, 2);
             }
-            return Some(m.complete(p, RANGE_EXPR));
+            return Some((m.complete(p, RANGE_EXPR), BlockLike::NotBlock));
         }
         _ => {
-            let lhs = atom::atom_expr(p, r)?;
-            return Some(postfix_expr(p, r, lhs));
+            let (lhs, blocklike) = atom::atom_expr(p, r)?;
+            return Some((
+                postfix_expr(p, lhs, !(r.prefer_stmt && blocklike.is_block())),
+                blocklike,
+            ));
         }
     };
     expr_bp(p, r, 255);
-    Some(m.complete(p, kind))
+    Some((m.complete(p, kind), BlockLike::NotBlock))
 }
 
-fn postfix_expr(p: &mut Parser, r: Restrictions, mut lhs: CompletedMarker) -> CompletedMarker {
-    let mut allow_calls = !r.prefer_stmt || !is_block(lhs.kind());
+fn postfix_expr(
+    p: &mut Parser,
+    mut lhs: CompletedMarker,
+    // Calls are disallowed if the type is a block and we prefer statements because the call cannot be disambiguated from a tuple
+    // E.g. `while true {break}();` is parsed as
+    // `while true {break}; ();`
+    mut allow_calls: bool,
+) -> CompletedMarker {
     loop {
         lhs = match p.current() {
             // test stmt_postfix_expr_ambiguity
@@ -406,20 +412,20 @@ fn arg_list(p: &mut Parser) {
 //     let _ = ::a::<b>;
 //     let _ = format!();
 // }
-fn path_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
+fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
     assert!(paths::is_path_start(p) || p.at(L_ANGLE));
     let m = p.start();
     paths::expr_path(p);
     match p.current() {
         L_CURLY if !r.forbid_structs => {
             named_field_list(p);
-            m.complete(p, STRUCT_LIT)
+            (m.complete(p, STRUCT_LIT), BlockLike::Block)
         }
         EXCL => {
-            items::macro_call_after_excl(p);
-            m.complete(p, MACRO_CALL)
+            let block_like = items::macro_call_after_excl(p);
+            return (m.complete(p, MACRO_CALL), block_like);
         }
-        _ => m.complete(p, PATH_EXPR),
+        _ => (m.complete(p, PATH_EXPR), BlockLike::NotBlock),
     }
 }
 
diff --git a/crates/ra_syntax/src/grammar/expressions/atom.rs b/crates/ra_syntax/src/grammar/expressions/atom.rs
index 04087fd60..cd7d62aff 100644
--- a/crates/ra_syntax/src/grammar/expressions/atom.rs
+++ b/crates/ra_syntax/src/grammar/expressions/atom.rs
@@ -61,9 +61,9 @@ pub(super) const ATOM_EXPR_FIRST: TokenSet = token_set_union![
 
 const EXPR_RECOVERY_SET: TokenSet = token_set![LET_KW];
 
-pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<CompletedMarker> {
+pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
     if let Some(m) = literal(p) {
-        return Some(m);
+        return Some((m, BlockLike::NotBlock));
     }
     if paths::is_path_start(p) || p.at(L_ANGLE) {
         return Some(path_expr(p, r));
@@ -114,7 +114,11 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<CompletedMark
             return None;
         }
     };
-    Some(done)
+    let blocklike = match done.kind() {
+        IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR | BLOCK_EXPR => BlockLike::Block,
+        _ => BlockLike::NotBlock,
+    };
+    Some((done, blocklike))
 }
 
 // test tuple_expr
@@ -349,6 +353,7 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
 // fn foo() {
 //     match () {
 //         _ => (),
+//         _ if Test>{field: 0} => (),
 //         X | Y if Z => (),
 //         | X | Y if Z => (),
 //         | X => (),
@@ -362,7 +367,7 @@ fn match_arm(p: &mut Parser) -> BlockLike {
         patterns::pattern(p);
     }
     if p.eat(IF_KW) {
-        expr_no_struct(p);
+        expr(p);
     }
     p.expect(FAT_ARROW);
     let ret = expr_stmt(p);
diff --git a/crates/ra_syntax/src/grammar/patterns.rs b/crates/ra_syntax/src/grammar/patterns.rs
index 10fa0e0be..64cdf0b1b 100644
--- a/crates/ra_syntax/src/grammar/patterns.rs
+++ b/crates/ra_syntax/src/grammar/patterns.rs
@@ -14,9 +14,13 @@ pub(super) fn pattern_r(p: &mut Parser, recovery_set: TokenSet) {
     if let Some(lhs) = atom_pat(p, recovery_set) {
         // test range_pat
         // fn main() {
-        //     match 92 { 0 ... 100 => () }
+        //     match 92 {
+        //         0 ... 100 => (),
+        //         101 ..= 200 => (),
+        //         200 .. 301=> (),
+        //     }
         // }
-        if p.at(DOTDOTDOT) {
+        if p.at(DOTDOTDOT) || p.at(DOTDOTEQ) || p.at(DOTDOT) {
             let m = lhs.precede(p);
             p.bump();
             atom_pat(p, recovery_set);
diff --git a/crates/ra_syntax/src/parser_api.rs b/crates/ra_syntax/src/parser_api.rs
index c37c30e34..02421def1 100644
--- a/crates/ra_syntax/src/parser_api.rs
+++ b/crates/ra_syntax/src/parser_api.rs
@@ -36,7 +36,7 @@ impl<'t> Parser<'t> {
         self.current() == kind
     }
 
-    /// Checks if the current token is `kind`.
+    /// Checks if the current token is in `kinds`.
     pub(crate) fn at_ts(&self, kinds: TokenSet) -> bool {
         kinds.contains(self.current())
     }