Add mbe stmt matcher

1 files changed, 82 insertions, 72 deletions

diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 295577325..06f2b45b1 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -48,88 +48,77 @@ fn is_expr_stmt_attr_allowed(kind: SyntaxKind) -> bool {
     }
 }
 
-pub(crate) fn expr_block_contents(p: &mut Parser) {
-    // This is checked by a validator
-    attributes::inner_attributes(p);
-
-    while !p.at(EOF) && !p.at(R_CURLY) {
-        // test nocontentexpr
-        // fn foo(){
-        //     ;;;some_expr();;;;{;;;};;;;Ok(())
-        // }
-        if p.current() == SEMI {
-            p.bump();
-            continue;
-        }
+pub(super) fn stmt(p: &mut Parser, with_semi: bool) {
+    // test block_items
+    // fn a() { fn b() {} }
+    let m = p.start();
+    // test attr_on_expr_stmt
+    // fn foo() {
+    //     #[A] foo();
+    //     #[B] bar!{}
+    //     #[C] #[D] {}
+    //     #[D] return ();
+    // }
+    let has_attrs = p.at(POUND);
+    attributes::outer_attributes(p);
 
-        // test block_items
-        // fn a() { fn b() {} }
-        let m = p.start();
-        // test attr_on_expr_stmt
-        // fn foo() {
-        //     #[A] foo();
-        //     #[B] bar!{}
-        //     #[C] #[D] {}
-        //     #[D] return ();
-        // }
-        let has_attrs = p.at(POUND);
-        attributes::outer_attributes(p);
-        if p.at(LET_KW) {
-            let_stmt(p, m);
-            continue;
-        }
+    if p.at(LET_KW) {
+        let_stmt(p, m, with_semi);
+        return;
+    }
 
-        let m = match items::maybe_item(p, m, items::ItemFlavor::Mod) {
-            Ok(()) => continue,
-            Err(m) => m,
-        };
+    let m = match items::maybe_item(p, m, items::ItemFlavor::Mod) {
+        Ok(()) => return,
+        Err(m) => m,
+    };
 
-        let (cm, blocklike) = expr_stmt(p);
-        let kind = cm.as_ref().map(|cm| cm.kind()).unwrap_or(ERROR);
+    let (cm, blocklike) = expr_stmt(p);
+    let kind = cm.as_ref().map(|cm| cm.kind()).unwrap_or(ERROR);
 
-        if has_attrs && !is_expr_stmt_attr_allowed(kind) {
-            // test_err attr_on_expr_not_allowed
-            // fn foo() {
-            //    #[A] 1 + 2;
-            //    #[B] if true {};
-            // }
-            p.error(format!("attributes are not allowed on {:?}", kind));
-        }
+    if has_attrs && !is_expr_stmt_attr_allowed(kind) {
+        // test_err attr_on_expr_not_allowed
+        // fn foo() {
+        //    #[A] 1 + 2;
+        //    #[B] if true {};
+        // }
+        p.error(format!("attributes are not allowed on {:?}", kind));
+    }
 
-        if p.at(R_CURLY) {
-            // test attr_on_last_expr_in_block
-            // fn foo() {
-            //     { #[A] bar!()? }
-            //     #[B] &()
-            // }
-            if let Some(cm) = cm {
-                cm.undo_completion(p).abandon(p);
-                m.complete(p, kind);
-            } else {
-                m.abandon(p);
-            }
+    if p.at(R_CURLY) {
+        // test attr_on_last_expr_in_block
+        // fn foo() {
+        //     { #[A] bar!()? }
+        //     #[B] &()
+        // }
+        if let Some(cm) = cm {
+            cm.undo_completion(p).abandon(p);
+            m.complete(p, kind);
         } else {
-            // test no_semi_after_block
-            // fn foo() {
-            //     if true {}
-            //     loop {}
-            //     match () {}
-            //     while true {}
-            //     for _ in () {}
-            //     {}
-            //     {}
-            //     macro_rules! test {
-            //          () => {}
-            //     }
-            //     test!{}
-            // }
+            m.abandon(p);
+        }
+    } else {
+        // test no_semi_after_block
+        // fn foo() {
+        //     if true {}
+        //     loop {}
+        //     match () {}
+        //     while true {}
+        //     for _ in () {}
+        //     {}
+        //     {}
+        //     macro_rules! test {
+        //          () => {}
+        //     }
+        //     test!{}
+        // }
+        if with_semi {
             if blocklike.is_block() {
                 p.eat(SEMI);
             } else {
                 p.expect(SEMI);
             }
-            m.complete(p, EXPR_STMT);
         }
+        m.complete(p, EXPR_STMT);
     }
 
     // test let_stmt;
@@ -139,7 +128,7 @@ pub(crate) fn expr_block_contents(p: &mut Parser) {
     //     let c = 92;
     //     let d: i32 = 92;
     // }
-    fn let_stmt(p: &mut Parser, m: Marker) {
+    fn let_stmt(p: &mut Parser, m: Marker, with_semi: bool) {
         assert!(p.at(LET_KW));
         p.bump();
         patterns::pattern(p);
@@ -149,11 +138,32 @@ pub(crate) fn expr_block_contents(p: &mut Parser) {
         if p.eat(EQ) {
             expressions::expr(p);
         }
-        p.expect(SEMI);
+
+        if with_semi {
+            p.expect(SEMI);
+        }
         m.complete(p, LET_STMT);
     }
 }
 
+pub(crate) fn expr_block_contents(p: &mut Parser) {
+    // This is checked by a validator
+    attributes::inner_attributes(p);
+
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        // test nocontentexpr
+        // fn foo(){
+        //     ;;;some_expr();;;;{;;;};;;;Ok(())
+        // }
+        if p.current() == SEMI {
+            p.bump();
+            continue;
+        }
+
+        stmt(p, true)
+    }
+}
+
 #[derive(Clone, Copy)]
 struct Restrictions {
     forbid_structs: bool,