diff --git a/crates/ra_mbe/src/lib.rs b/crates/ra_mbe/src/lib.rs
index a530f3b03c2..a1f4389069d 100644
--- a/crates/ra_mbe/src/lib.rs
+++ b/crates/ra_mbe/src/lib.rs
@@ -582,4 +582,19 @@ macro_rules! foo {
         );
         assert_expansion(&rules, "foo! { (a, b) }", "fn foo () {let (a , b) ;}");
     }
+
+    #[test]
+    fn test_stmt() {
+        let rules = create_rules(
+            r#"
+        macro_rules! foo {
+            ($ i:stmt) => (
+                fn bar() { $ i; }
+            )
+        }
+"#,
+        );
+        assert_expansion(&rules, "foo! { 2 }", "fn bar () {2 ;}");
+        assert_expansion(&rules, "foo! { let a = 0 }", "fn bar () {let a = 0 ;}");
+    }
 }
diff --git a/crates/ra_mbe/src/mbe_expander.rs b/crates/ra_mbe/src/mbe_expander.rs
index 7a259f33861..7587b575d91 100644
--- a/crates/ra_mbe/src/mbe_expander.rs
+++ b/crates/ra_mbe/src/mbe_expander.rs
@@ -157,6 +157,10 @@ fn match_lhs(pattern: &crate::Subtree, input: &mut TtCursor) -> Result<Bindings,
                             let pat = input.eat_pat().ok_or(ExpandError::UnexpectedToken)?.clone();
                             res.inner.insert(text.clone(), Binding::Simple(pat.into()));
                         }
+                        "stmt" => {
+                            let pat = input.eat_stmt().ok_or(ExpandError::UnexpectedToken)?.clone();
+                            res.inner.insert(text.clone(), Binding::Simple(pat.into()));
+                        }
                         _ => return Err(ExpandError::UnexpectedToken),
                     }
                 }
diff --git a/crates/ra_mbe/src/subtree_parser.rs b/crates/ra_mbe/src/subtree_parser.rs
index 13d5d2169e0..f075ce24565 100644
--- a/crates/ra_mbe/src/subtree_parser.rs
+++ b/crates/ra_mbe/src/subtree_parser.rs
@@ -42,6 +42,10 @@ pub fn parse_pat(self) -> Option<tt::TokenTree> {
         self.parse(ra_parser::parse_pat)
     }
 
+    pub fn parse_stmt(self) -> Option<tt::TokenTree> {
+        self.parse(|src, sink| ra_parser::parse_stmt(src, sink, false))
+    }
+
     fn parse<F>(self, f: F) -> Option<tt::TokenTree>
     where
         F: FnOnce(&dyn TokenSource, &mut dyn TreeSink),
diff --git a/crates/ra_mbe/src/tt_cursor.rs b/crates/ra_mbe/src/tt_cursor.rs
index f6cefe087e5..adfe5520d11 100644
--- a/crates/ra_mbe/src/tt_cursor.rs
+++ b/crates/ra_mbe/src/tt_cursor.rs
@@ -99,6 +99,11 @@ pub(crate) fn eat_pat(&mut self) -> Option<tt::TokenTree> {
         parser.parse_pat()
     }
 
+    pub(crate) fn eat_stmt(&mut self) -> Option<tt::TokenTree> {
+        let parser = Parser::new(&mut self.pos, self.subtree);
+        parser.parse_stmt()
+    }
+
     pub(crate) fn expect_char(&mut self, char: char) -> Result<(), ParseError> {
         if self.at_char(char) {
             self.bump();
diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs
index 5a7a5514190..2c2f785d0f4 100644
--- a/crates/ra_parser/src/grammar.rs
+++ b/crates/ra_parser/src/grammar.rs
@@ -65,6 +65,10 @@ pub(crate) fn pattern(p: &mut Parser) {
     patterns::pattern(p)
 }
 
+pub(crate) fn stmt(p: &mut Parser, with_semi: bool) {
+    expressions::stmt(p, with_semi)
+}
+
 pub(crate) fn reparser(
     node: SyntaxKind,
     first_child: Option<SyntaxKind>,
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 2955773256f..06f2b45b151 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -48,6 +48,104 @@ fn is_expr_stmt_attr_allowed(kind: SyntaxKind) -> bool {
     }
 }
 
+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);
+
+    if p.at(LET_KW) {
+        let_stmt(p, m, with_semi);
+        return;
+    }
+
+    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);
+
+    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);
+        }
+    } 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);
+    }
+
+    // test let_stmt;
+    // fn foo() {
+    //     let a;
+    //     let b: i32;
+    //     let c = 92;
+    //     let d: i32 = 92;
+    // }
+    fn let_stmt(p: &mut Parser, m: Marker, with_semi: bool) {
+        assert!(p.at(LET_KW));
+        p.bump();
+        patterns::pattern(p);
+        if p.at(COLON) {
+            types::ascription(p);
+        }
+        if p.eat(EQ) {
+            expressions::expr(p);
+        }
+
+        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);
@@ -62,95 +160,7 @@ pub(crate) fn expr_block_contents(p: &mut Parser) {
             continue;
         }
 
-        // 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;
-        }
-
-        let m = match items::maybe_item(p, m, items::ItemFlavor::Mod) {
-            Ok(()) => continue,
-            Err(m) => m,
-        };
-
-        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 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);
-            }
-        } else {
-            // test no_semi_after_block
-            // fn foo() {
-            //     if true {}
-            //     loop {}
-            //     match () {}
-            //     while true {}
-            //     for _ in () {}
-            //     {}
-            //     {}
-            //     macro_rules! test {
-            //          () => {}
-            //     }
-            //     test!{}
-            // }
-            if blocklike.is_block() {
-                p.eat(SEMI);
-            } else {
-                p.expect(SEMI);
-            }
-            m.complete(p, EXPR_STMT);
-        }
-    }
-
-    // test let_stmt;
-    // fn foo() {
-    //     let a;
-    //     let b: i32;
-    //     let c = 92;
-    //     let d: i32 = 92;
-    // }
-    fn let_stmt(p: &mut Parser, m: Marker) {
-        assert!(p.at(LET_KW));
-        p.bump();
-        patterns::pattern(p);
-        if p.at(COLON) {
-            types::ascription(p);
-        }
-        if p.eat(EQ) {
-            expressions::expr(p);
-        }
-        p.expect(SEMI);
-        m.complete(p, LET_STMT);
+        stmt(p, true)
     }
 }
 
diff --git a/crates/ra_parser/src/lib.rs b/crates/ra_parser/src/lib.rs
index 56755c394b5..9133c1b8ae0 100644
--- a/crates/ra_parser/src/lib.rs
+++ b/crates/ra_parser/src/lib.rs
@@ -88,6 +88,11 @@ pub fn parse_pat(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
     parse_from_tokens(token_source, tree_sink, grammar::pattern);
 }
 
+/// Parse given tokens into the given sink as a statement
+pub fn parse_stmt(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink, with_semi: bool) {
+    parse_from_tokens(token_source, tree_sink, |p| grammar::stmt(p, with_semi));
+}
+
 /// A parsing function for a specific braced-block.
 pub struct Reparser(fn(&mut parser::Parser));