15 files changed, 383 insertions, 119 deletions
diff --git a/crates/assists/src/handlers/generate_function.rs b/crates/assists/src/handlers/generate_function.rs
index b38d64058..d23f4293b 100644
--- a/crates/assists/src/handlers/generate_function.rs
+++ b/crates/assists/src/handlers/generate_function.rs
@@ -36,8 +36,8 @@ use crate::{
 //     bar("", baz());
 // }
 //
-// fn bar(arg: &str, baz: Baz) {
+// fn bar(arg: &str, baz: Baz) ${0:-> ()} {
-//     ${0:todo!()}
+//     todo!()
 // }
 //
 // ```
@@ -80,9 +80,9 @@ pub(crate) fn generate_function(acc: &mut Assists, ctx: &AssistContext) -> Optio
 struct FunctionTemplate {
    insert_offset: TextSize,
-    placeholder_expr: ast::MacroCall,
    leading_ws: String,
    fn_def: ast::Fn,
+    ret_type: ast::RetType,
    trailing_ws: String,
    file: FileId,
 }
@@ -90,11 +90,9 @@ struct FunctionTemplate {
 impl FunctionTemplate {
    fn to_string(&self, cap: Option<SnippetCap>) -> String {
        let f = match cap {
-            Some(cap) => render_snippet(
+            Some(cap) => {
-                cap,
+                render_snippet(cap, self.fn_def.syntax(), Cursor::Replace(self.ret_type.syntax()))
-                self.fn_def.syntax(),
+            }
-                Cursor::Replace(self.placeholder_expr.syntax()),
-            ),
            None => self.fn_def.to_string(),
        };
        format!("{}{}{}", self.leading_ws, f, self.trailing_ws)
@@ -141,8 +139,14 @@ impl FunctionBuilder {
        let placeholder_expr = make::expr_todo();
        let fn_body = make::block_expr(vec![], Some(placeholder_expr));
        let visibility = if self.needs_pub { Some(make::visibility_pub_crate()) } else { None };
-        let mut fn_def =
+        let mut fn_def = make::fn_(
-            make::fn_(visibility, self.fn_name, self.type_params, self.params, fn_body);
+            visibility,
+            self.fn_name,
+            self.type_params,
+            self.params,
+            fn_body,
+            Some(make::ret_type(make::ty("()"))),
+        );
        let leading_ws;
        let trailing_ws;
@@ -163,12 +167,10 @@ impl FunctionBuilder {
            }
        };
-        let placeholder_expr =
-            fn_def.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
        FunctionTemplate {
            insert_offset,
-            placeholder_expr,
            leading_ws,
+            ret_type: fn_def.ret_type().unwrap(),
            fn_def,
            trailing_ws,
            file: self.file,
@@ -349,8 +351,8 @@ fn foo() {
    bar();
 }
-fn bar() {
+fn bar() ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -376,8 +378,8 @@ impl Foo {
    }
 }
-fn bar() {
+fn bar() ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -400,8 +402,8 @@ fn foo1() {
    bar();
 }
-fn bar() {
+fn bar() ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 fn foo2() {}
@@ -426,8 +428,8 @@ mod baz {
        bar();
    }
-    fn bar() {
+    fn bar() ${0:-> ()} {
-        ${0:todo!()}
+        todo!()
    }
 }
 ",
@@ -452,8 +454,8 @@ fn foo() {
    bar(baz());
 }
-fn bar(baz: Baz) {
+fn bar(baz: Baz) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        );
@@ -485,8 +487,8 @@ impl Baz {
    }
 }
-fn bar(baz: Baz) {
+fn bar(baz: Baz) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -506,8 +508,8 @@ fn foo() {
    bar("bar")
 }
-fn bar(arg: &str) {
+fn bar(arg: &str) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 "#,
        )
@@ -527,8 +529,8 @@ fn foo() {
    bar('x')
 }
-fn bar(arg: char) {
+fn bar(arg: char) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 "#,
        )
@@ -548,8 +550,8 @@ fn foo() {
    bar(42)
 }
-fn bar(arg: i32) {
+fn bar(arg: i32) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -569,8 +571,8 @@ fn foo() {
    bar(42 as u8)
 }
-fn bar(arg: u8) {
+fn bar(arg: u8) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -594,8 +596,8 @@ fn foo() {
    bar(x as u8)
 }
-fn bar(x: u8) {
+fn bar(x: u8) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -617,8 +619,8 @@ fn foo() {
    bar(worble)
 }
-fn bar(worble: ()) {
+fn bar(worble: ()) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -646,8 +648,8 @@ fn baz() {
    bar(foo())
 }
-fn bar(foo: impl Foo) {
+fn bar(foo: impl Foo) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -673,8 +675,8 @@ fn foo() {
    bar(&baz())
 }
-fn bar(baz: &Baz) {
+fn bar(baz: &Baz) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -702,8 +704,8 @@ fn foo() {
    bar(Baz::baz())
 }
-fn bar(baz: Baz::Bof) {
+fn bar(baz: Baz::Bof) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -725,8 +727,8 @@ fn foo<T>(t: T) {
    bar(t)
 }
-fn bar<T>(t: T) {
+fn bar<T>(t: T) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -756,8 +758,8 @@ fn foo() {
    bar(Baz::new);
 }
-fn bar(arg: fn() -> Baz) {
+fn bar(arg: fn() -> Baz) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -781,8 +783,8 @@ fn foo() {
    bar(closure)
 }
-fn bar(closure: impl Fn(i64) -> i64) {
+fn bar(closure: impl Fn(i64) -> i64) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -802,8 +804,8 @@ fn foo() {
    bar(baz)
 }
-fn bar(baz: ()) {
+fn bar(baz: ()) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -827,8 +829,8 @@ fn foo() {
    bar(baz(), baz())
 }
-fn bar(baz_1: Baz, baz_2: Baz) {
+fn bar(baz_1: Baz, baz_2: Baz) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -852,8 +854,8 @@ fn foo() {
    bar(baz(), baz(), "foo", "bar")
 }
-fn bar(baz_1: Baz, baz_2: Baz, arg_1: &str, arg_2: &str) {
+fn bar(baz_1: Baz, baz_2: Baz, arg_1: &str, arg_2: &str) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 "#,
        )
@@ -872,8 +874,8 @@ fn foo() {
 ",
            r"
 mod bar {
-    pub(crate) fn my_fn() {
+    pub(crate) fn my_fn() ${0:-> ()} {
-        ${0:todo!()}
+        todo!()
    }
 }
@@ -911,8 +913,8 @@ fn bar() {
    baz(foo)
 }
-fn baz(foo: foo::Foo) {
+fn baz(foo: foo::Foo) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 ",
        )
@@ -935,8 +937,8 @@ fn foo() {
 mod bar {
    fn something_else() {}
-    pub(crate) fn my_fn() {
+    pub(crate) fn my_fn() ${0:-> ()} {
-        ${0:todo!()}
+        todo!()
    }
 }
@@ -963,8 +965,8 @@ fn foo() {
            r"
 mod bar {
    mod baz {
-        pub(crate) fn my_fn() {
+        pub(crate) fn my_fn() ${0:-> ()} {
-            ${0:todo!()}
+            todo!()
        }
    }
 }
@@ -992,8 +994,8 @@ fn main() {
            r"
-pub(crate) fn bar() {
+pub(crate) fn bar() ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }",
        )
    }
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index 7f6e98a54..41f536574 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -454,8 +454,8 @@ fn foo() {
    bar("", baz());
 }
-fn bar(arg: &str, baz: Baz) {
+fn bar(arg: &str, baz: Baz) ${0:-> ()} {
-    ${0:todo!()}
+    todo!()
 }
 "#####,
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
index c330314d4..215ac4b41 100644
--- a/crates/base_db/src/input.rs
+++ b/crates/base_db/src/input.rs
@@ -221,6 +221,34 @@ impl CrateGraph {
        deps.into_iter()
    }
+    /// Returns all crates in the graph, sorted in topological order (ie. dependencies of a crate
+    /// come before the crate itself).
+    pub fn crates_in_topological_order(&self) -> Vec<CrateId> {
+        let mut res = Vec::new();
+        let mut visited = FxHashSet::default();
+        for krate in self.arena.keys().copied() {
+            go(self, &mut visited, &mut res, krate);
+        }
+        return res;
+        fn go(
+            graph: &CrateGraph,
+            visited: &mut FxHashSet<CrateId>,
+            res: &mut Vec<CrateId>,
+            source: CrateId,
+        ) {
+            if !visited.insert(source) {
+                return;
+            }
+            for dep in graph[source].dependencies.iter() {
+                go(graph, visited, res, dep.crate_id)
+            }
+            res.push(source)
+        }
+    }
    // FIXME: this only finds one crate with the given root; we could have multiple
    pub fn crate_id_for_crate_root(&self, file_id: FileId) -> Option<CrateId> {
        let (&crate_id, _) =
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index fb85041fd..b65be4fe1 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -1411,7 +1411,7 @@ impl Type {
        r#trait: Trait,
        args: &[Type],
        alias: TypeAlias,
-    ) -> Option<Ty> {
+    ) -> Option<Type> {
        let subst = Substs::build_for_def(db, r#trait.id)
            .push(self.ty.value.clone())
            .fill(args.iter().map(|t| t.ty.value.clone()))
@@ -1432,6 +1432,10 @@ impl Type {
            Solution::Unique(SolutionVariables(subst)) => subst.value.first().cloned(),
            Solution::Ambig(_) => None,
        }
+        .map(|ty| Type {
+            krate: self.krate,
+            ty: InEnvironment { value: ty, environment: Arc::clone(&self.ty.environment) },
+        })
    }
    pub fn is_copy(&self, db: &dyn HirDatabase) -> bool {
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 2d91bb21f..01e72690a 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -107,7 +107,10 @@ impl ExprCollector<'_> {
                let param_pat = self.alloc_pat(
                    Pat::Bind {
                        name: name![self],
-                        mode: BindingAnnotation::Unannotated,
+                        mode: BindingAnnotation::new(
+                            self_param.mut_token().is_some() && self_param.amp_token().is_none(),
+                            false,
+                        ),
                        subpat: None,
                    },
                    Either::Right(ptr),
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 7d716577e..e2079bbcf 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -220,8 +220,8 @@ fn hint_iterator(
    }
    let iter_trait = FamousDefs(sema, krate).core_iter_Iterator()?;
    let iter_mod = FamousDefs(sema, krate).core_iter()?;
-    // assert this type comes from `core::iter`
+    // assert this struct comes from `core::iter`
-    iter_mod.visibility_of(db, &iter_trait.into()).filter(|&vis| vis == hir::Visibility::Public)?;
+    iter_mod.visibility_of(db, &strukt.into()).filter(|&vis| vis == hir::Visibility::Public)?;
    if ty.impls_trait(db, iter_trait, &[]) {
        let assoc_type_item = iter_trait.items(db).into_iter().find_map(|item| match item {
            hir::AssocItem::TypeAlias(alias) if alias.name(db) == known::Item => Some(alias),
@@ -231,12 +231,17 @@ fn hint_iterator(
            const LABEL_START: &str = "impl Iterator<Item = ";
            const LABEL_END: &str = ">";
-            let ty_display = ty.display_truncated(
+            let ty_display = hint_iterator(sema, config, &ty)
-                db,
+                .map(|assoc_type_impl| assoc_type_impl.to_string())
-                config
+                .unwrap_or_else(|| {
-                    .max_length
+                    ty.display_truncated(
-                    .map(|len| len.saturating_sub(LABEL_START.len() + LABEL_END.len())),
+                        db,
-            );
+                        config
+                            .max_length
+                            .map(|len| len.saturating_sub(LABEL_START.len() + LABEL_END.len())),
+                    )
+                    .to_string()
+                });
            return Some(format!("{}{}{}", LABEL_START, ty_display, LABEL_END).into());
        }
    }
@@ -1002,18 +1007,6 @@ fn main() {
    println!("Unit expr");
 }
-//- /alloc.rs crate:alloc deps:core
-mod collections {
-    struct Vec<T> {}
-    impl<T> Vec<T> {
-        fn new() -> Self { Vec {} }
-        fn push(&mut self, t: T) { }
-    }
-    impl<T> IntoIterator for Vec<T> {
-        type Item=T;
-    }
-}
 "#,
        );
    }
@@ -1043,17 +1036,6 @@ fn main() {
        //^ &str
    }
 }
-//- /alloc.rs crate:alloc deps:core
-mod collections {
-    struct Vec<T> {}
-    impl<T> Vec<T> {
-        fn new() -> Self { Vec {} }
-        fn push(&mut self, t: T) { }
-    }
-    impl<T> IntoIterator for Vec<T> {
-        type Item=T;
-    }
-}
 "#,
        );
    }
@@ -1183,4 +1165,41 @@ fn main() {
            "#]],
        );
    }
+    #[test]
+    fn shorten_iterators_in_associated_params() {
+        check_with_config(
+            InlayHintsConfig {
+                parameter_hints: false,
+                type_hints: true,
+                chaining_hints: false,
+                max_length: None,
+            },
+            r#"
+use core::iter;
+pub struct SomeIter<T> {}
+impl<T> SomeIter<T> {
+    pub fn new() -> Self { SomeIter {} }
+    pub fn push(&mut self, t: T) {}
+}
+impl<T> Iterator for SomeIter<T> {
+    type Item = T;
+    fn next(&mut self) -> Option<Self::Item> {
+        None
+    }
+}
+fn main() {
+    let mut some_iter = SomeIter::new();
+      //^^^^^^^^^^^^^ SomeIter<Take<Repeat<i32>>>
+      some_iter.push(iter::repeat(2).take(2));
+    let iter_of_iters = some_iter.take(2);
+      //^^^^^^^^^^^^^ impl Iterator<Item = impl Iterator<Item = i32>>
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 686cee3a1..aaf9b3b4b 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -77,6 +77,7 @@ pub use crate::{
    hover::{HoverAction, HoverConfig, HoverGotoTypeData, HoverResult},
    inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
    markup::Markup,
+    prime_caches::PrimeCachesProgress,
    references::{
        Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult, RenameError,
    },
@@ -223,8 +224,11 @@ impl Analysis {
        self.with_db(|db| status::status(&*db, file_id))
    }
-    pub fn prime_caches(&self, files: Vec<FileId>) -> Cancelable<()> {
+    pub fn prime_caches<F>(&self, cb: F) -> Cancelable<()>
-        self.with_db(|db| prime_caches::prime_caches(db, files))
+    where
+        F: Fn(PrimeCachesProgress) + Sync + std::panic::UnwindSafe,
+    {
+        self.with_db(move |db| prime_caches::prime_caches(db, &cb))
    }
    /// Gets the text of the source file.
diff --git a/crates/ide/src/prime_caches.rs b/crates/ide/src/prime_caches.rs
index c5ab5a1d8..9687c2734 100644
--- a/crates/ide/src/prime_caches.rs
+++ b/crates/ide/src/prime_caches.rs
@@ -3,10 +3,45 @@
 //! request takes longer to compute. This modules implemented prepopulating of
 //! various caches, it's not really advanced at the moment.
-use crate::{FileId, RootDatabase};
+use base_db::SourceDatabase;
+use hir::db::DefDatabase;
-pub(crate) fn prime_caches(db: &RootDatabase, files: Vec<FileId>) {
+use crate::RootDatabase;
-    for file in files {
-        let _ = crate::syntax_highlighting::highlight(db, file, None, false);
+#[derive(Debug)]
+pub enum PrimeCachesProgress {
+    Started,
+    /// We started indexing a crate.
+    StartedOnCrate {
+        on_crate: String,
+        n_done: usize,
+        n_total: usize,
+    },
+    /// We finished indexing all crates.
+    Finished,
+}
+pub(crate) fn prime_caches(db: &RootDatabase, cb: &(dyn Fn(PrimeCachesProgress) + Sync)) {
+    let _p = profile::span("prime_caches");
+    let graph = db.crate_graph();
+    let topo = &graph.crates_in_topological_order();
+    cb(PrimeCachesProgress::Started);
+    // FIXME: This would be easy to parallelize, since it's in the ideal ordering for that.
+    // Unfortunately rayon prevents panics from propagation out of a `scope`, which breaks
+    // cancellation, so we cannot use rayon.
+    for (i, krate) in topo.iter().enumerate() {
+        let crate_name =
+            graph[*krate].declaration_name.as_ref().map(ToString::to_string).unwrap_or_default();
+        cb(PrimeCachesProgress::StartedOnCrate {
+            on_crate: crate_name,
+            n_done: i,
+            n_total: topo.len(),
+        });
+        db.crate_def_map(*krate);
    }
+    cb(PrimeCachesProgress::Finished);
 }
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index d9fc25d88..6aafd6fd5 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -68,7 +68,7 @@ pub(crate) fn highlight(
    // When we leave a node, the we use it to flatten the highlighted ranges.
    let mut stack = HighlightedRangeStack::new();
-    let mut current_macro_call: Option<ast::MacroCall> = None;
+    let mut current_macro_call: Option<(ast::MacroCall, Option<MacroMatcherParseState>)> = None;
    let mut format_string: Option<SyntaxElement> = None;
    // Walk all nodes, keeping track of whether we are inside a macro or not.
@@ -92,7 +92,6 @@ pub(crate) fn highlight(
        // Track "inside macro" state
        match event.clone().map(|it| it.into_node().and_then(ast::MacroCall::cast)) {
            WalkEvent::Enter(Some(mc)) => {
-                current_macro_call = Some(mc.clone());
                if let Some(range) = macro_call_range(&mc) {
                    stack.add(HighlightedRange {
                        range,
@@ -100,7 +99,9 @@ pub(crate) fn highlight(
                        binding_hash: None,
                    });
                }
+                let mut is_macro_rules = None;
                if let Some(name) = mc.is_macro_rules() {
+                    is_macro_rules = Some(MacroMatcherParseState::new());
                    if let Some((highlight, binding_hash)) = highlight_element(
                        &sema,
                        &mut bindings_shadow_count,
@@ -114,10 +115,11 @@ pub(crate) fn highlight(
                        });
                    }
                }
+                current_macro_call = Some((mc.clone(), is_macro_rules));
                continue;
            }
            WalkEvent::Leave(Some(mc)) => {
-                assert!(current_macro_call == Some(mc));
+                assert!(current_macro_call.map(|it| it.0) == Some(mc));
                current_macro_call = None;
                format_string = None;
            }
@@ -146,6 +148,20 @@ pub(crate) fn highlight(
            WalkEvent::Leave(_) => continue,
        };
+        // check if in matcher part of a macro_rules rule
+        if let Some((_, Some(ref mut state))) = current_macro_call {
+            if let Some(tok) = element.as_token() {
+                if matches!(
+                    update_macro_rules_state(tok, state),
+                    RuleState::Matcher | RuleState::Expander
+                ) {
+                    if skip_metavariables(element.clone()) {
+                        continue;
+                    }
+                }
+            }
+        }
        let range = element.text_range();
        let element_to_highlight = if current_macro_call.is_some() && element.kind() != COMMENT {
@@ -918,3 +934,99 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
        _ => default.into(),
    }
 }
+struct MacroMatcherParseState {
+    /// Opening and corresponding closing bracket of the matcher or expander of the current rule
+    paren_ty: Option<(SyntaxKind, SyntaxKind)>,
+    paren_level: usize,
+    rule_state: RuleState,
+    /// Whether we are inside the outer `{` `}` macro block that holds the rules
+    in_invoc_body: bool,
+}
+impl MacroMatcherParseState {
+    fn new() -> Self {
+        MacroMatcherParseState {
+            paren_ty: None,
+            paren_level: 0,
+            in_invoc_body: false,
+            rule_state: RuleState::None,
+        }
+    }
+}
+#[derive(Copy, Clone, PartialEq)]
+enum RuleState {
+    Matcher,
+    Expander,
+    Between,
+    None,
+}
+impl RuleState {
+    fn transition(&mut self) {
+        *self = match self {
+            RuleState::Matcher => RuleState::Between,
+            RuleState::Expander => RuleState::None,
+            RuleState::Between => RuleState::Expander,
+            RuleState::None => RuleState::Matcher,
+        };
+    }
+}
+fn update_macro_rules_state(tok: &SyntaxToken, state: &mut MacroMatcherParseState) -> RuleState {
+    if !state.in_invoc_body {
+        if tok.kind() == T!['{'] {
+            state.in_invoc_body = true;
+        }
+        return state.rule_state;
+    }
+    match state.paren_ty {
+        Some((open, close)) => {
+            if tok.kind() == open {
+                state.paren_level += 1;
+            } else if tok.kind() == close {
+                state.paren_level -= 1;
+                if state.paren_level == 0 {
+                    let res = state.rule_state;
+                    state.rule_state.transition();
+                    state.paren_ty = None;
+                    return res;
+                }
+            }
+        }
+        None => {
+            match tok.kind() {
+                T!['('] => {
+                    state.paren_ty = Some((T!['('], T![')']));
+                }
+                T!['{'] => {
+                    state.paren_ty = Some((T!['{'], T!['}']));
+                }
+                T!['['] => {
+                    state.paren_ty = Some((T!['['], T![']']));
+                }
+                _ => (),
+            }
+            if state.paren_ty.is_some() {
+                state.paren_level = 1;
+                state.rule_state.transition();
+            }
+        }
+    }
+    state.rule_state
+}
+fn skip_metavariables(element: SyntaxElement) -> bool {
+    let tok = match element.as_token() {
+        Some(tok) => tok,
+        None => return false,
+    };
+    let is_fragment = || tok.prev_token().map(|tok| tok.kind()) == Some(T![$]);
+    match tok.kind() {
+        IDENT if is_fragment() => true,
+        kind if kind.is_keyword() && is_fragment() => true,
+        _ => false,
+    }
+}
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
index 1b681b2c6..43f1b32fd 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
@@ -37,7 +37,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 </style>
 <pre><code><span class="macro">macro_rules!</span> <span class="macro declaration">println</span> <span class="punctuation">{</span>
    <span class="punctuation">(</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>arg<span class="punctuation">:</span>tt<span class="punctuation">)</span><span class="punctuation">*</span><span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">(</span><span class="punctuation">{</span>
-        <span class="punctuation">$</span><span class="keyword">crate</span><span class="punctuation">:</span><span class="punctuation">:</span>io<span class="punctuation">:</span><span class="punctuation">:</span>_print<span class="punctuation">(</span><span class="punctuation">$</span><span class="keyword">crate</span><span class="punctuation">:</span><span class="punctuation">:</span>format_args_nl<span class="punctuation">!</span><span class="punctuation">(</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>arg<span class="punctuation">)</span><span class="punctuation">*</span><span class="punctuation">)</span><span class="punctuation">)</span><span class="punctuation">;</span>
+        <span class="punctuation">$</span>crate<span class="punctuation">:</span><span class="punctuation">:</span>io<span class="punctuation">:</span><span class="punctuation">:</span>_print<span class="punctuation">(</span><span class="punctuation">$</span>crate<span class="punctuation">:</span><span class="punctuation">:</span>format_args_nl<span class="punctuation">!</span><span class="punctuation">(</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>arg<span class="punctuation">)</span><span class="punctuation">*</span><span class="punctuation">)</span><span class="punctuation">)</span><span class="punctuation">;</span>
    <span class="punctuation">}</span><span class="punctuation">)</span>
 <span class="punctuation">}</span>
 #[rustc_builtin_macro]
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 1d8a3c404..0bb0928e4 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -62,7 +62,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 <span class="keyword">impl</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
    <span class="keyword">fn</span> <span class="function declaration">baz</span><span class="punctuation">(</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">,</span> <span class="value_param declaration">f</span><span class="punctuation">:</span> <span class="struct">Foo</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
-        <span class="value_param">f</span><span class="punctuation">.</span><span class="function consuming">baz</span><span class="punctuation">(</span><span class="self_keyword consuming">self</span><span class="punctuation">)</span>
+        <span class="value_param">f</span><span class="punctuation">.</span><span class="function consuming">baz</span><span class="punctuation">(</span><span class="self_keyword mutable consuming">self</span><span class="punctuation">)</span>
    <span class="punctuation">}</span>
    <span class="keyword">fn</span> <span class="function declaration">qux</span><span class="punctuation">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="punctuation">)</span> <span class="punctuation">{</span>
@@ -115,6 +115,10 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
    <span class="punctuation">}</span>
 <span class="punctuation">}</span>
+<span class="macro">macro_rules!</span> <span class="macro declaration">keyword_frag</span> <span class="punctuation">{</span>
+    <span class="punctuation">(</span><span class="punctuation">$</span>type<span class="punctuation">:</span>ty<span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">(</span><span class="punctuation">$</span>type<span class="punctuation">)</span>
+<span class="punctuation">}</span>
 <span class="comment">// comment</span>
 <span class="keyword">fn</span> <span class="function declaration">main</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello, {}!"</span><span class="punctuation">,</span> <span class="numeric_literal">92</span><span class="punctuation">)</span><span class="punctuation">;</span>
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index 694c4b7fa..126363b8b 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -89,6 +89,10 @@ macro_rules! noop {
    }
 }
+macro_rules! keyword_frag {
+    ($type:ty) => ($type)
+}
 // comment
 fn main() {
    println!("Hello, {}!", 92);
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 06b38d99c..fb18f9014 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -7,6 +7,7 @@ use std::{
 use base_db::VfsPath;
 use crossbeam_channel::{select, Receiver};
+use ide::PrimeCachesProgress;
 use ide::{Canceled, FileId};
 use lsp_server::{Connection, Notification, Request, Response};
 use lsp_types::notification::Notification as _;
@@ -61,7 +62,7 @@ pub(crate) enum Task {
    Response(Response),
    Diagnostics(Vec<(FileId, Vec<lsp_types::Diagnostic>)>),
    Workspaces(Vec<anyhow::Result<ProjectWorkspace>>),
-    Unit,
+    PrimeCaches(PrimeCachesProgress),
 }
 impl fmt::Debug for Event {
@@ -197,7 +198,28 @@ impl GlobalState {
                    }
                }
                Task::Workspaces(workspaces) => self.switch_workspaces(workspaces),
-                Task::Unit => (),
+                Task::PrimeCaches(progress) => {
+                    let (state, message, fraction);
+                    match progress {
+                        PrimeCachesProgress::Started => {
+                            state = Progress::Begin;
+                            message = None;
+                            fraction = 0.0;
+                        }
+                        PrimeCachesProgress::StartedOnCrate { on_crate, n_done, n_total } => {
+                            state = Progress::Report;
+                            message = Some(format!("{}/{} ({})", n_done, n_total, on_crate));
+                            fraction = Progress::fraction(n_done, n_total);
+                        }
+                        PrimeCachesProgress::Finished => {
+                            state = Progress::End;
+                            message = None;
+                            fraction = 1.0;
+                        }
+                    };
+                    self.report_progress("indexing", state, message, Some(fraction));
+                }
            },
            Event::Vfs(mut task) => {
                let _p = profile::span("GlobalState::handle_event/vfs");
@@ -573,12 +595,18 @@ impl GlobalState {
                Task::Diagnostics(diagnostics)
            })
        }
-        self.task_pool.handle.spawn({
+        self.task_pool.handle.spawn_with_sender({
-            let subs = subscriptions;
            let snap = self.snapshot();
-            move || {
+            move |sender| {
-                snap.analysis.prime_caches(subs).unwrap_or_else(|_: Canceled| ());
+                snap.analysis
-                Task::Unit
+                    .prime_caches(|progress| {
+                        sender.send(Task::PrimeCaches(progress)).unwrap();
+                    })
+                    .unwrap_or_else(|_: Canceled| {
+                        // Pretend that we're done, so that the progress bar is removed. Otherwise
+                        // the editor may complain about it already existing.
+                        sender.send(Task::PrimeCaches(PrimeCachesProgress::Finished)).unwrap()
+                    });
            }
        });
    }
diff --git a/crates/rust-analyzer/src/thread_pool.rs b/crates/rust-analyzer/src/thread_pool.rs
index 4fa502925..833893739 100644
--- a/crates/rust-analyzer/src/thread_pool.rs
+++ b/crates/rust-analyzer/src/thread_pool.rs
@@ -23,6 +23,17 @@ impl<T> TaskPool<T> {
        })
    }
+    pub(crate) fn spawn_with_sender<F>(&mut self, task: F)
+    where
+        F: FnOnce(Sender<T>) + Send + 'static,
+        T: Send + 'static,
+    {
+        self.inner.execute({
+            let sender = self.sender.clone();
+            move || task(sender)
+        })
+    }
    pub(crate) fn len(&self) -> usize {
        self.inner.queued_count()
    }
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 3a184094c..74dbdfaf7 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -320,6 +320,10 @@ pub fn param(name: String, ty: String) -> ast::Param {
    ast_from_text(&format!("fn f({}: {}) {{ }}", name, ty))
 }
+pub fn ret_type(ty: ast::Type) -> ast::RetType {
+    ast_from_text(&format!("fn f() -> {} {{ }}", ty))
+}
 pub fn param_list(pats: impl IntoIterator<Item = ast::Param>) -> ast::ParamList {
    let args = pats.into_iter().join(", ");
    ast_from_text(&format!("fn f({}) {{ }}", args))
@@ -350,14 +354,20 @@ pub fn fn_(
    type_params: Option<ast::GenericParamList>,
    params: ast::ParamList,
    body: ast::BlockExpr,
+    ret_type: Option<ast::RetType>,
 ) -> ast::Fn {
    let type_params =
        if let Some(type_params) = type_params { format!("<{}>", type_params) } else { "".into() };
+    let ret_type = if let Some(ret_type) = ret_type { format!("{} ", ret_type) } else { "".into() };
    let visibility = match visibility {
        None => String::new(),
        Some(it) => format!("{} ", it),
    };
-    ast_from_text(&format!("{}fn {}{}{} {}", visibility, fn_name, type_params, params, body))
+    ast_from_text(&format!(
+        "{}fn {}{}{} {}{}",
+        visibility, fn_name, type_params, params, ret_type, body
+    ))
 }
 fn ast_from_text<N: AstNode>(text: &str) -> N {