18 files changed, 690 insertions, 77 deletions

diff --git a/crates/ra_mbe/src/lib.rs b/crates/ra_mbe/src/lib.rs
index 8d5008d20..d2115bd67 100644
--- a/crates/ra_mbe/src/lib.rs
+++ b/crates/ra_mbe/src/lib.rs
@@ -37,9 +37,19 @@ pub enum ExpandError {
     NoMatchingRule,
     UnexpectedToken,
     BindingError(String),
+    ConversionError,
 }
 
-pub use crate::syntax_bridge::{ast_to_token_tree, token_tree_to_ast_item_list, syntax_node_to_token_tree};
+pub use crate::syntax_bridge::{
+    ast_to_token_tree,
+    token_tree_to_ast_item_list,
+    syntax_node_to_token_tree,
+    token_tree_to_expr,
+    token_tree_to_pat,
+    token_tree_to_ty,
+    token_tree_to_macro_items,
+    token_tree_to_macro_stmts,
+};
 
 /// This struct contains AST for a single `macro_rules` definition. What might
 /// be very confusing is that AST has almost exactly the same shape as
@@ -192,23 +202,26 @@ impl_froms!(TokenTree: Leaf, Subtree);
     pub(crate) fn expand_to_syntax(
         rules: &MacroRules,
         invocation: &str,
-    ) -> ra_syntax::TreeArc<ast::SourceFile> {
+    ) -> ra_syntax::TreeArc<ast::MacroItems> {
         let expanded = expand(rules, invocation);
-        token_tree_to_ast_item_list(&expanded)
+        token_tree_to_macro_items(&expanded).unwrap()
     }
 
     pub(crate) fn assert_expansion(rules: &MacroRules, invocation: &str, expansion: &str) {
         let expanded = expand(rules, invocation);
         assert_eq!(expanded.to_string(), expansion);
 
-        let tree = token_tree_to_ast_item_list(&expanded);
+        let tree = token_tree_to_macro_items(&expanded);
 
         // Eat all white space by parse it back and forth
         let expansion = ast::SourceFile::parse(expansion);
         let expansion = syntax_node_to_token_tree(expansion.syntax()).unwrap().0;
-        let file = token_tree_to_ast_item_list(&expansion);
+        let file = token_tree_to_macro_items(&expansion);
 
-        assert_eq!(tree.syntax().debug_dump().trim(), file.syntax().debug_dump().trim());
+        assert_eq!(
+            tree.unwrap().syntax().debug_dump().trim(),
+            file.unwrap().syntax().debug_dump().trim()
+        );
     }
 
     #[test]
@@ -346,11 +359,11 @@ impl_froms!(TokenTree: Leaf, Subtree);
             ",
         );
         let expansion = expand(&rules, "structs!(Foo, Bar)");
-        let tree = token_tree_to_ast_item_list(&expansion);
+        let tree = token_tree_to_macro_items(&expansion);
         assert_eq!(
-            tree.syntax().debug_dump().trim(),
+            tree.unwrap().syntax().debug_dump().trim(),
             r#"
-SOURCE_FILE@[0; 40)
+MACRO_ITEMS@[0; 40)
   STRUCT_DEF@[0; 20)
     STRUCT_KW@[0; 6) "struct"
     NAME@[6; 9)
@@ -444,6 +457,59 @@ SOURCE_FILE@[0; 40)
         assert_expansion(&rules, "foo! { foo, bar }", "fn foo () {let a = foo ; let b = bar ;}");
     }
 
+    #[test]
+    fn test_tt_to_stmts() {
+        let rules = create_rules(
+            r#"
+        macro_rules! foo {
+            () => {
+                 let a = 0;
+                 a = 10 + 1;
+                 a
+            }
+        }
+"#,
+        );
+
+        let expanded = expand(&rules, "foo!{}");
+        let stmts = token_tree_to_macro_stmts(&expanded);
+
+        assert_eq!(
+            stmts.unwrap().syntax().debug_dump().trim(),
+            r#"MACRO_STMTS@[0; 15)
+  LET_STMT@[0; 7)
+    LET_KW@[0; 3) "let"
+    BIND_PAT@[3; 4)
+      NAME@[3; 4)
+        IDENT@[3; 4) "a"
+    EQ@[4; 5) "="
+    LITERAL@[5; 6)
+      INT_NUMBER@[5; 6) "0"
+    SEMI@[6; 7) ";"
+  EXPR_STMT@[7; 14)
+    BIN_EXPR@[7; 13)
+      PATH_EXPR@[7; 8)
+        PATH@[7; 8)
+          PATH_SEGMENT@[7; 8)
+            NAME_REF@[7; 8)
+              IDENT@[7; 8) "a"
+      EQ@[8; 9) "="
+      BIN_EXPR@[9; 13)
+        LITERAL@[9; 11)
+          INT_NUMBER@[9; 11) "10"
+        PLUS@[11; 12) "+"
+        LITERAL@[12; 13)
+          INT_NUMBER@[12; 13) "1"
+    SEMI@[13; 14) ";"
+  EXPR_STMT@[14; 15)
+    PATH_EXPR@[14; 15)
+      PATH@[14; 15)
+        PATH_SEGMENT@[14; 15)
+          NAME_REF@[14; 15)
+            IDENT@[14; 15) "a""#,
+        );
+    }
+
     // The following tests are port from intellij-rust directly
     // https://github.com/intellij-rust/intellij-rust/blob/c4e9feee4ad46e7953b1948c112533360b6087bb/src/test/kotlin/org/rust/lang/core/macros/RsMacroExpansionTest.kt
 
@@ -527,7 +593,7 @@ SOURCE_FILE@[0; 40)
 
         assert_eq!(
             expand_to_syntax(&rules, "foo! { 1 + 1  }").syntax().debug_dump().trim(),
-            r#"SOURCE_FILE@[0; 15)
+            r#"MACRO_ITEMS@[0; 15)
   FN_DEF@[0; 15)
     FN_KW@[0; 2) "fn"
     NAME@[2; 5)
@@ -665,4 +731,95 @@ SOURCE_FILE@[0; 40)
         }
 "#, r#"extern crate a ; mod b ; mod c {} use d ; const E : i32 = 0 ; static F : i32 = 0 ; impl G {} struct H ; enum I {Foo} trait J {} fn h () {} extern {} type T = u8 ;"#);
     }
+
+    #[test]
+    fn test_block() {
+        let rules = create_rules(
+            r#"
+        macro_rules! foo {
+            ($ i:block) => { fn foo() $ i }
+        }
+"#,
+        );
+        assert_expansion(&rules, "foo! { { 1; } }", "fn foo () {1 ;}");
+    }
+
+    #[test]
+    fn test_meta() {
+        let rules = create_rules(
+            r#"
+        macro_rules! foo {
+            ($ i:meta) => (
+                #[$ i]
+                fn bar() {}
+            )
+        }
+"#,
+        );
+        assert_expansion(
+            &rules,
+            r#"foo! { cfg(target_os = "windows") }"#,
+            r#"# [cfg (target_os = "windows")] fn bar () {}"#,
+        );
+    }
+
+    //     #[test]
+    //     fn test_tt_block() {
+    //         let rules = create_rules(
+    //             r#"
+    //         macro_rules! foo {
+    //             ($ i:tt) => { fn foo() $ i }
+    //         }
+    // "#,
+    //         );
+    //         assert_expansion(&rules, r#"foo! { { 1; } }"#, r#"fn foo () {1 ;}"#);
+    //     }
+
+    //     #[test]
+    //     fn test_tt_group() {
+    //         let rules = create_rules(
+    //             r#"
+    //         macro_rules! foo {
+    //              ($($ i:tt)*) => { $($ i)* }
+    //         }
+    // "#,
+    //         );
+    //         assert_expansion(&rules, r#"foo! { fn foo() {} }"#, r#"fn foo () {}"#);
+    //     }
+
+    #[test]
+    fn test_lifetime() {
+        let rules = create_rules(
+            r#"
+        macro_rules! foo {
+              ($ lt:lifetime) => { struct Ref<$ lt>{ s: &$ lt str } }
+        }
+"#,
+        );
+        assert_expansion(&rules, r#"foo!{'a}"#, r#"struct Ref < 'a > {s : & 'a str}"#);
+    }
+
+    #[test]
+    fn test_literal() {
+        let rules = create_rules(
+            r#"
+        macro_rules! foo {
+              ($ type:ty $ lit:literal) => { const VALUE: $ type = $ lit;};
+        }
+"#,
+        );
+        assert_expansion(&rules, r#"foo!(u8 0)"#, r#"const VALUE : u8 = 0 ;"#);
+    }
+
+    #[test]
+    fn test_vis() {
+        let rules = create_rules(
+            r#"
+        macro_rules! foo {
+              ($ vis:vis $ name:ident) => { $ vis fn $ name() {}};
+        }
+"#,
+        );
+        assert_expansion(&rules, r#"foo!(pub foo);"#, r#"pub fn foo () {}"#);
+    }
 }
diff --git a/crates/ra_mbe/src/mbe_expander.rs b/crates/ra_mbe/src/mbe_expander.rs
index acba42809..86867111f 100644
--- a/crates/ra_mbe/src/mbe_expander.rs
+++ b/crates/ra_mbe/src/mbe_expander.rs
@@ -161,11 +161,47 @@ fn match_lhs(pattern: &crate::Subtree, input: &mut TtCursor) -> Result<Bindings,
                             let pat = input.eat_stmt().ok_or(ExpandError::UnexpectedToken)?.clone();
                             res.inner.insert(text.clone(), Binding::Simple(pat.into()));
                         }
+                        "block" => {
+                            let block =
+                                input.eat_block().ok_or(ExpandError::UnexpectedToken)?.clone();
+                            res.inner.insert(text.clone(), Binding::Simple(block.into()));
+                        }
+                        "meta" => {
+                            let meta =
+                                input.eat_meta().ok_or(ExpandError::UnexpectedToken)?.clone();
+                            res.inner.insert(text.clone(), Binding::Simple(meta.into()));
+                        }
+                        // FIXME:
+                        // Enable followiing code when everything is fixed
+                        // At least we can dogfood itself to not stackoverflow
+                        //
+                        // "tt" => {
+                        //     let token = input.eat().ok_or(ExpandError::UnexpectedToken)?.clone();
+                        //     res.inner.insert(text.clone(), Binding::Simple(token.into()));
+                        // }
                         "item" => {
                             let item =
                                 input.eat_item().ok_or(ExpandError::UnexpectedToken)?.clone();
                             res.inner.insert(text.clone(), Binding::Simple(item.into()));
                         }
+                        "lifetime" => {
+                            let lifetime =
+                                input.eat_lifetime().ok_or(ExpandError::UnexpectedToken)?.clone();
+                            res.inner.insert(text.clone(), Binding::Simple(lifetime.into()));
+                        }
+                        "literal" => {
+                            let literal =
+                                input.eat_literal().ok_or(ExpandError::UnexpectedToken)?.clone();
+                            res.inner.insert(
+                                text.clone(),
+                                Binding::Simple(tt::Leaf::from(literal).into()),
+                            );
+                        }
+                        "vis" => {
+                            let vis = input.eat_vis().ok_or(ExpandError::UnexpectedToken)?.clone();
+                            res.inner.insert(text.clone(), Binding::Simple(vis.into()));
+                        }
+
                         _ => return Err(ExpandError::UnexpectedToken),
                     }
                 }
diff --git a/crates/ra_mbe/src/subtree_parser.rs b/crates/ra_mbe/src/subtree_parser.rs
index 195e4c3ac..528aa0f8a 100644
--- a/crates/ra_mbe/src/subtree_parser.rs
+++ b/crates/ra_mbe/src/subtree_parser.rs
@@ -46,10 +46,22 @@ impl<'a> Parser<'a> {
         self.parse(|src, sink| ra_parser::parse_stmt(src, sink, false))
     }
 
+    pub fn parse_block(self) -> Option<tt::TokenTree> {
+        self.parse(ra_parser::parse_block)
+    }
+
+    pub fn parse_meta(self) -> Option<tt::TokenTree> {
+        self.parse(ra_parser::parse_meta)
+    }
+
     pub fn parse_item(self) -> Option<tt::TokenTree> {
         self.parse(ra_parser::parse_item)
     }
 
+    pub fn parse_vis(self) -> Option<tt::TokenTree> {
+        self.parse(ra_parser::parse_vis)
+    }
+
     fn parse<F>(self, f: F) -> Option<tt::TokenTree>
     where
         F: FnOnce(&dyn TokenSource, &mut dyn TreeSink),
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index 28ded7870..38a481029 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -5,6 +5,7 @@ use ra_syntax::{
 };
 
 use crate::subtree_source::{SubtreeTokenSource, Querier};
+use crate::ExpandError;
 
 /// Maps `tt::TokenId` to the relative range of the original token.
 #[derive(Default)]
@@ -30,6 +31,71 @@ pub fn syntax_node_to_token_tree(node: &SyntaxNode) -> Option<(tt::Subtree, Toke
     Some((tt, token_map))
 }
 
+// The following items are what `rustc` macro can be parsed into :
+// link: https://github.com/rust-lang/rust/blob/9ebf47851a357faa4cd97f4b1dc7835f6376e639/src/libsyntax/ext/expand.rs#L141
+// * Expr(P<ast::Expr>)                     -> token_tree_to_expr
+// * Pat(P<ast::Pat>)                       -> token_tree_to_pat
+// * Ty(P<ast::Ty>)                         -> token_tree_to_ty
+// * Stmts(SmallVec<[ast::Stmt; 1]>)        -> token_tree_to_stmts
+// * Items(SmallVec<[P<ast::Item>; 1]>)     -> token_tree_to_items
+//
+// * TraitItems(SmallVec<[ast::TraitItem; 1]>)
+// * ImplItems(SmallVec<[ast::ImplItem; 1]>)
+// * ForeignItems(SmallVec<[ast::ForeignItem; 1]>
+//
+//
+
+/// Parses the token tree (result of macro expansion) to an expression
+pub fn token_tree_to_expr(tt: &tt::Subtree) -> Result<TreeArc<ast::Expr>, ExpandError> {
+    let token_source = SubtreeTokenSource::new(tt);
+    let mut tree_sink = TtTreeSink::new(token_source.querier());
+    ra_parser::parse_expr(&token_source, &mut tree_sink);
+    let syntax = tree_sink.inner.finish();
+    ast::Expr::cast(&syntax)
+        .map(|m| m.to_owned())
+        .ok_or_else(|| crate::ExpandError::ConversionError)
+}
+
+/// Parses the token tree (result of macro expansion) to a Pattern
+pub fn token_tree_to_pat(tt: &tt::Subtree) -> Result<TreeArc<ast::Pat>, ExpandError> {
+    let token_source = SubtreeTokenSource::new(tt);
+    let mut tree_sink = TtTreeSink::new(token_source.querier());
+    ra_parser::parse_pat(&token_source, &mut tree_sink);
+    let syntax = tree_sink.inner.finish();
+    ast::Pat::cast(&syntax).map(|m| m.to_owned()).ok_or_else(|| ExpandError::ConversionError)
+}
+
+/// Parses the token tree (result of macro expansion) to a Type
+pub fn token_tree_to_ty(tt: &tt::Subtree) -> Result<TreeArc<ast::TypeRef>, ExpandError> {
+    let token_source = SubtreeTokenSource::new(tt);
+    let mut tree_sink = TtTreeSink::new(token_source.querier());
+    ra_parser::parse_ty(&token_source, &mut tree_sink);
+    let syntax = tree_sink.inner.finish();
+    ast::TypeRef::cast(&syntax).map(|m| m.to_owned()).ok_or_else(|| ExpandError::ConversionError)
+}
+
+/// Parses the token tree (result of macro expansion) as a sequence of stmts
+pub fn token_tree_to_macro_stmts(
+    tt: &tt::Subtree,
+) -> Result<TreeArc<ast::MacroStmts>, ExpandError> {
+    let token_source = SubtreeTokenSource::new(tt);
+    let mut tree_sink = TtTreeSink::new(token_source.querier());
+    ra_parser::parse_macro_stmts(&token_source, &mut tree_sink);
+    let syntax = tree_sink.inner.finish();
+    ast::MacroStmts::cast(&syntax).map(|m| m.to_owned()).ok_or_else(|| ExpandError::ConversionError)
+}
+
+/// Parses the token tree (result of macro expansion) as a sequence of items
+pub fn token_tree_to_macro_items(
+    tt: &tt::Subtree,
+) -> Result<TreeArc<ast::MacroItems>, ExpandError> {
+    let token_source = SubtreeTokenSource::new(tt);
+    let mut tree_sink = TtTreeSink::new(token_source.querier());
+    ra_parser::parse_macro_items(&token_source, &mut tree_sink);
+    let syntax = tree_sink.inner.finish();
+    ast::MacroItems::cast(&syntax).map(|m| m.to_owned()).ok_or_else(|| ExpandError::ConversionError)
+}
+
 /// Parses the token tree (result of macro expansion) as a sequence of items
 pub fn token_tree_to_ast_item_list(tt: &tt::Subtree) -> TreeArc<ast::SourceFile> {
     let token_source = SubtreeTokenSource::new(tt);
@@ -91,7 +157,10 @@ fn convert_tt(
                         );
                     }
                 } else {
-                    let child = if token.kind().is_keyword() || token.kind() == IDENT {
+                    let child: tt::TokenTree = if token.kind().is_keyword()
+                        || token.kind() == IDENT
+                        || token.kind() == LIFETIME
+                    {
                         let relative_range = token.range() - global_offset;
                         let id = token_map.alloc(relative_range);
                         let text = token.text().clone();
diff --git a/crates/ra_mbe/src/tt_cursor.rs b/crates/ra_mbe/src/tt_cursor.rs
index 484437b0e..741b5ea1c 100644
--- a/crates/ra_mbe/src/tt_cursor.rs
+++ b/crates/ra_mbe/src/tt_cursor.rs
@@ -41,6 +41,13 @@ impl<'a> TtCursor<'a> {
         }
     }
 
+    pub(crate) fn at_literal(&mut self) -> Option<&'a tt::Literal> {
+        match self.current() {
+            Some(tt::TokenTree::Leaf(tt::Leaf::Literal(i))) => Some(i),
+            _ => None,
+        }
+    }
+
     pub(crate) fn bump(&mut self) {
         self.pos += 1;
     }
@@ -79,6 +86,13 @@ impl<'a> TtCursor<'a> {
         })
     }
 
+    pub(crate) fn eat_literal(&mut self) -> Option<&'a tt::Literal> {
+        self.at_literal().map(|i| {
+            self.bump();
+            i
+        })
+    }
+
     pub(crate) fn eat_path(&mut self) -> Option<tt::TokenTree> {
         let parser = Parser::new(&mut self.pos, self.subtree);
         parser.parse_path()
@@ -104,11 +118,37 @@ impl<'a> TtCursor<'a> {
         parser.parse_stmt()
     }
 
+    pub(crate) fn eat_block(&mut self) -> Option<tt::TokenTree> {
+        let parser = Parser::new(&mut self.pos, self.subtree);
+        parser.parse_block()
+    }
+
+    pub(crate) fn eat_meta(&mut self) -> Option<tt::TokenTree> {
+        let parser = Parser::new(&mut self.pos, self.subtree);
+        parser.parse_meta()
+    }
+
     pub(crate) fn eat_item(&mut self) -> Option<tt::TokenTree> {
         let parser = Parser::new(&mut self.pos, self.subtree);
         parser.parse_item()
     }
 
+    pub(crate) fn eat_lifetime(&mut self) -> Option<tt::TokenTree> {
+        // check if it start from "`"
+        if let Some(ident) = self.at_ident() {
+            if ident.text.chars().next()? != '\'' {
+                return None;
+            }
+        }
+
+        self.eat_ident().cloned().map(|ident| tt::Leaf::from(ident).into())
+    }
+
+    pub(crate) fn eat_vis(&mut self) -> Option<tt::TokenTree> {
+        let parser = Parser::new(&mut self.pos, self.subtree);
+        parser.parse_vis()
+    }
+
     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 f8ed1299a..67eae749d 100644
--- a/crates/ra_parser/src/grammar.rs
+++ b/crates/ra_parser/src/grammar.rs
@@ -49,6 +49,27 @@ pub(crate) fn root(p: &mut Parser) {
     m.complete(p, SOURCE_FILE);
 }
 
+pub(crate) fn macro_items(p: &mut Parser) {
+    let m = p.start();
+    items::mod_contents(p, false);
+    m.complete(p, MACRO_ITEMS);
+}
+
+pub(crate) fn macro_stmts(p: &mut Parser) {
+    let m = p.start();
+
+    while !p.at(EOF) {
+        if p.current() == SEMI {
+            p.bump();
+            continue;
+        }
+
+        expressions::stmt(p, expressions::StmtWithSemi::Optional);
+    }
+
+    m.complete(p, MACRO_STMTS);
+}
+
 pub(crate) fn path(p: &mut Parser) {
     paths::type_path(p);
 }
@@ -66,9 +87,45 @@ pub(crate) fn pattern(p: &mut Parser) {
 }
 
 pub(crate) fn stmt(p: &mut Parser, with_semi: bool) {
+    let with_semi = match with_semi {
+        true => expressions::StmtWithSemi::Yes,
+        false => expressions::StmtWithSemi::No,
+    };
+
     expressions::stmt(p, with_semi)
 }
 
+pub(crate) fn block(p: &mut Parser) {
+    expressions::block(p);
+}
+
+// Parse a meta item , which excluded [], e.g : #[ MetaItem ]
+pub(crate) fn meta_item(p: &mut Parser) {
+    fn is_delimiter(p: &mut Parser) -> bool {
+        match p.current() {
+            L_CURLY | L_PAREN | L_BRACK => true,
+            _ => false,
+        }
+    }
+
+    if is_delimiter(p) {
+        items::token_tree(p);
+        return;
+    }
+
+    let m = p.start();
+    while !p.at(EOF) {
+        if is_delimiter(p) {
+            items::token_tree(p);
+            break;
+        } else {
+            p.bump();
+        }
+    }
+
+    m.complete(p, TOKEN_TREE);
+}
+
 pub(crate) fn item(p: &mut Parser) {
     items::item_or_macro(p, true, items::ItemFlavor::Mod)
 }
@@ -110,7 +167,7 @@ impl BlockLike {
     }
 }
 
-fn opt_visibility(p: &mut Parser) -> bool {
+pub(crate) fn opt_visibility(p: &mut Parser) -> bool {
     match p.current() {
         PUB_KW => {
             let m = p.start();
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 06f2b45b1..8df9035e9 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -4,6 +4,12 @@ pub(crate) use self::atom::match_arm_list;
 pub(super) use self::atom::{literal, LITERAL_FIRST};
 use super::*;
 
+pub(super) enum StmtWithSemi {
+    Yes,
+    No,
+    Optional,
+}
+
 const EXPR_FIRST: TokenSet = LHS_FIRST;
 
 pub(super) fn expr(p: &mut Parser) -> BlockLike {
@@ -48,7 +54,7 @@ fn is_expr_stmt_attr_allowed(kind: SyntaxKind) -> bool {
     }
 }
 
-pub(super) fn stmt(p: &mut Parser, with_semi: bool) {
+pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
     // test block_items
     // fn a() { fn b() {} }
     let m = p.start();
@@ -111,13 +117,23 @@ pub(super) fn stmt(p: &mut Parser, with_semi: bool) {
         //     }
         //     test!{}
         // }
-        if with_semi {
-            if blocklike.is_block() {
-                p.eat(SEMI);
-            } else {
-                p.expect(SEMI);
+
+        match with_semi {
+            StmtWithSemi::Yes => {
+                if blocklike.is_block() {
+                    p.eat(SEMI);
+                } else {
+                    p.expect(SEMI);
+                }
+            }
+            StmtWithSemi::No => {}
+            StmtWithSemi::Optional => {
+                if p.at(SEMI) {
+                    p.eat(SEMI);
+                }
             }
         }
+
         m.complete(p, EXPR_STMT);
     }
 
@@ -128,7 +144,7 @@ pub(super) fn stmt(p: &mut Parser, with_semi: bool) {
     //     let c = 92;
     //     let d: i32 = 92;
     // }
-    fn let_stmt(p: &mut Parser, m: Marker, with_semi: bool) {
+    fn let_stmt(p: &mut Parser, m: Marker, with_semi: StmtWithSemi) {
         assert!(p.at(LET_KW));
         p.bump();
         patterns::pattern(p);
@@ -139,8 +155,16 @@ pub(super) fn stmt(p: &mut Parser, with_semi: bool) {
             expressions::expr(p);
         }
 
-        if with_semi {
-            p.expect(SEMI);
+        match with_semi {
+            StmtWithSemi::Yes => {
+                p.expect(SEMI);
+            }
+            StmtWithSemi::No => {}
+            StmtWithSemi::Optional => {
+                if p.at(SEMI) {
+                    p.eat(SEMI);
+                }
+            }
         }
         m.complete(p, LET_STMT);
     }
@@ -160,7 +184,7 @@ pub(crate) fn expr_block_contents(p: &mut Parser) {
             continue;
         }
 
-        stmt(p, true)
+        stmt(p, StmtWithSemi::Yes)
     }
 }
 
diff --git a/crates/ra_parser/src/lib.rs b/crates/ra_parser/src/lib.rs
index 11b5b9a75..970d699c0 100644
--- a/crates/ra_parser/src/lib.rs
+++ b/crates/ra_parser/src/lib.rs
@@ -93,11 +93,35 @@ pub fn parse_stmt(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink,
     parse_from_tokens(token_source, tree_sink, |p| grammar::stmt(p, with_semi));
 }
 
+/// Parse given tokens into the given sink as a block
+pub fn parse_block(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
+    parse_from_tokens(token_source, tree_sink, grammar::block);
+}
+
+pub fn parse_meta(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
+    parse_from_tokens(token_source, tree_sink, grammar::meta_item);
+}
+
 /// Parse given tokens into the given sink as an item
 pub fn parse_item(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
     parse_from_tokens(token_source, tree_sink, grammar::item);
 }
 
+/// Parse given tokens into the given sink as an visibility qualifier
+pub fn parse_vis(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
+    parse_from_tokens(token_source, tree_sink, |p| {
+        grammar::opt_visibility(p);
+    });
+}
+
+pub fn parse_macro_items(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
+    parse_from_tokens(token_source, tree_sink, grammar::macro_items);
+}
+
+pub fn parse_macro_stmts(token_source: &dyn TokenSource, tree_sink: &mut dyn TreeSink) {
+    parse_from_tokens(token_source, tree_sink, grammar::macro_stmts);
+}
+
 /// A parsing function for a specific braced-block.
 pub struct Reparser(fn(&mut parser::Parser));
 
diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs
index 498b0e164..6f984aea1 100644
--- a/crates/ra_parser/src/syntax_kind/generated.rs
+++ b/crates/ra_parser/src/syntax_kind/generated.rs
@@ -233,6 +233,8 @@ pub enum SyntaxKind {
     ARG_LIST,
     TYPE_BOUND,
     TYPE_BOUND_LIST,
+    MACRO_ITEMS,
+    MACRO_STMTS,
     // Technical kind so that we can cast from u16 safely
     #[doc(hidden)]
     __LAST,
@@ -592,6 +594,8 @@ impl SyntaxKind {
             ARG_LIST => &SyntaxInfo { name: "ARG_LIST" },
             TYPE_BOUND => &SyntaxInfo { name: "TYPE_BOUND" },
             TYPE_BOUND_LIST => &SyntaxInfo { name: "TYPE_BOUND_LIST" },
+            MACRO_ITEMS => &SyntaxInfo { name: "MACRO_ITEMS" },
+            MACRO_STMTS => &SyntaxInfo { name: "MACRO_STMTS" },
             TOMBSTONE => &SyntaxInfo { name: "TOMBSTONE" },
             EOF => &SyntaxInfo { name: "EOF" },
             __LAST => &SyntaxInfo { name: "__LAST" },
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 29a7ce166..fae371509 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1771,6 +1771,72 @@ impl MacroCall {
     }
 }
 
+// MacroItems
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct MacroItems {
+    pub(crate) syntax: SyntaxNode,
+}
+unsafe impl TransparentNewType for MacroItems {
+    type Repr = rowan::SyntaxNode;
+}
+
+impl AstNode for MacroItems {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+        match syntax.kind() {
+            MACRO_ITEMS => Some(MacroItems::from_repr(syntax.into_repr())),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for MacroItems {
+    type Owned = TreeArc<MacroItems>;
+    fn to_owned(&self) -> TreeArc<MacroItems> { TreeArc::cast(self.syntax.to_owned()) }
+}
+
+
+impl ast::ModuleItemOwner for MacroItems {}
+impl ast::FnDefOwner for MacroItems {}
+impl MacroItems {}
+
+// MacroStmts
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct MacroStmts {
+    pub(crate) syntax: SyntaxNode,
+}
+unsafe impl TransparentNewType for MacroStmts {
+    type Repr = rowan::SyntaxNode;
+}
+
+impl AstNode for MacroStmts {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
+        match syntax.kind() {
+            MACRO_STMTS => Some(MacroStmts::from_repr(syntax.into_repr())),
+            _ => None,
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+
+impl ToOwned for MacroStmts {
+    type Owned = TreeArc<MacroStmts>;
+    fn to_owned(&self) -> TreeArc<MacroStmts> { TreeArc::cast(self.syntax.to_owned()) }
+}
+
+
+impl MacroStmts {
+    pub fn statements(&self) -> impl Iterator<Item = &Stmt> {
+        super::children(self)
+    }
+
+    pub fn expr(&self) -> Option<&Expr> {
+        super::child_opt(self)
+    }
+}
+
 // MatchArm
 #[derive(Debug, PartialEq, Eq, Hash)]
 #[repr(transparent)]
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 41fe35f08..5bdcf9c84 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -247,6 +247,10 @@ Grammar(
         "ARG_LIST",
         "TYPE_BOUND",
         "TYPE_BOUND_LIST",
+
+        // macro related
+        "MACRO_ITEMS",
+        "MACRO_STMTS",
     ],
     ast: {
         "SourceFile": (
@@ -668,5 +672,16 @@ Grammar(
         "TypeArg": (options: ["TypeRef"]),
         "AssocTypeArg": (options: ["NameRef", "TypeRef"]),
         "LifetimeArg": (),
+
+        "MacroItems": (
+            traits: [ "ModuleItemOwner", "FnDefOwner" ],            
+        ),
+
+        "MacroStmts" : (
+            options: [ "Expr" ],
+            collections: [
+                ["statements", "Stmt"],
+            ],
+        )
     },
 )
diff --git a/docs/user/README.md b/docs/user/README.md
index 33dd4f995..0196bf45f 100644
--- a/docs/user/README.md
+++ b/docs/user/README.md
@@ -78,3 +78,30 @@ Installation:
 to load path and require it in `init.el`
 * run `lsp` in a rust buffer
 * (Optionally) bind commands like `rust-analyzer-join-lines` or `rust-analyzer-extend-selection` to keys
+
+
+## Sublime Text 3
+
+Prequisites:
+
+`LSP` package.
+
+Installation:
+
+* Invoke the command palette with <kbd>Ctrl+Shift+P</kbd>
+* Type `LSP Settings` to open the LSP preferences editor
+* Add the following LSP client definition to your settings:
+
+```json
+"rust-analyzer": {
+    "command": ["rustup", "run", "stable", "ra_lsp_server"],
+    "languageId": "rust",
+    "scopes": ["source.rust"],
+    "syntaxes": [
+        "Packages/Rust/Rust.sublime-syntax",
+        "Packages/Rust Enhanced/RustEnhanced.sublime-syntax"
+    ]
+}
+```
+
+* You can now invoke the command palette and type LSP enable to locally/globally enable the rust-analyzer LSP (type LSP enable, then choose either locally or globally, then select rust-analyzer)
diff --git a/docs/user/features.md b/docs/user/features.md
index 09a7f5a43..cffbb4c7f 100644
--- a/docs/user/features.md
+++ b/docs/user/features.md
@@ -76,6 +76,14 @@ Shows internal statistic about memory usage of rust-analyzer
 
 Manually triggers GC
 
+#### Start Cargo Watch
+
+Start `cargo watch` for live error highlighting. Will prompt to install if it's not already installed.
+
+#### Stop Cargo Watch
+
+Stop `cargo watch`
+
 ### Code Actions (Assists)
 
 These are triggered in a particular context via light bulb. We use custom code on
diff --git a/editors/code/package.json b/editors/code/package.json
index a0454191a..83ceb19f7 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -119,6 +119,16 @@
                 "command": "rust-analyzer.reload",
                 "title": "Restart server",
                 "category": "Rust Analyzer"
+            },
+            {
+                "command": "rust-analyzer.startCargoWatch",
+                "title": "Start Cargo Watch",
+                "category": "Rust Analyzer"
+            },
+            {
+                "command": "rust-analyzer.stopCargoWatch",
+                "title": "Stop Cargo Watch",
+                "category": "Rust Analyzer"
             }
         ],
         "keybindings": [
@@ -250,6 +260,18 @@
                     "${workspaceRoot}"
                 ],
                 "pattern": "$rustc"
+            },
+            {
+                "name": "rustc-watch",
+                "fileLocation": [
+                    "relative",
+                    "${workspaceRoot}"
+                ],
+                "background": {
+                    "beginsPattern": "^\\[Running\\b",
+                    "endsPattern": "^\\[Finished running\\b"
+                },
+                "pattern": "$rustc"
             }
         ]
     }
diff --git a/editors/code/src/commands/cargo_watch.ts b/editors/code/src/commands/cargo_watch.ts
index 32bd38a1c..1d939e28c 100644
--- a/editors/code/src/commands/cargo_watch.ts
+++ b/editors/code/src/commands/cargo_watch.ts
@@ -7,44 +7,55 @@ import { terminate } from '../utils/processes';
 import { LineBuffer } from './line_buffer';
 import { StatusDisplay } from './watch_status';
 
-export class CargoWatchProvider {
-    private diagnosticCollection?: vscode.DiagnosticCollection;
-    private cargoProcess?: child_process.ChildProcess;
-    private outBuffer: string = '';
-    private statusDisplay?: StatusDisplay;
-    private outputChannel?: vscode.OutputChannel;
-
-    public activate(subscriptions: vscode.Disposable[]) {
-        let cargoExists = false;
-        const cargoTomlFile = path.join(
-            vscode.workspace.rootPath!,
-            'Cargo.toml'
+export function registerCargoWatchProvider(
+    subscriptions: vscode.Disposable[]
+): CargoWatchProvider | undefined {
+    let cargoExists = false;
+    const cargoTomlFile = path.join(vscode.workspace.rootPath!, 'Cargo.toml');
+    // Check if the working directory is valid cargo root path
+    try {
+        if (fs.existsSync(cargoTomlFile)) {
+            cargoExists = true;
+        }
+    } catch (err) {
+        cargoExists = false;
+    }
+
+    if (!cargoExists) {
+        vscode.window.showErrorMessage(
+            `Couldn\'t find \'Cargo.toml\' in ${cargoTomlFile}`
         );
-        // Check if the working directory is valid cargo root path
-        try {
-            if (fs.existsSync(cargoTomlFile)) {
-                cargoExists = true;
-            }
-        } catch (err) {
-            cargoExists = false;
-        }
+        return;
+    }
 
-        if (!cargoExists) {
-            vscode.window.showErrorMessage(
-                `Couldn\'t find \'Cargo.toml\' in ${cargoTomlFile}`
-            );
-            return;
-        }
+    const provider = new CargoWatchProvider();
+    subscriptions.push(provider);
+    return provider;
+}
 
-        subscriptions.push(this);
+export class CargoWatchProvider implements vscode.Disposable {
+    private readonly diagnosticCollection: vscode.DiagnosticCollection;
+    private readonly statusDisplay: StatusDisplay;
+    private readonly outputChannel: vscode.OutputChannel;
+    private cargoProcess?: child_process.ChildProcess;
+
+    constructor() {
         this.diagnosticCollection = vscode.languages.createDiagnosticCollection(
             'rustc'
         );
-
-        this.statusDisplay = new StatusDisplay(subscriptions);
+        this.statusDisplay = new StatusDisplay();
         this.outputChannel = vscode.window.createOutputChannel(
             'Cargo Watch Trace'
         );
+    }
+
+    public start() {
+        if (this.cargoProcess) {
+            vscode.window.showInformationMessage(
+                'Cargo Watch is already running'
+            );
+            return;
+        }
 
         let args = 'check --message-format json';
         if (Server.config.cargoWatchOptions.checkArguments.length > 0) {
@@ -95,25 +106,28 @@ export class CargoWatchProvider {
         this.logInfo('cargo-watch started.');
     }
 
-    public dispose(): void {
-        if (this.diagnosticCollection) {
-            this.diagnosticCollection.clear();
-            this.diagnosticCollection.dispose();
-        }
-
+    public stop() {
         if (this.cargoProcess) {
             this.cargoProcess.kill();
             terminate(this.cargoProcess);
+            this.cargoProcess = undefined;
+        } else {
+            vscode.window.showInformationMessage('Cargo Watch is not running');
         }
+    }
 
-        if (this.outputChannel) {
-            this.outputChannel.dispose();
-        }
+    public dispose(): void {
+        this.stop();
+
+        this.diagnosticCollection.clear();
+        this.diagnosticCollection.dispose();
+        this.outputChannel.dispose();
+        this.statusDisplay.dispose();
     }
 
     private logInfo(line: string) {
         if (Server.config.cargoWatchOptions.trace === 'verbose') {
-            this.outputChannel!.append(line);
+            this.outputChannel.append(line);
         }
     }
 
@@ -122,18 +136,18 @@ export class CargoWatchProvider {
             Server.config.cargoWatchOptions.trace === 'error' ||
             Server.config.cargoWatchOptions.trace === 'verbose'
         ) {
-            this.outputChannel!.append(line);
+            this.outputChannel.append(line);
         }
     }
 
     private parseLine(line: string) {
         if (line.startsWith('[Running')) {
-            this.diagnosticCollection!.clear();
-            this.statusDisplay!.show();
+            this.diagnosticCollection.clear();
+            this.statusDisplay.show();
         }
 
         if (line.startsWith('[Finished running')) {
-            this.statusDisplay!.hide();
+            this.statusDisplay.hide();
         }
 
         function getLevel(s: string): vscode.DiagnosticSeverity {
@@ -193,7 +207,7 @@ export class CargoWatchProvider {
 
             // The format of the package_id is "{name} {version} ({source_id})",
             // https://github.com/rust-lang/cargo/blob/37ad03f86e895bb80b474c1c088322634f4725f5/src/cargo/core/package_id.rs#L53
-            this.statusDisplay!.packageName = msg.package_id.split(' ')[0];
+            this.statusDisplay.packageName = msg.package_id.split(' ')[0];
         } else if (data.reason === 'compiler-message') {
             const msg = data.message as RustDiagnostic;
 
diff --git a/editors/code/src/commands/runnables.ts b/editors/code/src/commands/runnables.ts
index c4df24c79..26372c1e8 100644
--- a/editors/code/src/commands/runnables.ts
+++ b/editors/code/src/commands/runnables.ts
@@ -5,7 +5,7 @@ import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
 
 import { Server } from '../server';
-import { CargoWatchProvider } from './cargo_watch';
+import { CargoWatchProvider, registerCargoWatchProvider } from './cargo_watch';
 
 interface RunnablesParams {
     textDocument: lc.TextDocumentIdentifier;
@@ -137,7 +137,7 @@ export async function handleSingle(runnable: Runnable) {
  */
 export async function interactivelyStartCargoWatch(
     context: vscode.ExtensionContext
-) {
+): Promise<CargoWatchProvider | undefined> {
     if (Server.config.cargoWatchOptions.enableOnStartup === 'disabled') {
         return;
     }
@@ -153,6 +153,12 @@ export async function interactivelyStartCargoWatch(
         }
     }
 
+    return startCargoWatch(context);
+}
+
+export async function startCargoWatch(
+    context: vscode.ExtensionContext
+): Promise<CargoWatchProvider | undefined> {
     const execPromise = util.promisify(child_process.exec);
 
     const { stderr } = await execPromise('cargo watch --version').catch(e => e);
@@ -197,6 +203,9 @@ export async function interactivelyStartCargoWatch(
         }
     }
 
-    const validater = new CargoWatchProvider();
-    validater.activate(context.subscriptions);
+    const provider = await registerCargoWatchProvider(context.subscriptions);
+    if (provider) {
+        provider.start();
+    }
+    return provider;
 }
diff --git a/editors/code/src/commands/watch_status.ts b/editors/code/src/commands/watch_status.ts
index 86ae821de..a3b0178f2 100644
--- a/editors/code/src/commands/watch_status.ts
+++ b/editors/code/src/commands/watch_status.ts
@@ -2,19 +2,18 @@ import * as vscode from 'vscode';
 
 const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
-export class StatusDisplay {
+export class StatusDisplay implements vscode.Disposable {
     public packageName?: string;
 
     private i = 0;
     private statusBarItem: vscode.StatusBarItem;
     private timer?: NodeJS.Timeout;
 
-    constructor(subscriptions: vscode.Disposable[]) {
+    constructor() {
         this.statusBarItem = vscode.window.createStatusBarItem(
             vscode.StatusBarAlignment.Left,
             10
         );
-        subscriptions.push(this.statusBarItem);
         this.statusBarItem.hide();
     }
 
@@ -33,7 +32,7 @@ export class StatusDisplay {
                 }
             }, 300);
 
-        this.statusBarItem!.show();
+        this.statusBarItem.show();
     }
 
     public hide() {
@@ -42,7 +41,16 @@ export class StatusDisplay {
             this.timer = undefined;
         }
 
-        this.statusBarItem!.hide();
+        this.statusBarItem.hide();
+    }
+
+    public dispose() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+
+        this.statusBarItem.dispose();
     }
 
     private frame() {
diff --git a/editors/code/src/extension.ts b/editors/code/src/extension.ts
index 1073a36a0..48dd2a614 100644
--- a/editors/code/src/extension.ts
+++ b/editors/code/src/extension.ts
@@ -2,7 +2,11 @@ import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
 
 import * as commands from './commands';
-import { interactivelyStartCargoWatch } from './commands/runnables';
+import { CargoWatchProvider } from './commands/cargo_watch';
+import {
+    interactivelyStartCargoWatch,
+    startCargoWatch
+} from './commands/runnables';
 import { SyntaxTreeContentProvider } from './commands/syntaxTree';
 import * as events from './events';
 import * as notifications from './notifications';
@@ -126,7 +130,24 @@ export function activate(context: vscode.ExtensionContext) {
     vscode.commands.registerCommand('rust-analyzer.reload', reloadCommand);
 
     // Executing `cargo watch` provides us with inline diagnostics on save
-    interactivelyStartCargoWatch(context);
+    let provider: CargoWatchProvider | undefined;
+    interactivelyStartCargoWatch(context).then(p => {
+        provider = p;
+    });
+    registerCommand('rust-analyzer.startCargoWatch', () => {
+        if (provider) {
+            provider.start();
+        } else {
+            startCargoWatch(context).then(p => {
+                provider = p;
+            });
+        }
+    });
+    registerCommand('rust-analyzer.stopCargoWatch', () => {
+        if (provider) {
+            provider.stop();
+        }
+    });
 
     // Start the language server, finally!
     startServer();