32 files changed, 895 insertions, 636 deletions
diff --git a/Cargo.lock b/Cargo.lock
index 9092a87d3..4e08a0bd1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -185,16 +185,6 @@ dependencies = [
 ]
 [[package]]
-name = "clap"
-version = "2.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "unicode-width 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-[[package]]
 name = "clicolors-control"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -838,6 +828,11 @@ dependencies = [
 ]
 [[package]]
+name = "pico-args"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[[package]]
 name = "ppv-lite86"
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -930,9 +925,9 @@ dependencies = [
 name = "ra_cli"
 version = "0.1.0"
 dependencies = [
- "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "flexi_logger 0.14.3 (registry+https://github.com/rust-lang/crates.io-index)",
 "indicatif 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pico-args 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "ra_batch 0.1.0",
 "ra_db 0.1.0",
 "ra_hir 0.1.0",
@@ -1051,6 +1046,7 @@ dependencies = [
 "ra_tt 0.1.0",
 "rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
 "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "test_utils 0.1.0",
 ]
 [[package]]
@@ -1111,8 +1107,8 @@ dependencies = [
 name = "ra_tools"
 version = "0.1.0"
 dependencies = [
- "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pico-args 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 "proc-macro2 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 "ron 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1594,14 +1590,6 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 [[package]]
-name = "textwrap"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "unicode-width 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-[[package]]
 name = "thread_local"
 version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1795,7 +1783,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum chalk-rust-ir 0.1.0 (git+https://github.com/rust-lang/chalk.git)" = "<none>"
 "checksum chalk-solve 0.1.0 (git+https://github.com/rust-lang/chalk.git)" = "<none>"
 "checksum chrono 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e8493056968583b0193c1bb04d6f7684586f3726992d6c573261941a895dbd68"
-"checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9"
 "checksum clicolors-control 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "90082ee5dcdd64dc4e9e0d37fbf3ee325419e39c0092191e0393df65518f741e"
 "checksum cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
 "checksum console 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b147390a412132d75d10dd3b7b175a69cf5fd95032f7503c7091b8831ba10242"
@@ -1873,6 +1860,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum paste-impl 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "4214c9e912ef61bf42b81ba9a47e8aad1b2ffaf739ab162bf96d1e011f54e6c5"
 "checksum percent-encoding 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
 "checksum petgraph 0.4.13 (registry+https://github.com/rust-lang/crates.io-index)" = "9c3659d1ee90221741f65dd128d9998311b0e40c5d3c23a62445938214abce4f"
+"checksum pico-args 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2fce25154205cf4360b456fd7d48994afe20663b77e3bd3d0a353a2fccf7f22c"
 "checksum ppv-lite86 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e3cbf9f658cdb5000fcf6f362b8ea2ba154b9f146a61c7a20d647034c6b6561b"
 "checksum proc-macro-hack 0.5.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e688f31d92ffd7c1ddc57a1b4e6d773c0f2a14ee437a4b0a4f5a69c80eb221c8"
 "checksum proc-macro2 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "175a40b9cf564ce9bf050654633dbf339978706b8ead1a907bb970b63185dd95"
@@ -1930,7 +1918,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
 "checksum termios 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "72b620c5ea021d75a735c943269bb07d30c9b77d6ac6b236bc8b5c496ef05625"
 "checksum text_unit 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e08bbcb7a3adbda0eb23431206b653bdad3d8dea311e72d36bf2215e27a42579"
-"checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
 "checksum thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
 "checksum threadpool 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e2f0c90a5f3459330ac8bc0d2f879c693bb7a2f59689c1083fc4ef83834da865"
 "checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
diff --git a/crates/ra_cli/Cargo.toml b/crates/ra_cli/Cargo.toml
index 205dd223b..d42ac3ad4 100644
--- a/crates/ra_cli/Cargo.toml
+++ b/crates/ra_cli/Cargo.toml
@@ -6,7 +6,7 @@ authors = ["rust-analyzer developers"]
 publish = false
 [dependencies]
-clap = { version = "2.32.0", default-features = false }
+pico-args = "0.2.0"
 flexi_logger = "0.14.0"
 indicatif = "0.11.0"
diff --git a/crates/ra_cli/src/help.rs b/crates/ra_cli/src/help.rs
new file mode 100644
index 000000000..5171578f0
--- /dev/null
+++ b/crates/ra_cli/src/help.rs
@@ -0,0 +1,72 @@
+pub const GLOBAL_HELP: &str = "ra-cli
+USAGE:
+    ra_cli <SUBCOMMAND>
+FLAGS:
+    -h, --help        Prints help information
+SUBCOMMANDS:
+    analysis-bench
+    analysis-stats
+    highlight
+    parse
+    symbols";
+pub const ANALYSIS_BENCH_HELP: &str = "ra_cli-analysis-bench
+USAGE:
+    ra_cli analysis-bench [FLAGS] [OPTIONS] [PATH]
+FLAGS:
+    -h, --help        Prints help information
+    -v, --verbose
+    
+OPTIONS:
+    --complete <PATH:LINE:COLUMN>    Compute completions at this location
+    --highlight <PATH>               Hightlight this file
+    
+ARGS:
+    <PATH>    Project to analyse";
+pub const ANALYSIS_STATS_HELP: &str = "ra-cli-analysis-stats
+USAGE:
+    ra_cli analysis-stats [FLAGS] [OPTIONS] [PATH]
+    
+FLAGS:
+    -h, --help            Prints help information
+        --memory-usage
+    -v, --verbose
+    
+OPTIONS:
+    -o <ONLY>
+    
+ARGS:
+    <PATH>";
+pub const HIGHLIGHT_HELP: &str = "ra-cli-highlight
+    
+USAGE:
+    ra_cli highlight [FLAGS]
+    
+FLAGS:
+    -h, --help       Prints help information
+    -r, --rainbow";
+pub const SYMBOLS_HELP: &str = "ra-cli-symbols
+    
+USAGE:
+    ra_cli highlight [FLAGS]
+    
+FLAGS:
+    -h, --help    Prints help inforamtion";
+pub const PARSE_HELP: &str = "ra-cli-parse
+    
+USAGE:
+    ra_cli parse [FLAGS]
+    
+FLAGS:
+    -h, --help       Prints help inforamtion
+        --no-dump";
diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
index de8191ca3..e6334cf56 100644
--- a/crates/ra_cli/src/main.rs
+++ b/crates/ra_cli/src/main.rs
@@ -1,10 +1,11 @@
 mod analysis_stats;
 mod analysis_bench;
+mod help;
-use std::{error::Error, io::Read};
+use std::{error::Error, fmt::Write, io::Read};
-use clap::{App, Arg, SubCommand};
 use flexi_logger::Logger;
+use pico_args::Arguments;
 use ra_ide_api::{file_structure, Analysis};
 use ra_prof::profile;
 use ra_syntax::{AstNode, SourceFile};
@@ -13,77 +14,89 @@ type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
 fn main() -> Result<()> {
    Logger::with_env().start()?;
-    let matches = App::new("ra-cli")
-        .setting(clap::AppSettings::SubcommandRequiredElseHelp)
+    let subcommand = match std::env::args_os().nth(1) {
-        .subcommand(SubCommand::with_name("parse").arg(Arg::with_name("no-dump").long("--no-dump")))
+        None => {
-        .subcommand(SubCommand::with_name("symbols"))
+            eprintln!("{}", help::GLOBAL_HELP);
-        .subcommand(
+            return Ok(());
-            SubCommand::with_name("highlight")
+        }
-                .arg(Arg::with_name("rainbow").short("r").long("rainbow")),
+        Some(s) => s,
-        )
+    };
-        .subcommand(
+    let mut matches = Arguments::from_vec(std::env::args_os().skip(2).collect());
-            SubCommand::with_name("analysis-stats")
-                .arg(Arg::with_name("verbose").short("v").long("verbose"))
+    match &*subcommand.to_string_lossy() {
-                .arg(Arg::with_name("memory-usage").long("memory-usage"))
+        "parse" => {
-                .arg(Arg::with_name("only").short("o").takes_value(true))
+            if matches.contains(["-h", "--help"]) {
-                .arg(Arg::with_name("path")),
+                eprintln!("{}", help::PARSE_HELP);
-        )
+                return Ok(());
-        .subcommand(
+            }
-            SubCommand::with_name("analysis-bench")
+            let no_dump = matches.contains("--no-dump");
-                .arg(Arg::with_name("verbose").short("v").long("verbose"))
+            matches.finish().or_else(handle_extra_flags)?;
-                .arg(
-                    Arg::with_name("highlight")
-                        .long("highlight")
-                        .takes_value(true)
-                        .conflicts_with("complete")
-                        .value_name("PATH")
-                        .help("highlight this file"),
-                )
-                .arg(
-                    Arg::with_name("complete")
-                        .long("complete")
-                        .takes_value(true)
-                        .conflicts_with("highlight")
-                        .value_name("PATH:LINE:COLUMN")
-                        .help("compute completions at this location"),
-                )
-                .arg(Arg::with_name("path").value_name("PATH").help("project to analyze")),
-        )
-        .get_matches();
-    match matches.subcommand() {
-        ("parse", Some(matches)) => {
            let _p = profile("parsing");
            let file = file()?;
-            if !matches.is_present("no-dump") {
+            if !no_dump {
                println!("{:#?}", file.syntax());
            }
            std::mem::forget(file);
        }
-        ("symbols", _) => {
+        "symbols" => {
+            if matches.contains(["-h", "--help"]) {
+                eprintln!("{}", help::SYMBOLS_HELP);
+                return Ok(());
+            }
+            matches.finish().or_else(handle_extra_flags)?;
            let file = file()?;
            for s in file_structure(&file) {
                println!("{:?}", s);
            }
        }
-        ("highlight", Some(matches)) => {
+        "highlight" => {
+            if matches.contains(["-h", "--help"]) {
+                eprintln!("{}", help::HIGHLIGHT_HELP);
+                return Ok(());
+            }
+            let rainbow_opt = matches.contains(["-r", "--rainbow"]);
+            matches.finish().or_else(handle_extra_flags)?;
            let (analysis, file_id) = Analysis::from_single_file(read_stdin()?);
-            let html = analysis.highlight_as_html(file_id, matches.is_present("rainbow")).unwrap();
+            let html = analysis.highlight_as_html(file_id, rainbow_opt).unwrap();
            println!("{}", html);
        }
-        ("analysis-stats", Some(matches)) => {
+        "analysis-stats" => {
-            let verbose = matches.is_present("verbose");
+            if matches.contains(["-h", "--help"]) {
-            let memory_usage = matches.is_present("memory-usage");
+                eprintln!("{}", help::ANALYSIS_STATS_HELP);
-            let path = matches.value_of("path").unwrap_or("");
+                return Ok(());
-            let only = matches.value_of("only");
+            }
-            analysis_stats::run(verbose, memory_usage, path.as_ref(), only)?;
+            let verbose = matches.contains(["-v", "--verbose"]);
+            let memory_usage = matches.contains("--memory-usage");
+            let path: String = matches.value_from_str("--path")?.unwrap_or_default();
+            let only = matches.value_from_str(["-o", "--only"])?.map(|v: String| v.to_owned());
+            matches.finish().or_else(handle_extra_flags)?;
+            analysis_stats::run(
+                verbose,
+                memory_usage,
+                path.as_ref(),
+                only.as_ref().map(String::as_ref),
+            )?;
        }
-        ("analysis-bench", Some(matches)) => {
+        "analysis-bench" => {
-            let verbose = matches.is_present("verbose");
+            if matches.contains(["-h", "--help"]) {
-            let path = matches.value_of("path").unwrap_or("");
+                eprintln!("{}", help::ANALYSIS_BENCH_HELP);
-            let op = if let Some(path) = matches.value_of("highlight") {
+                return Ok(());
+            }
+            let verbose = matches.contains(["-v", "--verbose"]);
+            let path: String = matches.value_from_str("--path")?.unwrap_or_default();
+            let highlight_path = matches.value_from_str("--highlight")?;
+            let complete_path = matches.value_from_str("--complete")?;
+            if highlight_path.is_some() && complete_path.is_some() {
+                panic!("either --highlight or --complete must be set, not both")
+            }
+            let op = if let Some(path) = highlight_path {
+                let path: String = path;
                analysis_bench::Op::Highlight { path: path.into() }
-            } else if let Some(path_line_col) = matches.value_of("complete") {
+            } else if let Some(path_line_col) = complete_path {
-                let (path_line, column) = rsplit_at_char(path_line_col, ':')?;
+                let path_line_col: String = path_line_col;
+                let (path_line, column) = rsplit_at_char(path_line_col.as_str(), ':')?;
                let (path, line) = rsplit_at_char(path_line, ':')?;
                analysis_bench::Op::Complete {
                    path: path.into(),
@@ -93,13 +106,27 @@ fn main() -> Result<()> {
            } else {
                panic!("either --highlight or --complete must be set")
            };
+            matches.finish().or_else(handle_extra_flags)?;
            analysis_bench::run(verbose, path.as_ref(), op)?;
        }
-        _ => unreachable!(),
+        _ => eprintln!("{}", help::GLOBAL_HELP),
    }
    Ok(())
 }
+fn handle_extra_flags(e: pico_args::Error) -> Result<()> {
+    if let pico_args::Error::UnusedArgsLeft(flags) = e {
+        let mut invalid_flags = String::new();
+        for flag in flags {
+            write!(&mut invalid_flags, "{}, ", flag)?;
+        }
+        let (invalid_flags, _) = invalid_flags.split_at(invalid_flags.len() - 2);
+        Err(format!("Invalid flags: {}", invalid_flags).into())
+    } else {
+        Err(e.to_string().into())
+    }
+}
 fn file() -> Result<SourceFile> {
    let text = read_stdin()?;
    Ok(SourceFile::parse(&text).tree())
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index e0d0d4209..9ea4e695d 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -90,7 +90,7 @@ impl HirFileId {
            })
            .ok()?;
        match macro_file.macro_file_kind {
-            MacroFileKind::Items => Some(Parse::to_syntax(mbe::token_tree_to_ast_item_list(&tt))),
+            MacroFileKind::Items => mbe::token_tree_to_items(&tt).ok().map(Parse::to_syntax),
            MacroFileKind::Expr => mbe::token_tree_to_expr(&tt).ok().map(Parse::to_syntax),
        }
    }
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
index c646d3d00..04b97cb90 100644
--- a/crates/ra_hir/src/nameres/raw.rs
+++ b/crates/ra_hir/src/nameres/raw.rs
@@ -76,8 +76,10 @@ impl RawItems {
            source_map: ImportSourceMap::default(),
        };
        if let Some(node) = db.parse_or_expand(file_id) {
-            if let Some(source_file) = ast::SourceFile::cast(node) {
+            if let Some(source_file) = ast::SourceFile::cast(node.clone()) {
                collector.process_module(None, source_file);
+            } else if let Some(item_list) = ast::MacroItems::cast(node) {
+                collector.process_module(None, item_list);
            }
        }
        (Arc::new(collector.raw_items), Arc::new(collector.source_map))
diff --git a/crates/ra_mbe/Cargo.toml b/crates/ra_mbe/Cargo.toml
index 68f559295..b058dde91 100644
--- a/crates/ra_mbe/Cargo.toml
+++ b/crates/ra_mbe/Cargo.toml
@@ -12,3 +12,7 @@ itertools = "0.8.0"
 rustc-hash = "1.0.0"
 smallvec = "0.6.9"
 log = "0.4.5"
+[dev-dependencies]
+test_utils = { path = "../test_utils" }
diff --git a/crates/ra_mbe/src/lib.rs b/crates/ra_mbe/src/lib.rs
index 52c3d03b5..f07f000ff 100644
--- a/crates/ra_mbe/src/lib.rs
+++ b/crates/ra_mbe/src/lib.rs
@@ -41,8 +41,8 @@ pub enum ExpandError {
 }
 pub use crate::syntax_bridge::{
-    ast_to_token_tree, syntax_node_to_token_tree, token_tree_to_ast_item_list, token_tree_to_expr,
+    ast_to_token_tree, syntax_node_to_token_tree, token_tree_to_expr, token_tree_to_items,
-    token_tree_to_macro_items, token_tree_to_macro_stmts, token_tree_to_pat, token_tree_to_ty,
+    token_tree_to_macro_stmts, token_tree_to_pat, token_tree_to_ty,
 };
 /// This struct contains AST for a single `macro_rules` definition. What might
diff --git a/crates/ra_mbe/src/mbe_expander.rs b/crates/ra_mbe/src/mbe_expander.rs
index 01641fdee..78df96880 100644
--- a/crates/ra_mbe/src/mbe_expander.rs
+++ b/crates/ra_mbe/src/mbe_expander.rs
@@ -81,21 +81,26 @@ struct Bindings {
 #[derive(Debug)]
 enum Binding {
-    Simple(tt::TokenTree),
+    Fragment(Fragment),
    Nested(Vec<Binding>),
    Empty,
 }
+#[derive(Debug, Clone)]
+enum Fragment {
+    /// token fragments are just copy-pasted into the output
+    Tokens(tt::TokenTree),
+    /// Ast fragments are inserted with fake delimiters, so as to make things
+    /// like `$i * 2` where `$i = 1 + 1` work as expectd.
+    Ast(tt::TokenTree),
+}
 impl Bindings {
    fn push_optional(&mut self, name: &SmolStr) {
        // FIXME: Do we have a better way to represent an empty token ?
        // Insert an empty subtree for empty token
-        self.inner.insert(
+        let tt = tt::Subtree { delimiter: tt::Delimiter::None, token_trees: vec![] }.into();
-            name.clone(),
+        self.inner.insert(name.clone(), Binding::Fragment(Fragment::Tokens(tt)));
-            Binding::Simple(
-                tt::Subtree { delimiter: tt::Delimiter::None, token_trees: vec![] }.into(),
-            ),
-        );
    }
    fn push_empty(&mut self, name: &SmolStr) {
@@ -106,13 +111,13 @@ impl Bindings {
        self.inner.contains_key(name)
    }
-    fn get(&self, name: &SmolStr, nesting: &[usize]) -> Result<&tt::TokenTree, ExpandError> {
+    fn get(&self, name: &SmolStr, nesting: &[usize]) -> Result<&Fragment, ExpandError> {
        let mut b = self.inner.get(name).ok_or_else(|| {
            ExpandError::BindingError(format!("could not find binding `{}`", name))
        })?;
        for &idx in nesting.iter() {
            b = match b {
-                Binding::Simple(_) => break,
+                Binding::Fragment(_) => break,
                Binding::Nested(bs) => bs.get(idx).ok_or_else(|| {
                    ExpandError::BindingError(format!("could not find nested binding `{}`", name))
                })?,
@@ -125,7 +130,7 @@ impl Bindings {
            };
        }
        match b {
-            Binding::Simple(it) => Ok(it),
+            Binding::Fragment(it) => Ok(it),
            Binding::Nested(_) => Err(ExpandError::BindingError(format!(
                "expected simple binding, found nested binding `{}`",
                name
@@ -195,8 +200,8 @@ fn match_lhs(pattern: &crate::Subtree, input: &mut TtCursor) -> Result<Bindings,
                crate::Leaf::Var(crate::Var { text, kind }) => {
                    let kind = kind.as_ref().ok_or(ExpandError::UnexpectedToken)?;
                    match match_meta_var(kind.as_str(), input)? {
-                        Some(tt) => {
+                        Some(fragment) => {
-                            res.inner.insert(text.clone(), Binding::Simple(tt));
+                            res.inner.insert(text.clone(), Binding::Fragment(fragment));
                        }
                        None => res.push_optional(text),
                    }
@@ -292,7 +297,7 @@ fn match_lhs(pattern: &crate::Subtree, input: &mut TtCursor) -> Result<Bindings,
    Ok(res)
 }
-fn match_meta_var(kind: &str, input: &mut TtCursor) -> Result<Option<tt::TokenTree>, ExpandError> {
+fn match_meta_var(kind: &str, input: &mut TtCursor) -> Result<Option<Fragment>, ExpandError> {
    let fragment = match kind {
        "path" => Path,
        "expr" => Expr,
@@ -303,7 +308,7 @@ fn match_meta_var(kind: &str, input: &mut TtCursor) -> Result<Option<tt::TokenTr
        "meta" => MetaItem,
        "item" => Item,
        _ => {
-            let binding = match kind {
+            let tt = match kind {
                "ident" => {
                    let ident = input.eat_ident().ok_or(ExpandError::UnexpectedToken)?.clone();
                    tt::Leaf::from(ident).into()
@@ -321,11 +326,12 @@ fn match_meta_var(kind: &str, input: &mut TtCursor) -> Result<Option<tt::TokenTr
                },
                _ => return Err(ExpandError::UnexpectedToken),
            };
-            return Ok(Some(binding));
+            return Ok(Some(Fragment::Tokens(tt)));
        }
    };
-    let binding = input.eat_fragment(fragment).ok_or(ExpandError::UnexpectedToken)?;
+    let tt = input.eat_fragment(fragment).ok_or(ExpandError::UnexpectedToken)?;
-    Ok(Some(binding))
+    let fragment = if kind == "expr" { Fragment::Ast(tt) } else { Fragment::Tokens(tt) };
+    Ok(Some(fragment))
 }
 #[derive(Debug)]
@@ -339,45 +345,20 @@ fn expand_subtree(
    template: &crate::Subtree,
    ctx: &mut ExpandCtx,
 ) -> Result<tt::Subtree, ExpandError> {
-    let token_trees = template
+    let mut buf: Vec<tt::TokenTree> = Vec::new();
-        .token_trees
+    for tt in template.token_trees.iter() {
-        .iter()
+        let tt = expand_tt(tt, ctx)?;
-        .map(|it| expand_tt(it, ctx))
+        push_fragment(&mut buf, tt);
-        .filter(|it| {
-            // Filter empty subtree
-            if let Ok(tt::TokenTree::Subtree(subtree)) = it {
-                subtree.delimiter != tt::Delimiter::None || !subtree.token_trees.is_empty()
-            } else {
-                true
-            }
-        })
-        .collect::<Result<Vec<_>, ExpandError>>()?;
-    Ok(tt::Subtree { token_trees, delimiter: template.delimiter })
-}
-/// Reduce single token subtree to single token
-/// In `tt` matcher case, all tt tokens will be braced by a Delimiter::None
-/// which makes all sort of problems.
-fn reduce_single_token(mut subtree: tt::Subtree) -> tt::TokenTree {
-    if subtree.delimiter != tt::Delimiter::None || subtree.token_trees.len() != 1 {
-        return subtree.into();
    }
-    match subtree.token_trees.pop().unwrap() {
+    Ok(tt::Subtree { delimiter: template.delimiter, token_trees: buf })
-        tt::TokenTree::Subtree(subtree) => reduce_single_token(subtree),
-        tt::TokenTree::Leaf(token) => token.into(),
-    }
 }
-fn expand_tt(
+fn expand_tt(template: &crate::TokenTree, ctx: &mut ExpandCtx) -> Result<Fragment, ExpandError> {
-    template: &crate::TokenTree,
-    ctx: &mut ExpandCtx,
-) -> Result<tt::TokenTree, ExpandError> {
    let res: tt::TokenTree = match template {
        crate::TokenTree::Subtree(subtree) => expand_subtree(subtree, ctx)?.into(),
        crate::TokenTree::Repeat(repeat) => {
-            let mut token_trees: Vec<tt::TokenTree> = Vec::new();
+            let mut buf: Vec<tt::TokenTree> = Vec::new();
            ctx.nesting.push(0);
            // Dirty hack to make macro-expansion terminate.
            // This should be replaced by a propper macro-by-example implementation
@@ -418,23 +399,23 @@ fn expand_tt(
                let idx = ctx.nesting.pop().unwrap();
                ctx.nesting.push(idx + 1);
-                token_trees.push(reduce_single_token(t));
+                push_subtree(&mut buf, t);
                if let Some(ref sep) = repeat.separator {
                    match sep {
                        crate::Separator::Ident(ident) => {
                            has_seps = 1;
-                            token_trees.push(tt::Leaf::from(ident.clone()).into());
+                            buf.push(tt::Leaf::from(ident.clone()).into());
                        }
                        crate::Separator::Literal(lit) => {
                            has_seps = 1;
-                            token_trees.push(tt::Leaf::from(lit.clone()).into());
+                            buf.push(tt::Leaf::from(lit.clone()).into());
                        }
                        crate::Separator::Puncts(puncts) => {
                            has_seps = puncts.len();
                            for punct in puncts {
-                                token_trees.push(tt::Leaf::from(*punct).into());
+                                buf.push(tt::Leaf::from(*punct).into());
                            }
                        }
                    }
@@ -450,16 +431,16 @@ fn expand_tt(
            ctx.nesting.pop().unwrap();
            for _ in 0..has_seps {
-                token_trees.pop();
+                buf.pop();
            }
            if crate::RepeatKind::OneOrMore == repeat.kind && counter == 0 {
                return Err(ExpandError::UnexpectedToken);
            }
-            // Check if it is a singel token subtree without any delimiter
+            // Check if it is a single token subtree without any delimiter
            // e.g {Delimiter:None> ['>'] /Delimiter:None>}
-            reduce_single_token(tt::Subtree { token_trees, delimiter: tt::Delimiter::None })
+            tt::Subtree { delimiter: tt::Delimiter::None, token_trees: buf }.into()
        }
        crate::TokenTree::Leaf(leaf) => match leaf {
            crate::Leaf::Ident(ident) => {
@@ -500,20 +481,15 @@ fn expand_tt(
                    }
                    .into()
                } else {
-                    let tkn = ctx.bindings.get(&v.text, &ctx.nesting)?.clone();
+                    let fragment = ctx.bindings.get(&v.text, &ctx.nesting)?.clone();
                    ctx.var_expanded = true;
+                    return Ok(fragment);
-                    if let tt::TokenTree::Subtree(subtree) = tkn {
-                        reduce_single_token(subtree)
-                    } else {
-                        tkn
-                    }
                }
            }
            crate::Leaf::Literal(l) => tt::Leaf::from(tt::Literal { text: l.text.clone() }).into(),
        },
    };
-    Ok(res)
+    Ok(Fragment::Tokens(res))
 }
 #[cfg(test)]
@@ -586,3 +562,17 @@ mod tests {
        expand_rule(&rules.rules[0], &invocation_tt)
    }
 }
+fn push_fragment(buf: &mut Vec<tt::TokenTree>, fragment: Fragment) {
+    match fragment {
+        Fragment::Tokens(tt::TokenTree::Subtree(tt)) => push_subtree(buf, tt),
+        Fragment::Tokens(tt) | Fragment::Ast(tt) => buf.push(tt),
+    }
+}
+fn push_subtree(buf: &mut Vec<tt::TokenTree>, tt: tt::Subtree) {
+    match tt.delimiter {
+        tt::Delimiter::None => buf.extend(tt.token_trees),
+        _ => buf.push(tt.into()),
+    }
+}
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index a380b1cfd..2d035307b 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -46,31 +46,19 @@ pub fn syntax_node_to_token_tree(node: &SyntaxNode) -> Option<(tt::Subtree, Toke
 // * TraitItems(SmallVec<[ast::TraitItem; 1]>)
 // * ImplItems(SmallVec<[ast::ImplItem; 1]>)
 // * ForeignItems(SmallVec<[ast::ForeignItem; 1]>
-//
-//
-fn token_tree_to_syntax_node<F>(tt: &tt::Subtree, f: F) -> Result<Parse<SyntaxNode>, ExpandError>
-where
-    F: Fn(&mut dyn ra_parser::TokenSource, &mut dyn ra_parser::TreeSink),
-{
-    let tokens = [tt.clone().into()];
-    let buffer = TokenBuffer::new(&tokens);
-    let mut token_source = SubtreeTokenSource::new(&buffer);
-    let mut tree_sink = TtTreeSink::new(buffer.begin());
-    f(&mut token_source, &mut tree_sink);
-    if tree_sink.roots.len() != 1 {
-        return Err(ExpandError::ConversionError);
-    }
-    //FIXME: would be cool to report errors
-    let parse = tree_sink.inner.finish();
-    Ok(parse)
-}
 fn fragment_to_syntax_node(
    tt: &tt::Subtree,
    fragment_kind: FragmentKind,
 ) -> Result<Parse<SyntaxNode>, ExpandError> {
-    let tokens = [tt.clone().into()];
+    let tmp;
+    let tokens = match tt {
+        tt::Subtree { delimiter: tt::Delimiter::None, token_trees } => token_trees.as_slice(),
+        _ => {
+            tmp = [tt.clone().into()];
+            &tmp[..]
+        }
+    };
    let buffer = TokenBuffer::new(&tokens);
    let mut token_source = SubtreeTokenSource::new(&buffer);
    let mut tree_sink = TtTreeSink::new(buffer.begin());
@@ -108,17 +96,11 @@ pub fn token_tree_to_macro_stmts(tt: &tt::Subtree) -> Result<Parse<ast::MacroStm
 }
 /// Parses the token tree (result of macro expansion) as a sequence of items
-pub fn token_tree_to_macro_items(tt: &tt::Subtree) -> Result<Parse<ast::MacroItems>, ExpandError> {
+pub fn token_tree_to_items(tt: &tt::Subtree) -> Result<Parse<ast::MacroItems>, ExpandError> {
    let parse = fragment_to_syntax_node(tt, Items)?;
    parse.cast().ok_or_else(|| crate::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) -> Parse<ast::SourceFile> {
-    let parse = token_tree_to_syntax_node(tt, ra_parser::parse).unwrap();
-    parse.cast().unwrap()
-}
 impl TokenMap {
    pub fn relative_range_of(&self, tt: tt::TokenId) -> Option<TextRange> {
        let idx = tt.0 as usize;
diff --git a/crates/ra_mbe/src/tests.rs b/crates/ra_mbe/src/tests.rs
index 034ea639b..312fa4626 100644
--- a/crates/ra_mbe/src/tests.rs
+++ b/crates/ra_mbe/src/tests.rs
@@ -1,4 +1,5 @@
 use ra_syntax::{ast, AstNode, NodeOrToken};
+use test_utils::assert_eq_text;
 use super::*;
@@ -69,7 +70,7 @@ pub(crate) fn expand(rules: &MacroRules, invocation: &str) -> tt::Subtree {
 pub(crate) fn expand_to_items(rules: &MacroRules, invocation: &str) -> ast::MacroItems {
    let expanded = expand(rules, invocation);
-    token_tree_to_macro_items(&expanded).unwrap().tree()
+    token_tree_to_items(&expanded).unwrap().tree()
 }
 #[allow(unused)]
@@ -152,11 +153,10 @@ pub(crate) fn assert_expansion(
    // wrap the given text to a macro call
    let expected = text_to_tokentree(&expected);
    let (expanded_tree, expected_tree) = match kind {
        MacroKind::Items => {
-            let expanded_tree = token_tree_to_macro_items(&expanded).unwrap().tree();
+            let expanded_tree = token_tree_to_items(&expanded).unwrap().tree();
-            let expected_tree = token_tree_to_macro_items(&expected).unwrap().tree();
+            let expected_tree = token_tree_to_items(&expected).unwrap().tree();
            (
                debug_dump_ignore_spaces(expanded_tree.syntax()).trim().to_string(),
@@ -178,7 +178,7 @@ pub(crate) fn assert_expansion(
    let expected_tree = expected_tree.replace("C_C__C", "$crate");
    assert_eq!(
        expanded_tree, expected_tree,
-        "left => {}\nright => {}",
+        "\nleft:\n{}\nright:\n{}",
        expanded_tree, expected_tree,
    );
@@ -410,7 +410,7 @@ fn test_expand_to_item_list() {
            ",
    );
    let expansion = expand(&rules, "structs!(Foo, Bar);");
-    let tree = token_tree_to_macro_items(&expansion).unwrap().tree();
+    let tree = token_tree_to_items(&expansion).unwrap().tree();
    assert_eq!(
        format!("{:#?}", tree.syntax()).trim(),
        r#"
@@ -667,9 +667,9 @@ fn test_expr_order() {
        }
 "#,
    );
+    let dump = format!("{:#?}", expand_to_items(&rules, "foo! { 1 + 1  }").syntax());
-    assert_eq!(
+    assert_eq_text!(
-        format!("{:#?}", expand_to_items(&rules, "foo! { 1 + 1  }").syntax()).trim(),
+        dump.trim(),
        r#"MACRO_ITEMS@[0; 15)
  FN_DEF@[0; 15)
    FN_KW@[0; 2) "fn"
diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs
index 4e6f2f558..0158f9b8a 100644
--- a/crates/ra_parser/src/grammar.rs
+++ b/crates/ra_parser/src/grammar.rs
@@ -210,7 +210,7 @@ fn opt_visibility(p: &mut Parser) -> bool {
        //
        // test crate_keyword_path
        // fn foo() { crate::foo(); }
-        T![crate] if p.nth(1) != T![::] => {
+        T![crate] if !p.nth_at(1, T![::]) => {
            let m = p.start();
            p.bump_any();
            m.complete(p, VISIBILITY);
@@ -245,7 +245,7 @@ fn abi(p: &mut Parser) {
 fn opt_fn_ret_type(p: &mut Parser) -> bool {
    if p.at(T![->]) {
        let m = p.start();
-        p.bump_any();
+        p.bump(T![->]);
        types::type_(p);
        m.complete(p, RET_TYPE);
        true
diff --git a/crates/ra_parser/src/grammar/expressions.rs b/crates/ra_parser/src/grammar/expressions.rs
index 30036eb46..1dd9a586c 100644
--- a/crates/ra_parser/src/grammar/expressions.rs
+++ b/crates/ra_parser/src/grammar/expressions.rs
@@ -14,20 +14,17 @@ const EXPR_FIRST: TokenSet = LHS_FIRST;
 pub(super) fn expr(p: &mut Parser) -> BlockLike {
    let r = Restrictions { forbid_structs: false, prefer_stmt: false };
-    let mut dollar_lvl = 0;
+    expr_bp(p, r, 1).1
-    expr_bp(p, r, 1, &mut dollar_lvl).1
 }
 pub(super) fn expr_stmt(p: &mut Parser) -> (Option<CompletedMarker>, BlockLike) {
    let r = Restrictions { forbid_structs: false, prefer_stmt: true };
-    let mut dollar_lvl = 0;
+    expr_bp(p, r, 1)
-    expr_bp(p, r, 1, &mut dollar_lvl)
 }
 fn expr_no_struct(p: &mut Parser) {
    let r = Restrictions { forbid_structs: true, prefer_stmt: false };
-    let mut dollar_lvl = 0;
+    expr_bp(p, r, 1);
-    expr_bp(p, r, 1, &mut dollar_lvl);
 }
 // test block
@@ -212,72 +209,53 @@ struct Restrictions {
    prefer_stmt: bool,
 }
-enum Op {
+/// Binding powers of operators for a Pratt parser.
-    Simple,
+///
-    Composite(SyntaxKind, u8),
+/// See https://www.oilshell.org/blog/2016/11/03.html
-}
+#[rustfmt::skip]
+fn current_op(p: &Parser) -> (u8, SyntaxKind) {
-fn current_op(p: &Parser) -> (u8, Op) {
+    const NOT_AN_OP: (u8, SyntaxKind) = (0, T![@]);
-    if let Some(t) = p.current3() {
+    match p.current() {
-        match t {
+        T![|] if p.at(T![||])  => (3,  T![||]),
-            (T![<], T![<], T![=]) => return (1, Op::Composite(T![<<=], 3)),
+        T![|] if p.at(T![|=])  => (1,  T![|=]),
-            (T![>], T![>], T![=]) => return (1, Op::Composite(T![>>=], 3)),
+        T![|]                  => (6,  T![|]),
-            _ => (),
+        T![>] if p.at(T![>>=]) => (1,  T![>>=]),
-        }
+        T![>] if p.at(T![>>])  => (9,  T![>>]),
-    }
+        T![>] if p.at(T![>=])  => (5,  T![>=]),
+        T![>]                  => (5,  T![>]),
-    if let Some(t) = p.current2() {
+        T![=] if p.at(T![=>])  => NOT_AN_OP,
-        match t {
+        T![=] if p.at(T![==])  => (5,  T![==]),
-            (T![+], T![=]) => return (1, Op::Composite(T![+=], 2)),
+        T![=]                  => (1,  T![=]),
-            (T![-], T![=]) => return (1, Op::Composite(T![-=], 2)),
+        T![<] if p.at(T![<=])  => (5,  T![<=]),
-            (T![*], T![=]) => return (1, Op::Composite(T![*=], 2)),
+        T![<] if p.at(T![<<=]) => (1,  T![<<=]),
-            (T![%], T![=]) => return (1, Op::Composite(T![%=], 2)),
+        T![<] if p.at(T![<<])  => (9,  T![<<]),
-            (T![/], T![=]) => return (1, Op::Composite(T![/=], 2)),
+        T![<]                  => (5,  T![<]),
-            (T![|], T![=]) => return (1, Op::Composite(T![|=], 2)),
+        T![+] if p.at(T![+=])  => (1,  T![+=]),
-            (T![&], T![=]) => return (1, Op::Composite(T![&=], 2)),
+        T![+]                  => (10, T![+]),
-            (T![^], T![=]) => return (1, Op::Composite(T![^=], 2)),
+        T![^] if p.at(T![^=])  => (1,  T![^=]),
-            (T![|], T![|]) => return (3, Op::Composite(T![||], 2)),
+        T![^]                  => (7,  T![^]),
-            (T![&], T![&]) => return (4, Op::Composite(T![&&], 2)),
+        T![%] if p.at(T![%=])  => (1,  T![%=]),
-            (T![<], T![=]) => return (5, Op::Composite(T![<=], 2)),
+        T![%]                  => (11, T![%]),
-            (T![>], T![=]) => return (5, Op::Composite(T![>=], 2)),
+        T![&] if p.at(T![&=])  => (1,  T![&=]),
-            (T![<], T![<]) => return (9, Op::Composite(T![<<], 2)),
+        T![&] if p.at(T![&&])  => (4,  T![&&]),
-            (T![>], T![>]) => return (9, Op::Composite(T![>>], 2)),
+        T![&]                  => (8,  T![&]),
-            _ => (),
+        T![/] if p.at(T![/=])  => (1,  T![/=]),
-        }
+        T![/]                  => (11, T![/]),
+        T![*] if p.at(T![*=])  => (1,  T![*=]),
+        T![*]                  => (11, T![*]),
+        T![.] if p.at(T![..=]) => (2,  T![..=]),
+        T![.] if p.at(T![..])  => (2,  T![..]),
+        T![!] if p.at(T![!=])  => (5,  T![!=]),
+        T![-] if p.at(T![-=])  => (1,  T![-=]),
+        T![-]                  => (10, T![-]),
+        _                      => NOT_AN_OP
    }
-    let bp = match p.current() {
-        T![=] => 1,
-        T![..] | T![..=] => 2,
-        T![==] | T![!=] | T![<] | T![>] => 5,
-        T![|] => 6,
-        T![^] => 7,
-        T![&] => 8,
-        T![-] | T![+] => 10,
-        T![*] | T![/] | T![%] => 11,
-        _ => 0,
-    };
-    (bp, Op::Simple)
 }
 // Parses expression with binding power of at least bp.
-fn expr_bp(
+fn expr_bp(p: &mut Parser, r: Restrictions, bp: u8) -> (Option<CompletedMarker>, BlockLike) {
-    p: &mut Parser,
+    let mut lhs = match lhs(p, r) {
-    r: Restrictions,
-    mut bp: u8,
-    dollar_lvl: &mut usize,
-) -> (Option<CompletedMarker>, BlockLike) {
-    // `newly_dollar_open` is a flag indicated that dollar is just closed after lhs, e.g.
-    // `$1$ + a`
-    // We use this flag to skip handling it.
-    let mut newly_dollar_open = if p.at_l_dollar() {
-        *dollar_lvl += p.eat_l_dollars();
-        true
-    } else {
-        false
-    };
-    let mut lhs = match lhs(p, r, dollar_lvl) {
        Some((lhs, blocklike)) => {
            // test stmt_bin_expr_ambiguity
            // fn foo() {
@@ -293,42 +271,23 @@ fn expr_bp(
    };
    loop {
-        if *dollar_lvl > 0 && p.at_r_dollar() {
-            *dollar_lvl -= p.eat_r_dollars(*dollar_lvl);
-            if !newly_dollar_open {
-                // We "pump" bp for make it highest priority
-                bp = 255;
-            }
-            newly_dollar_open = false;
-        }
        let is_range = p.at(T![..]) || p.at(T![..=]);
        let (op_bp, op) = current_op(p);
        if op_bp < bp {
            break;
        }
        let m = lhs.precede(p);
-        match op {
+        p.bump(op);
-            Op::Simple => p.bump_any(),
-            Op::Composite(kind, n) => {
-                p.bump_compound(kind, n);
-            }
-        }
-        expr_bp(p, r, op_bp + 1, dollar_lvl);
+        expr_bp(p, r, op_bp + 1);
        lhs = m.complete(p, if is_range { RANGE_EXPR } else { BIN_EXPR });
    }
    (Some(lhs), BlockLike::NotBlock)
 }
-const LHS_FIRST: TokenSet =
+const LHS_FIRST: TokenSet = atom::ATOM_EXPR_FIRST.union(token_set![AMP, STAR, EXCL, DOT, MINUS]);
-    atom::ATOM_EXPR_FIRST.union(token_set![AMP, STAR, EXCL, DOTDOT, DOTDOTEQ, MINUS]);
-fn lhs(
+fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
-    p: &mut Parser,
-    r: Restrictions,
-    dollar_lvl: &mut usize,
-) -> Option<(CompletedMarker, BlockLike)> {
    let m;
    let kind = match p.current() {
        // test ref_expr
@@ -353,17 +312,20 @@ fn lhs(
            p.bump_any();
            PREFIX_EXPR
        }
-        // test full_range_expr
-        // fn foo() { xs[..]; }
-        T![..] | T![..=] => {
-            m = p.start();
-            p.bump_any();
-            if p.at_ts(EXPR_FIRST) {
-                expr_bp(p, r, 2, dollar_lvl);
-            }
-            return Some((m.complete(p, RANGE_EXPR), BlockLike::NotBlock));
-        }
        _ => {
+            // test full_range_expr
+            // fn foo() { xs[..]; }
+            for &op in [T![..=], T![..]].iter() {
+                if p.at(op) {
+                    m = p.start();
+                    p.bump(op);
+                    if p.at_ts(EXPR_FIRST) {
+                        expr_bp(p, r, 2);
+                    }
+                    return Some((m.complete(p, RANGE_EXPR), BlockLike::NotBlock));
+                }
+            }
            // test expression_after_block
            // fn foo() {
            //    let mut p = F{x: 5};
@@ -374,7 +336,7 @@ fn lhs(
            return Some(postfix_expr(p, lhs, blocklike, !(r.prefer_stmt && blocklike.is_block())));
        }
    };
-    expr_bp(p, r, 255, dollar_lvl);
+    expr_bp(p, r, 255);
    Some((m.complete(p, kind), BlockLike::NotBlock))
 }
@@ -399,29 +361,13 @@ fn postfix_expr(
            // }
            T!['('] if allow_calls => call_expr(p, lhs),
            T!['['] if allow_calls => index_expr(p, lhs),
-            T![.] if p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth(2) == T![::]) => {
+            T![.] => match postfix_dot_expr(p, lhs) {
-                method_call_expr(p, lhs)
+                Ok(it) => it,
-            }
+                Err(it) => {
-            T![.] if p.nth(1) == AWAIT_KW => {
+                    lhs = it;
-                // test await_expr
+                    break;
-                // fn foo() {
+                }
-                //     x.await;
+            },
-                //     x.0.await;
-                //     x.0().await?.hello();
-                // }
-                let m = lhs.precede(p);
-                p.bump_any();
-                p.bump_any();
-                m.complete(p, AWAIT_EXPR)
-            }
-            T![.] => field_expr(p, lhs),
-            // test postfix_range
-            // fn foo() { let x = 1..; }
-            T![..] | T![..=] if !EXPR_FIRST.contains(p.nth(1)) => {
-                let m = lhs.precede(p);
-                p.bump_any();
-                m.complete(p, RANGE_EXPR)
-            }
            T![?] => try_expr(p, lhs),
            T![as] => cast_expr(p, lhs),
            _ => break,
@@ -429,7 +375,46 @@ fn postfix_expr(
        allow_calls = true;
        block_like = BlockLike::NotBlock;
    }
-    (lhs, block_like)
+    return (lhs, block_like);
+    fn postfix_dot_expr(
+        p: &mut Parser,
+        lhs: CompletedMarker,
+    ) -> Result<CompletedMarker, CompletedMarker> {
+        assert!(p.at(T![.]));
+        if p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth_at(2, T![::])) {
+            return Ok(method_call_expr(p, lhs));
+        }
+        // test await_expr
+        // fn foo() {
+        //     x.await;
+        //     x.0.await;
+        //     x.0().await?.hello();
+        // }
+        if p.nth(1) == T![await] {
+            let m = lhs.precede(p);
+            p.bump(T![.]);
+            p.bump(T![await]);
+            return Ok(m.complete(p, AWAIT_EXPR));
+        }
+        // test postfix_range
+        // fn foo() { let x = 1..; }
+        for &(op, la) in [(T![..=], 3), (T![..], 2)].iter() {
+            if p.at(op) {
+                return if EXPR_FIRST.contains(p.nth(la)) {
+                    Err(lhs)
+                } else {
+                    let m = lhs.precede(p);
+                    p.bump(op);
+                    Ok(m.complete(p, RANGE_EXPR))
+                };
+            }
+        }
+        Ok(field_expr(p, lhs))
+    }
 }
 // test call_expr
@@ -465,7 +450,7 @@ fn index_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
 //     y.bar::<T>(1, 2,);
 // }
 fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
-    assert!(p.at(T![.]) && p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth(2) == T![::]));
+    assert!(p.at(T![.]) && p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth_at(2, T![::])));
    let m = lhs.precede(p);
    p.bump_any();
    name_ref(p);
@@ -567,7 +552,7 @@ fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
            record_field_list(p);
            (m.complete(p, RECORD_LIT), BlockLike::NotBlock)
        }
-        T![!] => {
+        T![!] if !p.at(T![!=]) => {
            let block_like = items::macro_call_after_excl(p);
            (m.complete(p, MACRO_CALL), block_like)
        }
@@ -601,8 +586,8 @@ pub(crate) fn record_field_list(p: &mut Parser) {
                }
                m.complete(p, RECORD_FIELD);
            }
-            T![..] => {
+            T![.] if p.at(T![..]) => {
-                p.bump_any();
+                p.bump(T![..]);
                expr(p);
            }
            T!['{'] => error_block(p, "expected a field"),
diff --git a/crates/ra_parser/src/grammar/expressions/atom.rs b/crates/ra_parser/src/grammar/expressions/atom.rs
index cea79cf6f..6e295fbf9 100644
--- a/crates/ra_parser/src/grammar/expressions/atom.rs
+++ b/crates/ra_parser/src/grammar/expressions/atom.rs
@@ -69,6 +69,7 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
    let done = match p.current() {
        T!['('] => tuple_expr(p),
        T!['['] => array_expr(p),
+        L_DOLLAR => meta_var_expr(p),
        T![|] => lambda_expr(p),
        T![move] if la == T![|] => lambda_expr(p),
        T![async] if la == T![|] || (la == T![move] && p.nth(2) == T![|]) => lambda_expr(p),
@@ -554,3 +555,27 @@ fn box_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
    }
    m.complete(p, BOX_EXPR)
 }
+/// Expression from `$var` macro expansion, wrapped in dollars
+fn meta_var_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(L_DOLLAR));
+    let m = p.start();
+    p.bump(L_DOLLAR);
+    let (completed, _is_block) =
+        expr_bp(p, Restrictions { forbid_structs: false, prefer_stmt: false }, 1);
+    match (completed, p.current()) {
+        (Some(it), R_DOLLAR) => {
+            p.bump(R_DOLLAR);
+            m.abandon(p);
+            it
+        }
+        _ => {
+            while !p.at(R_DOLLAR) {
+                p.bump_any()
+            }
+            p.bump(R_DOLLAR);
+            m.complete(p, ERROR)
+        }
+    }
+}
diff --git a/crates/ra_parser/src/grammar/items.rs b/crates/ra_parser/src/grammar/items.rs
index f27cc85ff..eff9d67e4 100644
--- a/crates/ra_parser/src/grammar/items.rs
+++ b/crates/ra_parser/src/grammar/items.rs
@@ -422,7 +422,7 @@ pub(crate) fn token_tree(p: &mut Parser) {
                return;
            }
            T![')'] | T![']'] => p.err_and_bump("unmatched brace"),
-            _ => p.bump_raw(),
+            _ => p.bump_any(),
        }
    }
    p.expect(closing_paren_kind);
diff --git a/crates/ra_parser/src/grammar/items/use_item.rs b/crates/ra_parser/src/grammar/items/use_item.rs
index 7a1693a34..f28f522b8 100644
--- a/crates/ra_parser/src/grammar/items/use_item.rs
+++ b/crates/ra_parser/src/grammar/items/use_item.rs
@@ -13,9 +13,8 @@ pub(super) fn use_item(p: &mut Parser, m: Marker) {
 /// so handles both `some::path::{inner::path}` and `inner::path` in
 /// `use some::path::{inner::path};`
 fn use_tree(p: &mut Parser) {
-    let la = p.nth(1);
    let m = p.start();
-    match (p.current(), la) {
+    match p.current() {
        // Finish the use_tree for cases of e.g.
        // `use some::path::{self, *};` or `use *;`
        // This does not handle cases such as `use some::path::*`
@@ -28,15 +27,15 @@ fn use_tree(p: &mut Parser) {
        // use ::*;
        // use some::path::{*};
        // use some::path::{::*};
-        (T![*], _) => p.bump_any(),
+        T![*] => p.bump(T![*]),
-        (T![::], T![*]) => {
+        T![:] if p.at(T![::]) && p.nth(2) == T![*] => {
            // Parse `use ::*;`, which imports all from the crate root in Rust 2015
            // This is invalid inside a use_tree_list, (e.g. `use some::path::{::*}`)
            // but still parses and errors later: ('crate root in paths can only be used in start position')
            // FIXME: Add this error (if not out of scope)
            // In Rust 2018, it is always invalid (see above)
-            p.bump_any();
+            p.bump(T![::]);
-            p.bump_any();
+            p.bump(T![*]);
        }
        // Open a use tree list
        // Handles cases such as `use {some::path};` or `{inner::path}` in
@@ -47,10 +46,11 @@ fn use_tree(p: &mut Parser) {
        // use {path::from::root}; // Rust 2015
        // use ::{some::arbritrary::path}; // Rust 2015
        // use ::{{{crate::export}}}; // Nonsensical but perfectly legal nestnig
-        (T!['{'], _) | (T![::], T!['{']) => {
+        T!['{'] => {
-            if p.at(T![::]) {
+            use_tree_list(p);
-                p.bump_any();
+        }
-            }
+        T![:] if p.at(T![::]) && p.nth(2) == T!['{'] => {
+            p.bump(T![::]);
            use_tree_list(p);
        }
        // Parse a 'standard' path.
@@ -80,8 +80,8 @@ fn use_tree(p: &mut Parser) {
                    // use Trait as _;
                    opt_alias(p);
                }
-                T![::] => {
+                T![:] if p.at(T![::]) => {
-                    p.bump_any();
+                    p.bump(T![::]);
                    match p.current() {
                        T![*] => {
                            p.bump_any();
diff --git a/crates/ra_parser/src/grammar/params.rs b/crates/ra_parser/src/grammar/params.rs
index 56e457325..5893b22fd 100644
--- a/crates/ra_parser/src/grammar/params.rs
+++ b/crates/ra_parser/src/grammar/params.rs
@@ -80,7 +80,7 @@ fn value_parameter(p: &mut Parser, flavor: Flavor) {
    match flavor {
        Flavor::OptionalType | Flavor::Normal => {
            patterns::pattern(p);
-            if p.at(T![:]) || flavor.type_required() {
+            if p.at(T![:]) && !p.at(T![::]) || flavor.type_required() {
                types::ascription(p)
            }
        }
@@ -96,10 +96,11 @@ fn value_parameter(p: &mut Parser, flavor: Flavor) {
            // trait Foo {
            //     fn bar(_: u64, mut x: i32);
            // }
-            if (la0 == IDENT || la0 == T![_]) && la1 == T![:]
+            if (la0 == IDENT || la0 == T![_]) && la1 == T![:] && !p.nth_at(1, T![::])
                || la0 == T![mut] && la1 == IDENT && la2 == T![:]
-                || la0 == T![&] && la1 == IDENT && la2 == T![:]
+                || la0 == T![&]
-                || la0 == T![&] && la1 == T![mut] && la2 == IDENT && la3 == T![:]
+                    && (la1 == IDENT && la2 == T![:] && !p.nth_at(2, T![::])
+                        || la1 == T![mut] && la2 == IDENT && la3 == T![:] && !p.nth_at(3, T![::]))
            {
                patterns::pattern(p);
                types::ascription(p);
diff --git a/crates/ra_parser/src/grammar/paths.rs b/crates/ra_parser/src/grammar/paths.rs
index 345c93f55..24b65128e 100644
--- a/crates/ra_parser/src/grammar/paths.rs
+++ b/crates/ra_parser/src/grammar/paths.rs
@@ -1,7 +1,7 @@
 use super::*;
 pub(super) const PATH_FIRST: TokenSet =
-    token_set![IDENT, SELF_KW, SUPER_KW, CRATE_KW, COLONCOLON, L_ANGLE];
+    token_set![IDENT, SELF_KW, SUPER_KW, CRATE_KW, COLON, L_ANGLE];
 pub(super) fn is_path_start(p: &Parser) -> bool {
    is_use_path_start(p) || p.at(T![<])
@@ -9,7 +9,8 @@ pub(super) fn is_path_start(p: &Parser) -> bool {
 pub(super) fn is_use_path_start(p: &Parser) -> bool {
    match p.current() {
-        IDENT | T![self] | T![super] | T![crate] | T![::] => true,
+        IDENT | T![self] | T![super] | T![crate] => true,
+        T![:] if p.at(T![::]) => true,
        _ => false,
    }
 }
@@ -38,13 +39,13 @@ fn path(p: &mut Parser, mode: Mode) {
    path_segment(p, mode, true);
    let mut qual = path.complete(p, PATH);
    loop {
-        let use_tree = match p.nth(1) {
+        let use_tree = match p.nth(2) {
            T![*] | T!['{'] => true,
            _ => false,
        };
        if p.at(T![::]) && !use_tree {
            let path = qual.precede(p);
-            p.bump_any();
+            p.bump(T![::]);
            path_segment(p, mode, false);
            let path = path.complete(p, PATH);
            qual = path;
diff --git a/crates/ra_parser/src/grammar/patterns.rs b/crates/ra_parser/src/grammar/patterns.rs
index d2f4296f8..dd1d25b07 100644
--- a/crates/ra_parser/src/grammar/patterns.rs
+++ b/crates/ra_parser/src/grammar/patterns.rs
@@ -34,17 +34,20 @@ pub(super) fn pattern_r(p: &mut Parser, recovery_set: TokenSet) {
        //         200 .. 301=> (),
        //     }
        // }
-        if p.at(T![...]) || p.at(T![..=]) || p.at(T![..]) {
+        for &range_op in [T![...], T![..=], T![..]].iter() {
-            let m = lhs.precede(p);
+            if p.at(range_op) {
-            p.bump_any();
+                let m = lhs.precede(p);
-            atom_pat(p, recovery_set);
+                p.bump(range_op);
-            m.complete(p, RANGE_PAT);
+                atom_pat(p, recovery_set);
+                m.complete(p, RANGE_PAT);
+                return;
+            }
        }
        // test marco_pat
        // fn main() {
        //     let m!(x) = 0;
        // }
-        else if lhs.kind() == PATH_PAT && p.at(T![!]) {
+        if lhs.kind() == PATH_PAT && p.at(T![!]) {
            let m = lhs.precede(p);
            items::macro_call_after_excl(p);
            m.complete(p, MACRO_CALL);
@@ -56,14 +59,16 @@ const PAT_RECOVERY_SET: TokenSet =
    token_set![LET_KW, IF_KW, WHILE_KW, LOOP_KW, MATCH_KW, R_PAREN, COMMA];
 fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
-    // Checks the token after an IDENT to see if a pattern is a path (Struct { .. }) or macro
-    // (T![x]).
-    let is_path_or_macro_pat =
-        |la1| la1 == T![::] || la1 == T!['('] || la1 == T!['{'] || la1 == T![!];
    let m = match p.nth(0) {
        T![box] => box_pat(p),
-        T![ref] | T![mut] | IDENT if !is_path_or_macro_pat(p.nth(1)) => bind_pat(p, true),
+        T![ref] | T![mut] => bind_pat(p, true),
+        IDENT => match p.nth(1) {
+            // Checks the token after an IDENT to see if a pattern is a path (Struct { .. }) or macro
+            // (T![x]).
+            T!['('] | T!['{'] | T![!] => path_pat(p),
+            T![:] if p.nth_at(1, T![::]) => path_pat(p),
+            _ => bind_pat(p, true),
+        },
        _ if paths::is_use_path_start(p) => path_pat(p),
        _ if is_literal_pat_start(p) => literal_pat(p),
@@ -158,7 +163,7 @@ fn record_field_pat_list(p: &mut Parser) {
    p.bump_any();
    while !p.at(EOF) && !p.at(T!['}']) {
        match p.current() {
-            T![..] => p.bump_any(),
+            T![.] if p.at(T![..]) => p.bump(T![..]),
            IDENT if p.nth(1) == T![:] => record_field_pat(p),
            T!['{'] => error_block(p, "expected ident"),
            T![box] => {
@@ -237,7 +242,7 @@ fn slice_pat(p: &mut Parser) -> CompletedMarker {
 fn pat_list(p: &mut Parser, ket: SyntaxKind) {
    while !p.at(EOF) && !p.at(ket) {
        match p.current() {
-            T![..] => p.bump_any(),
+            T![.] if p.at(T![..]) => p.bump(T![..]),
            _ => {
                if !p.at_ts(PATTERN_FIRST) {
                    p.error("expected a pattern");
diff --git a/crates/ra_parser/src/grammar/type_args.rs b/crates/ra_parser/src/grammar/type_args.rs
index e100af531..edc7d4ff2 100644
--- a/crates/ra_parser/src/grammar/type_args.rs
+++ b/crates/ra_parser/src/grammar/type_args.rs
@@ -2,19 +2,16 @@ use super::*;
 pub(super) fn opt_type_arg_list(p: &mut Parser, colon_colon_required: bool) {
    let m;
-    match (colon_colon_required, p.nth(0), p.nth(1)) {
+    if p.at(T![::]) && p.nth(2) == T![<] {
-        (_, T![::], T![<]) => {
+        m = p.start();
-            m = p.start();
+        p.bump(T![::]);
-            p.bump_any();
+        p.bump(T![<]);
-            p.bump_any();
+    } else if !colon_colon_required && p.at(T![<]) && p.nth(1) != T![=] {
-        }
+        m = p.start();
-        (false, T![<], T![=]) => return,
+        p.bump(T![<]);
-        (false, T![<], _) => {
+    } else {
-            m = p.start();
+        return;
-            p.bump_any();
+    }
-        }
-        _ => return,
-    };
    while !p.at(EOF) && !p.at(T![>]) {
        type_arg(p);
@@ -37,7 +34,7 @@ fn type_arg(p: &mut Parser) {
        }
        // test associated_type_bounds
        // fn print_all<T: Iterator<Item: Display>>(printables: T) {}
-        IDENT if p.nth(1) == T![:] => {
+        IDENT if p.nth(1) == T![:] && p.nth(2) != T![:] => {
            name_ref(p);
            type_params::bounds(p);
            m.complete(p, ASSOC_TYPE_ARG);
diff --git a/crates/ra_parser/src/parser.rs b/crates/ra_parser/src/parser.rs
index d8567e84b..a2ac363fb 100644
--- a/crates/ra_parser/src/parser.rs
+++ b/crates/ra_parser/src/parser.rs
@@ -5,8 +5,8 @@ use drop_bomb::DropBomb;
 use crate::{
    event::Event,
    ParseError,
-    SyntaxKind::{self, EOF, ERROR, TOMBSTONE},
+    SyntaxKind::{self, EOF, ERROR, L_DOLLAR, R_DOLLAR, TOMBSTONE},
-    Token, TokenSet, TokenSource, T,
+    TokenSet, TokenSource, T,
 };
 /// `Parser` struct provides the low-level API for
@@ -40,38 +40,6 @@ impl<'t> Parser<'t> {
        self.nth(0)
    }
-    /// Returns the kinds of the current two tokens, if they are not separated
-    /// by trivia.
-    ///
-    /// Useful for parsing things like `>>`.
-    pub(crate) fn current2(&self) -> Option<(SyntaxKind, SyntaxKind)> {
-        let c1 = self.nth(0);
-        let c2 = self.nth(1);
-        if self.token_source.current().is_jointed_to_next {
-            Some((c1, c2))
-        } else {
-            None
-        }
-    }
-    /// Returns the kinds of the current three tokens, if they are not separated
-    /// by trivia.
-    ///
-    /// Useful for parsing things like `=>>`.
-    pub(crate) fn current3(&self) -> Option<(SyntaxKind, SyntaxKind, SyntaxKind)> {
-        let c1 = self.nth(0);
-        let c2 = self.nth(1);
-        let c3 = self.nth(2);
-        if self.token_source.current().is_jointed_to_next
-            && self.token_source.lookahead_nth(1).is_jointed_to_next
-        {
-            Some((c1, c2, c3))
-        } else {
-            None
-        }
-    }
    /// Lookahead operation: returns the kind of the next nth
    /// token.
    pub(crate) fn nth(&self, n: usize) -> SyntaxKind {
@@ -81,33 +49,93 @@ impl<'t> Parser<'t> {
        assert!(steps <= 10_000_000, "the parser seems stuck");
        self.steps.set(steps + 1);
-        // It is beecause the Dollar will appear between nth
+        self.token_source.lookahead_nth(n).kind
-        // Following code skips through it
-        let mut non_dollars_count = 0;
-        let mut i = 0;
-        loop {
-            let token = self.token_source.lookahead_nth(i);
-            let mut kind = token.kind;
-            if let Some((composited, step)) = self.is_composite(token, i) {
-                kind = composited;
-                i += step;
-            } else {
-                i += 1;
-            }
-            match kind {
-                EOF => return EOF,
-                SyntaxKind::L_DOLLAR | SyntaxKind::R_DOLLAR => {}
-                _ if non_dollars_count == n => return kind,
-                _ => non_dollars_count += 1,
-            }
-        }
    }
    /// Checks if the current token is `kind`.
    pub(crate) fn at(&self, kind: SyntaxKind) -> bool {
-        self.current() == kind
+        self.nth_at(0, kind)
+    }
+    pub(crate) fn nth_at(&self, n: usize, kind: SyntaxKind) -> bool {
+        match kind {
+            T![-=] => self.at_composite2(n, T![-], T![=]),
+            T![->] => self.at_composite2(n, T![-], T![>]),
+            T![::] => self.at_composite2(n, T![:], T![:]),
+            T![!=] => self.at_composite2(n, T![!], T![=]),
+            T![..] => self.at_composite2(n, T![.], T![.]),
+            T![*=] => self.at_composite2(n, T![*], T![=]),
+            T![/=] => self.at_composite2(n, T![/], T![=]),
+            T![&&] => self.at_composite2(n, T![&], T![&]),
+            T![&=] => self.at_composite2(n, T![&], T![=]),
+            T![%=] => self.at_composite2(n, T![%], T![=]),
+            T![^=] => self.at_composite2(n, T![^], T![=]),
+            T![+=] => self.at_composite2(n, T![+], T![=]),
+            T![<<] => self.at_composite2(n, T![<], T![<]),
+            T![<=] => self.at_composite2(n, T![<], T![=]),
+            T![==] => self.at_composite2(n, T![=], T![=]),
+            T![=>] => self.at_composite2(n, T![=], T![>]),
+            T![>=] => self.at_composite2(n, T![>], T![=]),
+            T![>>] => self.at_composite2(n, T![>], T![>]),
+            T![|=] => self.at_composite2(n, T![|], T![=]),
+            T![||] => self.at_composite2(n, T![|], T![|]),
+            T![...] => self.at_composite3(n, T![.], T![.], T![.]),
+            T![..=] => self.at_composite3(n, T![.], T![.], T![=]),
+            T![<<=] => self.at_composite3(n, T![<], T![<], T![=]),
+            T![>>=] => self.at_composite3(n, T![>], T![>], T![=]),
+            _ => self.token_source.lookahead_nth(n).kind == kind,
+        }
+    }
+    /// Consume the next token if `kind` matches.
+    pub(crate) fn eat(&mut self, kind: SyntaxKind) -> bool {
+        if !self.at(kind) {
+            return false;
+        }
+        let n_raw_tokens = match kind {
+            T![-=]
+            | T![->]
+            | T![::]
+            | T![!=]
+            | T![..]
+            | T![*=]
+            | T![/=]
+            | T![&&]
+            | T![&=]
+            | T![%=]
+            | T![^=]
+            | T![+=]
+            | T![<<]
+            | T![<=]
+            | T![==]
+            | T![=>]
+            | T![>=]
+            | T![>>]
+            | T![|=]
+            | T![||] => 2,
+            T![...] | T![..=] | T![<<=] | T![>>=] => 3,
+            _ => 1,
+        };
+        self.do_bump(kind, n_raw_tokens);
+        true
+    }
+    fn at_composite2(&self, n: usize, k1: SyntaxKind, k2: SyntaxKind) -> bool {
+        let t1 = self.token_source.lookahead_nth(n + 0);
+        let t2 = self.token_source.lookahead_nth(n + 1);
+        t1.kind == k1 && t1.is_jointed_to_next && t2.kind == k2
+    }
+    fn at_composite3(&self, n: usize, k1: SyntaxKind, k2: SyntaxKind, k3: SyntaxKind) -> bool {
+        let t1 = self.token_source.lookahead_nth(n + 0);
+        let t2 = self.token_source.lookahead_nth(n + 1);
+        let t3 = self.token_source.lookahead_nth(n + 2);
+        (t1.kind == k1 && t1.is_jointed_to_next)
+            && (t2.kind == k2 && t2.is_jointed_to_next)
+            && t3.kind == k3
    }
    /// Checks if the current token is in `kinds`.
@@ -129,22 +157,9 @@ impl<'t> Parser<'t> {
        Marker::new(pos)
    }
-    /// Advances the parser by one token unconditionally
+    /// Consume the next token if `kind` matches.
-    /// Mainly use in `token_tree` parsing
+    pub(crate) fn bump(&mut self, kind: SyntaxKind) {
-    pub(crate) fn bump_raw(&mut self) {
+        assert!(self.eat(kind));
-        let mut kind = self.token_source.current().kind;
-        // Skip dollars, do_bump will eat these later
-        let mut i = 0;
-        while kind == SyntaxKind::L_DOLLAR || kind == SyntaxKind::R_DOLLAR {
-            kind = self.token_source.lookahead_nth(i).kind;
-            i += 1;
-        }
-        if kind == EOF {
-            return;
-        }
-        self.do_bump(kind, 1);
    }
    /// Advances the parser by one token with composite puncts handled
@@ -153,27 +168,7 @@ impl<'t> Parser<'t> {
        if kind == EOF {
            return;
        }
+        self.do_bump(kind, 1)
-        use SyntaxKind::*;
-        // Handle parser composites
-        match kind {
-            T![...] | T![..=] => {
-                self.bump_compound(kind, 3);
-            }
-            T![..] | T![::] | T![==] | T![=>] | T![!=] | T![->] => {
-                self.bump_compound(kind, 2);
-            }
-            _ => {
-                self.do_bump(kind, 1);
-            }
-        }
-    }
-    /// Advances the parser by one token, asserting that it is exactly the expected token
-    pub(crate) fn bump(&mut self, expected: SyntaxKind) {
-        debug_assert!(self.nth(0) == expected);
-        self.bump_any()
    }
    /// Advances the parser by one token, remapping its kind.
@@ -190,13 +185,6 @@ impl<'t> Parser<'t> {
        self.do_bump(kind, 1);
    }
-    /// Advances the parser by `n` tokens, remapping its kind.
-    /// This is useful to create compound tokens from parts. For
-    /// example, an `<<` token is two consecutive remapped `<` tokens
-    pub(crate) fn bump_compound(&mut self, kind: SyntaxKind, n: u8) {
-        self.do_bump(kind, n);
-    }
    /// Emit error with the `message`
    /// FIXME: this should be much more fancy and support
    /// structured errors with spans and notes, like rustc
@@ -206,15 +194,6 @@ impl<'t> Parser<'t> {
        self.push_event(Event::Error { msg })
    }
-    /// Consume the next token if `kind` matches.
-    pub(crate) fn eat(&mut self, kind: SyntaxKind) -> bool {
-        if !self.at(kind) {
-            return false;
-        }
-        self.bump_any();
-        true
-    }
    /// Consume the next token if it is `kind` or emit an error
    /// otherwise.
    pub(crate) fn expect(&mut self, kind: SyntaxKind) -> bool {
@@ -232,19 +211,26 @@ impl<'t> Parser<'t> {
    /// Create an error node and consume the next token.
    pub(crate) fn err_recover(&mut self, message: &str, recovery: TokenSet) {
-        if self.at(T!['{']) || self.at(T!['}']) || self.at_ts(recovery) {
+        match self.current() {
-            self.error(message);
+            T!['{'] | T!['}'] | L_DOLLAR | R_DOLLAR => {
-        } else {
+                self.error(message);
-            let m = self.start();
+                return;
+            }
+            _ => (),
+        }
+        if self.at_ts(recovery) {
            self.error(message);
-            self.bump_any();
+            return;
-            m.complete(self, ERROR);
+        }
-        };
+        let m = self.start();
+        self.error(message);
+        self.bump_any();
+        m.complete(self, ERROR);
    }
    fn do_bump(&mut self, kind: SyntaxKind, n_raw_tokens: u8) {
-        self.eat_dollars();
        for _ in 0..n_raw_tokens {
            self.token_source.bump();
        }
@@ -255,110 +241,6 @@ impl<'t> Parser<'t> {
    fn push_event(&mut self, event: Event) {
        self.events.push(event)
    }
-    /// helper function for check if it is composite.
-    fn is_composite(&self, first: Token, n: usize) -> Option<(SyntaxKind, usize)> {
-        // We assume the dollars will not occuried between
-        // mult-byte tokens
-        let jn1 = first.is_jointed_to_next;
-        if !jn1 && first.kind != T![-] {
-            return None;
-        }
-        let second = self.token_source.lookahead_nth(n + 1);
-        if first.kind == T![-] && second.kind == T![>] {
-            return Some((T![->], 2));
-        }
-        if !jn1 {
-            return None;
-        }
-        match (first.kind, second.kind) {
-            (T![:], T![:]) => return Some((T![::], 2)),
-            (T![=], T![=]) => return Some((T![==], 2)),
-            (T![=], T![>]) => return Some((T![=>], 2)),
-            (T![!], T![=]) => return Some((T![!=], 2)),
-            _ => {}
-        }
-        if first.kind != T![.] || second.kind != T![.] {
-            return None;
-        }
-        let third = self.token_source.lookahead_nth(n + 2);
-        let jn2 = second.is_jointed_to_next;
-        let la3 = third.kind;
-        if jn2 && la3 == T![.] {
-            return Some((T![...], 3));
-        }
-        if la3 == T![=] {
-            return Some((T![..=], 3));
-        }
-        return Some((T![..], 2));
-    }
-    fn eat_dollars(&mut self) {
-        loop {
-            match self.token_source.current().kind {
-                k @ SyntaxKind::L_DOLLAR | k @ SyntaxKind::R_DOLLAR => {
-                    self.token_source.bump();
-                    self.push_event(Event::Token { kind: k, n_raw_tokens: 1 });
-                }
-                _ => {
-                    return;
-                }
-            }
-        }
-    }
-    pub(crate) fn eat_l_dollars(&mut self) -> usize {
-        let mut ate_count = 0;
-        loop {
-            match self.token_source.current().kind {
-                k @ SyntaxKind::L_DOLLAR => {
-                    self.token_source.bump();
-                    self.push_event(Event::Token { kind: k, n_raw_tokens: 1 });
-                    ate_count += 1;
-                }
-                _ => {
-                    return ate_count;
-                }
-            }
-        }
-    }
-    pub(crate) fn eat_r_dollars(&mut self, max_count: usize) -> usize {
-        let mut ate_count = 0;
-        loop {
-            match self.token_source.current().kind {
-                k @ SyntaxKind::R_DOLLAR => {
-                    self.token_source.bump();
-                    self.push_event(Event::Token { kind: k, n_raw_tokens: 1 });
-                    ate_count += 1;
-                    if max_count >= ate_count {
-                        return ate_count;
-                    }
-                }
-                _ => {
-                    return ate_count;
-                }
-            }
-        }
-    }
-    pub(crate) fn at_l_dollar(&self) -> bool {
-        let kind = self.token_source.current().kind;
-        (kind == SyntaxKind::L_DOLLAR)
-    }
-    pub(crate) fn at_r_dollar(&self) -> bool {
-        let kind = self.token_source.current().kind;
-        (kind == SyntaxKind::R_DOLLAR)
-    }
 }
 /// See `Parser::start`.
diff --git a/crates/ra_syntax/src/tests.rs b/crates/ra_syntax/src/tests.rs
index fa5d2d5d8..458920607 100644
--- a/crates/ra_syntax/src/tests.rs
+++ b/crates/ra_syntax/src/tests.rs
@@ -16,6 +16,18 @@ fn lexer_tests() {
 }
 #[test]
+fn parse_smoke_test() {
+    let code = r##"
+fn main() {
+    println!("Hello, world!")
+}
+    "##;
+    let parse = SourceFile::parse(code);
+    assert!(parse.ok().is_ok());
+}
+#[test]
 fn parser_tests() {
    dir_tests(&test_data_dir(), &["parser/inline/ok", "parser/ok"], |text, path| {
        let parse = SourceFile::parse(text);
@@ -75,7 +87,9 @@ fn self_hosting_parsing() {
    {
        count += 1;
        let text = read_text(entry.path());
-        SourceFile::parse(&text).ok().expect("There should be no errors in the file");
+        if let Err(errors) = SourceFile::parse(&text).ok() {
+            panic!("Parsing errors:\n{:?}\n{}\n", errors, entry.path().display());
+        }
    }
    assert!(
        count > 30,
diff --git a/crates/ra_syntax/test_data/parser/ok/0054_qual_path_in_type_arg.rs b/crates/ra_syntax/test_data/parser/ok/0054_qual_path_in_type_arg.rs
new file mode 100644
index 000000000..0d3f5722a
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0054_qual_path_in_type_arg.rs
@@ -0,0 +1,5 @@
+fn a() -> Foo<bar::Baz> {}
+fn b(_: impl FnMut(x::Y)) {}
+fn c(_: impl FnMut(&x::Y)) {}
diff --git a/crates/ra_syntax/test_data/parser/ok/0054_qual_path_in_type_arg.txt b/crates/ra_syntax/test_data/parser/ok/0054_qual_path_in_type_arg.txt
new file mode 100644
index 000000000..7e1af254c
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0054_qual_path_in_type_arg.txt
@@ -0,0 +1,126 @@
+SOURCE_FILE@[0; 88)
+  FN_DEF@[0; 26)
+    FN_KW@[0; 2) "fn"
+    WHITESPACE@[2; 3) " "
+    NAME@[3; 4)
+      IDENT@[3; 4) "a"
+    PARAM_LIST@[4; 6)
+      L_PAREN@[4; 5) "("
+      R_PAREN@[5; 6) ")"
+    WHITESPACE@[6; 7) " "
+    RET_TYPE@[7; 23)
+      THIN_ARROW@[7; 9) "->"
+      WHITESPACE@[9; 10) " "
+      PATH_TYPE@[10; 23)
+        PATH@[10; 23)
+          PATH_SEGMENT@[10; 23)
+            NAME_REF@[10; 13)
+              IDENT@[10; 13) "Foo"
+            TYPE_ARG_LIST@[13; 23)
+              L_ANGLE@[13; 14) "<"
+              TYPE_ARG@[14; 22)
+                PATH_TYPE@[14; 22)
+                  PATH@[14; 22)
+                    PATH@[14; 17)
+                      PATH_SEGMENT@[14; 17)
+                        NAME_REF@[14; 17)
+                          IDENT@[14; 17) "bar"
+                    COLONCOLON@[17; 19) "::"
+                    PATH_SEGMENT@[19; 22)
+                      NAME_REF@[19; 22)
+                        IDENT@[19; 22) "Baz"
+              R_ANGLE@[22; 23) ">"
+    WHITESPACE@[23; 24) " "
+    BLOCK_EXPR@[24; 26)
+      BLOCK@[24; 26)
+        L_CURLY@[24; 25) "{"
+        R_CURLY@[25; 26) "}"
+  WHITESPACE@[26; 28) "\n\n"
+  FN_DEF@[28; 56)
+    FN_KW@[28; 30) "fn"
+    WHITESPACE@[30; 31) " "
+    NAME@[31; 32)
+      IDENT@[31; 32) "b"
+    PARAM_LIST@[32; 53)
+      L_PAREN@[32; 33) "("
+      PARAM@[33; 52)
+        PLACEHOLDER_PAT@[33; 34)
+          UNDERSCORE@[33; 34) "_"
+        COLON@[34; 35) ":"
+        WHITESPACE@[35; 36) " "
+        IMPL_TRAIT_TYPE@[36; 52)
+          IMPL_KW@[36; 40) "impl"
+          WHITESPACE@[40; 41) " "
+          TYPE_BOUND_LIST@[41; 52)
+            TYPE_BOUND@[41; 52)
+              PATH_TYPE@[41; 52)
+                PATH@[41; 52)
+                  PATH_SEGMENT@[41; 52)
+                    NAME_REF@[41; 46)
+                      IDENT@[41; 46) "FnMut"
+                    PARAM_LIST@[46; 52)
+                      L_PAREN@[46; 47) "("
+                      PARAM@[47; 51)
+                        PATH_TYPE@[47; 51)
+                          PATH@[47; 51)
+                            PATH@[47; 48)
+                              PATH_SEGMENT@[47; 48)
+                                NAME_REF@[47; 48)
+                                  IDENT@[47; 48) "x"
+                            COLONCOLON@[48; 50) "::"
+                            PATH_SEGMENT@[50; 51)
+                              NAME_REF@[50; 51)
+                                IDENT@[50; 51) "Y"
+                      R_PAREN@[51; 52) ")"
+      R_PAREN@[52; 53) ")"
+    WHITESPACE@[53; 54) " "
+    BLOCK_EXPR@[54; 56)
+      BLOCK@[54; 56)
+        L_CURLY@[54; 55) "{"
+        R_CURLY@[55; 56) "}"
+  WHITESPACE@[56; 58) "\n\n"
+  FN_DEF@[58; 87)
+    FN_KW@[58; 60) "fn"
+    WHITESPACE@[60; 61) " "
+    NAME@[61; 62)
+      IDENT@[61; 62) "c"
+    PARAM_LIST@[62; 84)
+      L_PAREN@[62; 63) "("
+      PARAM@[63; 83)
+        PLACEHOLDER_PAT@[63; 64)
+          UNDERSCORE@[63; 64) "_"
+        COLON@[64; 65) ":"
+        WHITESPACE@[65; 66) " "
+        IMPL_TRAIT_TYPE@[66; 83)
+          IMPL_KW@[66; 70) "impl"
+          WHITESPACE@[70; 71) " "
+          TYPE_BOUND_LIST@[71; 83)
+            TYPE_BOUND@[71; 83)
+              PATH_TYPE@[71; 83)
+                PATH@[71; 83)
+                  PATH_SEGMENT@[71; 83)
+                    NAME_REF@[71; 76)
+                      IDENT@[71; 76) "FnMut"
+                    PARAM_LIST@[76; 83)
+                      L_PAREN@[76; 77) "("
+                      PARAM@[77; 82)
+                        REFERENCE_TYPE@[77; 82)
+                          AMP@[77; 78) "&"
+                          PATH_TYPE@[78; 82)
+                            PATH@[78; 82)
+                              PATH@[78; 79)
+                                PATH_SEGMENT@[78; 79)
+                                  NAME_REF@[78; 79)
+                                    IDENT@[78; 79) "x"
+                              COLONCOLON@[79; 81) "::"
+                              PATH_SEGMENT@[81; 82)
+                                NAME_REF@[81; 82)
+                                  IDENT@[81; 82) "Y"
+                      R_PAREN@[82; 83) ")"
+      R_PAREN@[83; 84) ")"
+    WHITESPACE@[84; 85) " "
+    BLOCK_EXPR@[85; 87)
+      BLOCK@[85; 87)
+        L_CURLY@[85; 86) "{"
+        R_CURLY@[86; 87) "}"
+  WHITESPACE@[87; 88) "\n"
diff --git a/crates/ra_syntax/test_data/parser/ok/0055_dot_dot_dot.rs b/crates/ra_syntax/test_data/parser/ok/0055_dot_dot_dot.rs
new file mode 100644
index 000000000..cd204f65e
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0055_dot_dot_dot.rs
@@ -0,0 +1,5 @@
+type X = ();
+fn main() {
+    let ():::X = ();
+}
diff --git a/crates/ra_syntax/test_data/parser/ok/0055_dot_dot_dot.txt b/crates/ra_syntax/test_data/parser/ok/0055_dot_dot_dot.txt
new file mode 100644
index 000000000..d656e74b1
--- /dev/null
+++ b/crates/ra_syntax/test_data/parser/ok/0055_dot_dot_dot.txt
@@ -0,0 +1,50 @@
+SOURCE_FILE@[0; 49)
+  TYPE_ALIAS_DEF@[0; 12)
+    TYPE_KW@[0; 4) "type"
+    WHITESPACE@[4; 5) " "
+    NAME@[5; 6)
+      IDENT@[5; 6) "X"
+    WHITESPACE@[6; 7) " "
+    EQ@[7; 8) "="
+    WHITESPACE@[8; 9) " "
+    TUPLE_TYPE@[9; 11)
+      L_PAREN@[9; 10) "("
+      R_PAREN@[10; 11) ")"
+    SEMI@[11; 12) ";"
+  WHITESPACE@[12; 14) "\n\n"
+  FN_DEF@[14; 48)
+    FN_KW@[14; 16) "fn"
+    WHITESPACE@[16; 17) " "
+    NAME@[17; 21)
+      IDENT@[17; 21) "main"
+    PARAM_LIST@[21; 23)
+      L_PAREN@[21; 22) "("
+      R_PAREN@[22; 23) ")"
+    WHITESPACE@[23; 24) " "
+    BLOCK_EXPR@[24; 48)
+      BLOCK@[24; 48)
+        L_CURLY@[24; 25) "{"
+        WHITESPACE@[25; 30) "\n    "
+        LET_STMT@[30; 46)
+          LET_KW@[30; 33) "let"
+          WHITESPACE@[33; 34) " "
+          TUPLE_PAT@[34; 36)
+            L_PAREN@[34; 35) "("
+            R_PAREN@[35; 36) ")"
+          COLON@[36; 37) ":"
+          PATH_TYPE@[37; 40)
+            PATH@[37; 40)
+              PATH_SEGMENT@[37; 40)
+                COLONCOLON@[37; 39) "::"
+                NAME_REF@[39; 40)
+                  IDENT@[39; 40) "X"
+          WHITESPACE@[40; 41) " "
+          EQ@[41; 42) "="
+          WHITESPACE@[42; 43) " "
+          TUPLE_EXPR@[43; 45)
+            L_PAREN@[43; 44) "("
+            R_PAREN@[44; 45) ")"
+          SEMI@[45; 46) ";"
+        WHITESPACE@[46; 47) "\n"
+        R_CURLY@[47; 48) "}"
+  WHITESPACE@[48; 49) "\n"
diff --git a/crates/ra_tools/Cargo.toml b/crates/ra_tools/Cargo.toml
index b94a0b18d..848ca408d 100644
--- a/crates/ra_tools/Cargo.toml
+++ b/crates/ra_tools/Cargo.toml
@@ -8,7 +8,7 @@ publish = false
 [dependencies]
 walkdir = "2.1.3"
 itertools = "0.8.0"
-clap = { version = "2.32.0", default-features = false }
+pico-args = "0.2.0"
 quote = "1.0.2"
 proc-macro2 = "1.0.1"
 ron = "0.5.1"
diff --git a/crates/ra_tools/src/help.rs b/crates/ra_tools/src/help.rs
new file mode 100644
index 000000000..6dde6c2d2
--- /dev/null
+++ b/crates/ra_tools/src/help.rs
@@ -0,0 +1,45 @@
+pub const GLOBAL_HELP: &str = "tasks
+USAGE:
+    ra_tools <SUBCOMMAND>
+FLAGS:
+    -h, --help       Prints help information
+SUBCOMMANDS:
+    format
+    format-hook
+    fuzz-tests
+    gen-syntax
+    gen-tests
+    install-ra
+    lint";
+pub const INSTALL_RA_HELP: &str = "ra_tools-install-ra
+USAGE:
+    ra_tools.exe install-ra [FLAGS]
+FLAGS:
+        --client-code
+    -h, --help           Prints help information
+        --jemalloc
+        --server";
+pub fn print_no_param_subcommand_help(subcommand: &str) {
+    eprintln!(
+        "ra_tools-{}
+USAGE:
+    ra_tools {}
+FLAGS:
+    -h, --help       Prints help information",
+        subcommand, subcommand
+    );
+}
+pub const INSTALL_RA_CONFLICT: &str =
+    "error: The argument `--server` cannot be used with `--client-code`
+                    
+For more information try --help";
diff --git a/crates/ra_tools/src/main.rs b/crates/ra_tools/src/main.rs
index 33badf290..f96f1875f 100644
--- a/crates/ra_tools/src/main.rs
+++ b/crates/ra_tools/src/main.rs
@@ -1,5 +1,8 @@
-use clap::{App, Arg, SubCommand};
+mod help;
+use core::fmt::Write;
 use core::str;
+use pico_args::Arguments;
 use ra_tools::{
    gen_tests, generate_boilerplate, install_format_hook, run, run_clippy, run_fuzzer, run_rustfmt,
    Cmd, Overwrite, Result,
@@ -20,45 +23,95 @@ struct ServerOpt {
 }
 fn main() -> Result<()> {
-    let matches = App::new("tasks")
+    let subcommand = match std::env::args_os().nth(1) {
-        .setting(clap::AppSettings::SubcommandRequiredElseHelp)
+        None => {
-        .subcommand(SubCommand::with_name("gen-syntax"))
+            eprintln!("{}", help::GLOBAL_HELP);
-        .subcommand(SubCommand::with_name("gen-tests"))
+            return Ok(());
-        .subcommand(
+        }
-            SubCommand::with_name("install-ra")
+        Some(s) => s,
-                .arg(Arg::with_name("server").long("--server"))
+    };
-                .arg(Arg::with_name("jemalloc").long("jemalloc"))
+    let mut matches = Arguments::from_vec(std::env::args_os().skip(2).collect());
-                .arg(Arg::with_name("client-code").long("client-code").conflicts_with("server")),
+    let subcommand = &*subcommand.to_string_lossy();
-        )
+    match subcommand {
-        .alias("install-code")
+        "install-ra" | "install-code" => {
-        .subcommand(SubCommand::with_name("format"))
+            if matches.contains(["-h", "--help"]) {
-        .subcommand(SubCommand::with_name("format-hook"))
+                eprintln!("{}", help::INSTALL_RA_HELP);
-        .subcommand(SubCommand::with_name("fuzz-tests"))
+                return Ok(());
-        .subcommand(SubCommand::with_name("lint"))
+            }
-        .get_matches();
+            let server = matches.contains("--server");
-    match matches.subcommand() {
+            let client_code = matches.contains("--client-code");
-        ("install-ra", Some(matches)) => {
+            if server && client_code {
+                eprintln!("{}", help::INSTALL_RA_CONFLICT);
+                return Ok(());
+            }
+            let jemalloc = matches.contains("--jemalloc");
+            matches.finish().or_else(handle_extra_flags)?;
            let opts = InstallOpt {
-                client: if matches.is_present("server") { None } else { Some(ClientOpt::VsCode) },
+                client: if server { None } else { Some(ClientOpt::VsCode) },
-                server: if matches.is_present("client-code") {
+                server: if client_code { None } else { Some(ServerOpt { jemalloc: jemalloc }) },
-                    None
-                } else {
-                    Some(ServerOpt { jemalloc: matches.is_present("jemalloc") })
-                },
            };
            install(opts)?
        }
-        ("gen-tests", _) => gen_tests(Overwrite)?,
+        "gen-tests" => {
-        ("gen-syntax", _) => generate_boilerplate(Overwrite)?,
+            if matches.contains(["-h", "--help"]) {
-        ("format", _) => run_rustfmt(Overwrite)?,
+                help::print_no_param_subcommand_help(&subcommand);
-        ("format-hook", _) => install_format_hook()?,
+                return Ok(());
-        ("lint", _) => run_clippy()?,
+            }
-        ("fuzz-tests", _) => run_fuzzer()?,
+            gen_tests(Overwrite)?
-        _ => unreachable!(),
+        }
+        "gen-syntax" => {
+            if matches.contains(["-h", "--help"]) {
+                help::print_no_param_subcommand_help(&subcommand);
+                return Ok(());
+            }
+            generate_boilerplate(Overwrite)?
+        }
+        "format" => {
+            if matches.contains(["-h", "--help"]) {
+                help::print_no_param_subcommand_help(&subcommand);
+                return Ok(());
+            }
+            run_rustfmt(Overwrite)?
+        }
+        "format-hook" => {
+            if matches.contains(["-h", "--help"]) {
+                help::print_no_param_subcommand_help(&subcommand);
+                return Ok(());
+            }
+            install_format_hook()?
+        }
+        "lint" => {
+            if matches.contains(["-h", "--help"]) {
+                help::print_no_param_subcommand_help(&subcommand);
+                return Ok(());
+            }
+            run_clippy()?
+        }
+        "fuzz-tests" => {
+            if matches.contains(["-h", "--help"]) {
+                help::print_no_param_subcommand_help(&subcommand);
+                return Ok(());
+            }
+            run_fuzzer()?
+        }
+        _ => eprintln!("{}", help::GLOBAL_HELP),
    }
    Ok(())
 }
+fn handle_extra_flags(e: pico_args::Error) -> Result<()> {
+    if let pico_args::Error::UnusedArgsLeft(flags) = e {
+        let mut invalid_flags = String::new();
+        for flag in flags {
+            write!(&mut invalid_flags, "{}, ", flag)?;
+        }
+        let (invalid_flags, _) = invalid_flags.split_at(invalid_flags.len() - 2);
+        Err(format!("Invalid flags: {}", invalid_flags).into())
+    } else {
+        Err(e.to_string().into())
+    }
+}
 fn install(opts: InstallOpt) -> Result<()> {
    if cfg!(target_os = "macos") {
        fix_path_for_mac()?
diff --git a/docs/user/README.md b/docs/user/README.md
index 8205fa404..5101e49b8 100644
--- a/docs/user/README.md
+++ b/docs/user/README.md
@@ -130,7 +130,7 @@ Installation:
 ```json
 "rust-analyzer": {
-    "command": ["rustup", "run", "stable", "ra_lsp_server"],
+    "command": ["ra_lsp_server"],
    "languageId": "rust",
    "scopes": ["source.rust"],
    "syntaxes": [
@@ -141,3 +141,5 @@ Installation:
 ```
 * 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)
+* Note that `ra_lsp_server` binary must be in `$PATH` for this to work. If it's not the case, you can specify full path to the binary, which is typically `.cargo/bin/ra_lsp_server`.
diff --git a/editors/code/package.json b/editors/code/package.json
index 7a48d6794..38824acb4 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -13,7 +13,7 @@
        "Other"
    ],
    "engines": {
-        "vscode": "^1.36.0"
+        "vscode": "^1.37.0"
    },
    "scripts": {
        "vscode:prepublish": "npm run compile",
diff --git a/editors/code/src/commands/cargo_watch.ts b/editors/code/src/commands/cargo_watch.ts
index 4c3c10c8b..00b24dbce 100644
--- a/editors/code/src/commands/cargo_watch.ts
+++ b/editors/code/src/commands/cargo_watch.ts
@@ -1,5 +1,4 @@
 import * as child_process from 'child_process';
-import * as fs from 'fs';
 import * as path from 'path';
 import * as vscode from 'vscode';
@@ -15,23 +14,23 @@ import {
 import SuggestedFixCollection from '../utils/diagnostics/SuggestedFixCollection';
 import { areDiagnosticsEqual } from '../utils/diagnostics/vscode';
-export function registerCargoWatchProvider(
+export async function registerCargoWatchProvider(
    subscriptions: vscode.Disposable[]
-): CargoWatchProvider | undefined {
+): Promise<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 {
+    const cargoTomlPath = path.join(vscode.workspace.rootPath!, 'Cargo.toml');
-        if (fs.existsSync(cargoTomlFile)) {
+    const cargoTomlUri = vscode.Uri.file(cargoTomlPath);
-            cargoExists = true;
+    const cargoTomlFileInfo = await vscode.workspace.fs.stat(cargoTomlUri);
-        }
-    } catch (err) {
+    if (cargoTomlFileInfo) {
-        cargoExists = false;
+        cargoExists = true;
    }
    if (!cargoExists) {
        vscode.window.showErrorMessage(
-            `Couldn\'t find \'Cargo.toml\' in ${cargoTomlFile}`
+            `Couldn\'t find \'Cargo.toml\' at ${cargoTomlPath}`
        );
        return;
    }