14 files changed, 899 insertions, 105 deletions

diff --git a/crates/ide/src/completion/complete_postfix/format_like.rs b/crates/ide/src/completion/complete_postfix/format_like.rs
index 81c33bf3a..50d1e5c81 100644
--- a/crates/ide/src/completion/complete_postfix/format_like.rs
+++ b/crates/ide/src/completion/complete_postfix/format_like.rs
@@ -25,6 +25,7 @@ static KINDS: &[(&str, &str)] = &[
     ("fmt", "format!"),
     ("panic", "panic!"),
     ("println", "println!"),
+    ("eprintln", "eprintln!"),
     ("logd", "log::debug!"),
     ("logt", "log::trace!"),
     ("logi", "log::info!"),
@@ -259,6 +260,7 @@ mod tests {
     fn test_into_suggestion() {
         let test_vector = &[
             ("println!", "{}", r#"println!("{}", $1)"#),
+            ("eprintln!", "{}", r#"eprintln!("{}", $1)"#),
             (
                 "log::info!",
                 "{} {expr} {} {2 + 2}",
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index f5d627b6e..b30cdb6ed 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -96,6 +96,9 @@ pub(crate) fn diagnostics(
         .on::<hir::diagnostics::NoSuchField, _>(|d| {
             res.borrow_mut().push(diagnostic_with_fix(d, &sema));
         })
+        .on::<hir::diagnostics::IncorrectCase, _>(|d| {
+            res.borrow_mut().push(warning_with_fix(d, &sema));
+        })
         // Only collect experimental diagnostics when they're enabled.
         .filter(|diag| !(diag.is_experimental() && config.disable_experimental))
         .filter(|diag| !config.disabled.contains(diag.code().as_str()));
@@ -130,6 +133,15 @@ fn diagnostic_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabas
     }
 }
 
+fn warning_with_fix<D: DiagnosticWithFix>(d: &D, sema: &Semantics<RootDatabase>) -> Diagnostic {
+    Diagnostic {
+        range: sema.diagnostics_display_range(d).range,
+        message: d.message(),
+        severity: Severity::WeakWarning,
+        fix: d.fix(&sema),
+    }
+}
+
 fn check_unnecessary_braces_in_use_statement(
     acc: &mut Vec<Diagnostic>,
     file_id: FileId,
@@ -245,8 +257,37 @@ mod tests {
 
         assert_eq_text!(&after, &actual);
         assert!(
-            fix.fix_trigger_range.start() <= file_position.offset
-                && fix.fix_trigger_range.end() >= file_position.offset,
+            fix.fix_trigger_range.contains_inclusive(file_position.offset),
+            "diagnostic fix range {:?} does not touch cursor position {:?}",
+            fix.fix_trigger_range,
+            file_position.offset
+        );
+    }
+
+    /// Similar to `check_fix`, but applies all the available fixes.
+    fn check_fixes(ra_fixture_before: &str, ra_fixture_after: &str) {
+        let after = trim_indent(ra_fixture_after);
+
+        let (analysis, file_position) = fixture::position(ra_fixture_before);
+        let diagnostic = analysis
+            .diagnostics(&DiagnosticsConfig::default(), file_position.file_id)
+            .unwrap()
+            .pop()
+            .unwrap();
+        let fix = diagnostic.fix.unwrap();
+        let target_file_contents = analysis.file_text(file_position.file_id).unwrap();
+        let actual = {
+            let mut actual = target_file_contents.to_string();
+            // Go from the last one to the first one, so that ranges won't be affected by previous edits.
+            for edit in fix.source_change.source_file_edits.iter().rev() {
+                edit.edit.apply(&mut actual);
+            }
+            actual
+        };
+
+        assert_eq_text!(&after, &actual);
+        assert!(
+            fix.fix_trigger_range.contains_inclusive(file_position.offset),
             "diagnostic fix range {:?} does not touch cursor position {:?}",
             fix.fix_trigger_range,
             file_position.offset
@@ -790,4 +831,100 @@ struct Foo {
         let diagnostics = analysis.diagnostics(&DiagnosticsConfig::default(), file_id).unwrap();
         assert!(!diagnostics.is_empty());
     }
+
+    #[test]
+    fn test_rename_incorrect_case() {
+        check_fixes(
+            r#"
+pub struct test_struct<|> { one: i32 }
+
+pub fn some_fn(val: test_struct) -> test_struct {
+    test_struct { one: val.one + 1 }
+}
+"#,
+            r#"
+pub struct TestStruct { one: i32 }
+
+pub fn some_fn(val: TestStruct) -> TestStruct {
+    TestStruct { one: val.one + 1 }
+}
+"#,
+        );
+
+        check_fixes(
+            r#"
+pub fn some_fn(NonSnakeCase<|>: u8) -> u8 {
+    NonSnakeCase
+}
+"#,
+            r#"
+pub fn some_fn(non_snake_case: u8) -> u8 {
+    non_snake_case
+}
+"#,
+        );
+
+        check_fixes(
+            r#"
+pub fn SomeFn<|>(val: u8) -> u8 {
+    if val != 0 { SomeFn(val - 1) } else { val }
+}
+"#,
+            r#"
+pub fn some_fn(val: u8) -> u8 {
+    if val != 0 { some_fn(val - 1) } else { val }
+}
+"#,
+        );
+
+        check_fixes(
+            r#"
+fn some_fn() {
+    let whatAWeird_Formatting<|> = 10;
+    another_func(whatAWeird_Formatting);
+}
+"#,
+            r#"
+fn some_fn() {
+    let what_a_weird_formatting = 10;
+    another_func(what_a_weird_formatting);
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn test_uppercase_const_no_diagnostics() {
+        check_no_diagnostics(
+            r#"
+fn foo() {
+    const ANOTHER_ITEM<|>: &str = "some_item";
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn test_rename_incorrect_case_struct_method() {
+        check_fixes(
+            r#"
+pub struct TestStruct;
+
+impl TestStruct {
+    pub fn SomeFn<|>() -> TestStruct {
+        TestStruct
+    }
+}
+"#,
+            r#"
+pub struct TestStruct;
+
+impl TestStruct {
+    pub fn some_fn() -> TestStruct {
+        TestStruct
+    }
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index 68ae1c239..0c75e50b0 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -3,7 +3,10 @@
 use base_db::FileId;
 use hir::{
     db::AstDatabase,
-    diagnostics::{Diagnostic, MissingFields, MissingOkInTailExpr, NoSuchField, UnresolvedModule},
+    diagnostics::{
+        Diagnostic, IncorrectCase, MissingFields, MissingOkInTailExpr, NoSuchField,
+        UnresolvedModule,
+    },
     HasSource, HirDisplay, Semantics, VariantDef,
 };
 use ide_db::{
@@ -17,7 +20,7 @@ use syntax::{
 };
 use text_edit::TextEdit;
 
-use crate::diagnostics::Fix;
+use crate::{diagnostics::Fix, references::rename::rename_with_semantics, FilePosition};
 
 /// A [Diagnostic] that potentially has a fix available.
 ///
@@ -99,6 +102,23 @@ impl DiagnosticWithFix for MissingOkInTailExpr {
     }
 }
 
+impl DiagnosticWithFix for IncorrectCase {
+    fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
+        let root = sema.db.parse_or_expand(self.file)?;
+        let name_node = self.ident.to_node(&root);
+
+        let file_id = self.file.original_file(sema.db);
+        let offset = name_node.syntax().text_range().start();
+        let file_position = FilePosition { file_id, offset };
+
+        let rename_changes =
+            rename_with_semantics(sema, file_position, &self.suggested_text).ok()?;
+
+        let label = format!("Rename to {}", self.suggested_text);
+        Some(Fix::new(&label, rename_changes.info, rename_changes.range))
+    }
+}
+
 fn missing_record_expr_field_fix(
     sema: &Semantics<RootDatabase>,
     usage_file_id: FileId,
diff --git a/crates/ide/src/link_rewrite.rs b/crates/ide/src/doc_links.rs
index c317a2379..06af36b73 100644
--- a/crates/ide/src/link_rewrite.rs
+++ b/crates/ide/src/doc_links.rs
@@ -1,13 +1,27 @@
 //! Resolves and rewrites links in markdown documentation.
-//!
-//! Most of the implementation can be found in [`hir::doc_links`].
 
-use hir::{Adt, Crate, HasAttrs, ModuleDef};
-use ide_db::{defs::Definition, RootDatabase};
+use std::iter::once;
+
+use itertools::Itertools;
 use pulldown_cmark::{CowStr, Event, LinkType, Options, Parser, Tag};
 use pulldown_cmark_to_cmark::{cmark_with_options, Options as CmarkOptions};
 use url::Url;
 
+use hir::{
+    db::{DefDatabase, HirDatabase},
+    Adt, AsAssocItem, AsName, AssocItem, AssocItemContainer, Crate, Field, HasAttrs, ItemInNs,
+    ModuleDef,
+};
+use ide_db::{
+    defs::{classify_name, classify_name_ref, Definition},
+    RootDatabase,
+};
+use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
+
+use crate::{FilePosition, Semantics};
+
+pub type DocumentationLink = String;
+
 /// Rewrite documentation links in markdown to point to an online host (e.g. docs.rs)
 pub fn rewrite_links(db: &RootDatabase, markdown: &str, definition: &Definition) -> String {
     let doc = Parser::new_with_broken_link_callback(
@@ -80,6 +94,70 @@ pub fn remove_links(markdown: &str) -> String {
     out
 }
 
+// FIXME:
+// BUG: For Option::Some
+// Returns https://doc.rust-lang.org/nightly/core/prelude/v1/enum.Option.html#variant.Some
+// Instead of https://doc.rust-lang.org/nightly/core/option/enum.Option.html
+//
+// This should cease to be a problem if RFC2988 (Stable Rustdoc URLs) is implemented
+// https://github.com/rust-lang/rfcs/pull/2988
+fn get_doc_link(db: &RootDatabase, definition: Definition) -> Option<String> {
+    // Get the outermost definition for the moduledef. This is used to resolve the public path to the type,
+    // then we can join the method, field, etc onto it if required.
+    let target_def: ModuleDef = match definition {
+        Definition::ModuleDef(moddef) => match moddef {
+            ModuleDef::Function(f) => f
+                .as_assoc_item(db)
+                .and_then(|assoc| match assoc.container(db) {
+                    AssocItemContainer::Trait(t) => Some(t.into()),
+                    AssocItemContainer::ImplDef(impld) => {
+                        impld.target_ty(db).as_adt().map(|adt| adt.into())
+                    }
+                })
+                .unwrap_or_else(|| f.clone().into()),
+            moddef => moddef,
+        },
+        Definition::Field(f) => f.parent_def(db).into(),
+        // FIXME: Handle macros
+        _ => return None,
+    };
+
+    let ns = ItemInNs::from(target_def.clone());
+
+    let module = definition.module(db)?;
+    let krate = module.krate();
+    let import_map = db.import_map(krate.into());
+    let base = once(krate.declaration_name(db)?.to_string())
+        .chain(import_map.path_of(ns)?.segments.iter().map(|name| name.to_string()))
+        .join("/");
+
+    let filename = get_symbol_filename(db, &target_def);
+    let fragment = match definition {
+        Definition::ModuleDef(moddef) => match moddef {
+            ModuleDef::Function(f) => {
+                get_symbol_fragment(db, &FieldOrAssocItem::AssocItem(AssocItem::Function(f)))
+            }
+            ModuleDef::Const(c) => {
+                get_symbol_fragment(db, &FieldOrAssocItem::AssocItem(AssocItem::Const(c)))
+            }
+            ModuleDef::TypeAlias(ty) => {
+                get_symbol_fragment(db, &FieldOrAssocItem::AssocItem(AssocItem::TypeAlias(ty)))
+            }
+            _ => None,
+        },
+        Definition::Field(field) => get_symbol_fragment(db, &FieldOrAssocItem::Field(field)),
+        _ => None,
+    };
+
+    get_doc_url(db, &krate)
+        .and_then(|url| url.join(&base).ok())
+        .and_then(|url| filename.as_deref().and_then(|f| url.join(f).ok()))
+        .and_then(
+            |url| if let Some(fragment) = fragment { url.join(&fragment).ok() } else { Some(url) },
+        )
+        .map(|url| url.into_string())
+}
+
 fn rewrite_intra_doc_link(
     db: &RootDatabase,
     def: Definition,
@@ -138,7 +216,29 @@ fn rewrite_url_link(db: &RootDatabase, def: ModuleDef, target: &str) -> Option<S
         .map(|url| url.into_string())
 }
 
-// Rewrites a markdown document, resolving links using `callback` and additionally striping prefixes/suffixes on link titles.
+/// Retrieve a link to documentation for the given symbol.
+pub(crate) fn external_docs(
+    db: &RootDatabase,
+    position: &FilePosition,
+) -> Option<DocumentationLink> {
+    let sema = Semantics::new(db);
+    let file = sema.parse(position.file_id).syntax().clone();
+    let token = pick_best(file.token_at_offset(position.offset))?;
+    let token = sema.descend_into_macros(token);
+
+    let node = token.parent();
+    let definition = match_ast! {
+        match node {
+            ast::NameRef(name_ref) => classify_name_ref(&sema, &name_ref).map(|d| d.definition(sema.db)),
+            ast::Name(name) => classify_name(&sema, &name).map(|d| d.definition(sema.db)),
+            _ => None,
+        }
+    };
+
+    get_doc_link(db, definition?)
+}
+
+/// Rewrites a markdown document, applying 'callback' to each link.
 fn map_links<'e>(
     events: impl Iterator<Item = Event<'e>>,
     callback: impl Fn(&str, &str) -> (String, String),
@@ -239,6 +339,12 @@ fn ns_from_intra_spec(s: &str) -> Option<hir::Namespace> {
     .next()
 }
 
+/// Get the root URL for the documentation of a crate.
+///
+/// ```
+/// https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next
+/// ^^^^^^^^^^^^^^^^^^^^^^^^^^
+/// ```
 fn get_doc_url(db: &RootDatabase, krate: &Crate) -> Option<Url> {
     krate
         .get_html_root_url(db)
@@ -255,8 +361,11 @@ fn get_doc_url(db: &RootDatabase, krate: &Crate) -> Option<Url> {
 
 /// Get the filename and extension generated for a symbol by rustdoc.
 ///
-/// Example: `struct.Shard.html`
-fn get_symbol_filename(db: &RootDatabase, definition: &ModuleDef) -> Option<String> {
+/// ```
+/// https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next
+///                                    ^^^^^^^^^^^^^^^^^^^
+/// ```
+fn get_symbol_filename(db: &dyn HirDatabase, definition: &ModuleDef) -> Option<String> {
     Some(match definition {
         ModuleDef::Adt(adt) => match adt {
             Adt::Struct(s) => format!("struct.{}.html", s.name(db)),
@@ -266,7 +375,7 @@ fn get_symbol_filename(db: &RootDatabase, definition: &ModuleDef) -> Option<Stri
         ModuleDef::Module(_) => "index.html".to_string(),
         ModuleDef::Trait(t) => format!("trait.{}.html", t.name(db)),
         ModuleDef::TypeAlias(t) => format!("type.{}.html", t.name(db)),
-        ModuleDef::BuiltinType(t) => format!("primitive.{}.html", t),
+        ModuleDef::BuiltinType(t) => format!("primitive.{}.html", t.as_name()),
         ModuleDef::Function(f) => format!("fn.{}.html", f.name(db)),
         ModuleDef::EnumVariant(ev) => {
             format!("enum.{}.html#variant.{}", ev.parent_enum(db).name(db), ev.name(db))
@@ -275,3 +384,163 @@ fn get_symbol_filename(db: &RootDatabase, definition: &ModuleDef) -> Option<Stri
         ModuleDef::Static(s) => format!("static.{}.html", s.name(db)?),
     })
 }
+
+enum FieldOrAssocItem {
+    Field(Field),
+    AssocItem(AssocItem),
+}
+
+/// Get the fragment required to link to a specific field, method, associated type, or associated constant.
+///
+/// ```
+/// https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next
+///                                                       ^^^^^^^^^^^^^^
+/// ```
+fn get_symbol_fragment(db: &dyn HirDatabase, field_or_assoc: &FieldOrAssocItem) -> Option<String> {
+    Some(match field_or_assoc {
+        FieldOrAssocItem::Field(field) => format!("#structfield.{}", field.name(db)),
+        FieldOrAssocItem::AssocItem(assoc) => match assoc {
+            AssocItem::Function(function) => {
+                let is_trait_method = matches!(
+                    function.as_assoc_item(db).map(|assoc| assoc.container(db)),
+                    Some(AssocItemContainer::Trait(..))
+                );
+                // This distinction may get more complicated when specialisation is available.
+                // Rustdoc makes this decision based on whether a method 'has defaultness'.
+                // Currently this is only the case for provided trait methods.
+                if is_trait_method && !function.has_body(db) {
+                    format!("#tymethod.{}", function.name(db))
+                } else {
+                    format!("#method.{}", function.name(db))
+                }
+            }
+            AssocItem::Const(constant) => format!("#associatedconstant.{}", constant.name(db)?),
+            AssocItem::TypeAlias(ty) => format!("#associatedtype.{}", ty.name(db)),
+        },
+    })
+}
+
+fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
+    return tokens.max_by_key(priority);
+    fn priority(n: &SyntaxToken) -> usize {
+        match n.kind() {
+            IDENT | INT_NUMBER => 3,
+            T!['('] | T![')'] => 2,
+            kind if kind.is_trivia() => 0,
+            _ => 1,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use expect_test::{expect, Expect};
+
+    use crate::fixture;
+
+    fn check(ra_fixture: &str, expect: Expect) {
+        let (analysis, position) = fixture::position(ra_fixture);
+        let url = analysis.external_docs(position).unwrap().expect("could not find url for symbol");
+
+        expect.assert_eq(&url)
+    }
+
+    #[test]
+    fn test_doc_url_struct() {
+        check(
+            r#"
+pub struct Fo<|>o;
+"#,
+            expect![[r#"https://docs.rs/test/*/test/struct.Foo.html"#]],
+        );
+    }
+
+    #[test]
+    fn test_doc_url_fn() {
+        check(
+            r#"
+pub fn fo<|>o() {}
+"#,
+            expect![[r##"https://docs.rs/test/*/test/fn.foo.html#method.foo"##]],
+        );
+    }
+
+    #[test]
+    fn test_doc_url_inherent_method() {
+        check(
+            r#"
+pub struct Foo;
+
+impl Foo {
+    pub fn met<|>hod() {}
+}
+
+"#,
+            expect![[r##"https://docs.rs/test/*/test/struct.Foo.html#method.method"##]],
+        );
+    }
+
+    #[test]
+    fn test_doc_url_trait_provided_method() {
+        check(
+            r#"
+pub trait Bar {
+    fn met<|>hod() {}
+}
+
+"#,
+            expect![[r##"https://docs.rs/test/*/test/trait.Bar.html#method.method"##]],
+        );
+    }
+
+    #[test]
+    fn test_doc_url_trait_required_method() {
+        check(
+            r#"
+pub trait Foo {
+    fn met<|>hod();
+}
+
+"#,
+            expect![[r##"https://docs.rs/test/*/test/trait.Foo.html#tymethod.method"##]],
+        );
+    }
+
+    #[test]
+    fn test_doc_url_field() {
+        check(
+            r#"
+pub struct Foo {
+    pub fie<|>ld: ()
+}
+
+"#,
+            expect![[r##"https://docs.rs/test/*/test/struct.Foo.html#structfield.field"##]],
+        );
+    }
+
+    // FIXME: ImportMap will return re-export paths instead of public module
+    // paths. The correct path to documentation will never be a re-export.
+    // This problem stops us from resolving stdlib items included in the prelude
+    // such as `Option::Some` correctly.
+    #[ignore = "ImportMap may return re-exports"]
+    #[test]
+    fn test_reexport_order() {
+        check(
+            r#"
+pub mod wrapper {
+    pub use module::Item;
+
+    pub mod module {
+        pub struct Item;
+    }
+}
+
+fn foo() {
+    let bar: wrapper::It<|>em;
+}
+        "#,
+            expect![[r#"https://docs.rs/test/*/test/wrapper/module/struct.Item.html"#]],
+        )
+    }
+}
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 53265488e..6290b35bd 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -14,7 +14,7 @@ use test_utils::mark;
 
 use crate::{
     display::{macro_label, ShortLabel, ToNav, TryToNav},
-    link_rewrite::{remove_links, rewrite_links},
+    doc_links::{remove_links, rewrite_links},
     markdown_remove::remove_markdown,
     markup::Markup,
     runnables::runnable,
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`
-    iter_mod.visibility_of(db, &iter_trait.into()).filter(|&vis| vis == hir::Visibility::Public)?;
+    // assert this struct comes from `core::iter`
+    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(
-                db,
-                config
-                    .max_length
-                    .map(|len| len.saturating_sub(LABEL_START.len() + LABEL_END.len())),
-            );
+            let ty_display = hint_iterator(sema, config, &ty)
+                .map(|assoc_type_impl| assoc_type_impl.to_string())
+                .unwrap_or_else(|| {
+                    ty.display_truncated(
+                        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 57f3581b6..aaf9b3b4b 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -45,8 +45,8 @@ mod status;
 mod syntax_highlighting;
 mod syntax_tree;
 mod typing;
-mod link_rewrite;
 mod markdown_remove;
+mod doc_links;
 
 use std::sync::Arc;
 
@@ -77,7 +77,10 @@ pub use crate::{
     hover::{HoverAction, HoverConfig, HoverGotoTypeData, HoverResult},
     inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
     markup::Markup,
-    references::{Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult},
+    prime_caches::PrimeCachesProgress,
+    references::{
+        Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult, RenameError,
+    },
     runnables::{Runnable, RunnableKind, TestId},
     syntax_highlighting::{
         Highlight, HighlightModifier, HighlightModifiers, HighlightTag, HighlightedRange,
@@ -221,8 +224,11 @@ impl Analysis {
         self.with_db(|db| status::status(&*db, file_id))
     }
 
-    pub fn prime_caches(&self, files: Vec<FileId>) -> Cancelable<()> {
-        self.with_db(|db| prime_caches::prime_caches(db, files))
+    pub fn prime_caches<F>(&self, cb: F) -> Cancelable<()>
+    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.
@@ -382,6 +388,14 @@ impl Analysis {
         self.with_db(|db| hover::hover(db, position, links_in_hover, markdown))
     }
 
+    /// Return URL(s) for the documentation of the symbol under the cursor.
+    pub fn external_docs(
+        &self,
+        position: FilePosition,
+    ) -> Cancelable<Option<doc_links::DocumentationLink>> {
+        self.with_db(|db| doc_links::external_docs(db, &position))
+    }
+
     /// Computes parameter information for the given call expression.
     pub fn call_info(&self, position: FilePosition) -> Cancelable<Option<CallInfo>> {
         self.with_db(|db| call_info::call_info(db, position))
@@ -490,7 +504,7 @@ impl Analysis {
         &self,
         position: FilePosition,
         new_name: &str,
-    ) -> Cancelable<Option<RangeInfo<SourceChange>>> {
+    ) -> Cancelable<Result<RangeInfo<SourceChange>, RenameError>> {
         self.with_db(|db| references::rename(db, position, new_name))
     }
 
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>) {
-    for file in files {
-        let _ = crate::syntax_highlighting::highlight(db, file, None, false);
+use crate::RootDatabase;
+
+#[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/references.rs b/crates/ide/src/references.rs
index e0830eb4f..88e2f2db3 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -9,7 +9,7 @@
 //! at the index that the match starts at and its tree parent is
 //! resolved to the search element definition, we get a reference.
 
-mod rename;
+pub(crate) mod rename;
 
 use hir::Semantics;
 use ide_db::{
@@ -26,6 +26,7 @@ use syntax::{
 use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
 
 pub(crate) use self::rename::rename;
+pub use self::rename::RenameError;
 
 pub use ide_db::search::{Reference, ReferenceAccess, ReferenceKind};
 
@@ -406,6 +407,23 @@ enum Foo {
     }
 
     #[test]
+    fn test_find_all_refs_enum_var_field() {
+        check(
+            r#"
+enum Foo {
+    A,
+    B { field<|>: u8 },
+    C,
+}
+"#,
+            expect![[r#"
+                field RECORD_FIELD FileId(0) 26..35 26..31 Other
+
+            "#]],
+        );
+    }
+
+    #[test]
     fn test_find_all_refs_two_modules() {
         check(
             r#"
@@ -669,6 +687,76 @@ fn g() { f(); }
         );
     }
 
+    #[test]
+    fn test_find_all_refs_struct_pat() {
+        check(
+            r#"
+struct S {
+    field<|>: u8,
+}
+
+fn f(s: S) {
+    match s {
+        S { field } => {}
+    }
+}
+"#,
+            expect![[r#"
+                field RECORD_FIELD FileId(0) 15..24 15..20 Other
+
+                FileId(0) 68..73 FieldShorthandForField Read
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_find_all_refs_enum_var_pat() {
+        check(
+            r#"
+enum En {
+    Variant {
+        field<|>: u8,
+    }
+}
+
+fn f(e: En) {
+    match e {
+        En::Variant { field } => {}
+    }
+}
+"#,
+            expect![[r#"
+                field RECORD_FIELD FileId(0) 32..41 32..37 Other
+
+                FileId(0) 102..107 FieldShorthandForField Read
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_find_all_refs_enum_var_privacy() {
+        check(
+            r#"
+mod m {
+    pub enum En {
+        Variant {
+            field<|>: u8,
+        }
+    }
+}
+
+fn f() -> m::En {
+    m::En::Variant { field: 0 }
+}
+"#,
+            expect![[r#"
+                field RECORD_FIELD FileId(0) 56..65 56..61 Other
+
+                FileId(0) 125..130 Other Read
+            "#]],
+        );
+    }
+
     fn check(ra_fixture: &str, expect: Expect) {
         check_with_scope(ra_fixture, None, expect)
     }
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 8cbe1ae5a..f9a11e43d 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -6,11 +6,16 @@ use ide_db::{
     defs::{classify_name, classify_name_ref, Definition, NameClass, NameRefClass},
     RootDatabase,
 };
-use std::convert::TryInto;
+
+use std::{
+    convert::TryInto,
+    error::Error,
+    fmt::{self, Display},
+};
 use syntax::{
     algo::find_node_at_offset,
     ast::{self, NameOwner},
-    lex_single_valid_syntax_kind, match_ast, AstNode, SyntaxKind, SyntaxNode, SyntaxToken,
+    lex_single_syntax_kind, match_ast, AstNode, SyntaxKind, SyntaxNode, SyntaxToken,
 };
 use test_utils::mark;
 use text_edit::TextEdit;
@@ -20,17 +25,44 @@ use crate::{
     SourceChange, SourceFileEdit, TextRange, TextSize,
 };
 
+#[derive(Debug)]
+pub struct RenameError(pub(crate) String);
+
+impl fmt::Display for RenameError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl Error for RenameError {}
+
 pub(crate) fn rename(
     db: &RootDatabase,
     position: FilePosition,
     new_name: &str,
-) -> Option<RangeInfo<SourceChange>> {
+) -> Result<RangeInfo<SourceChange>, RenameError> {
     let sema = Semantics::new(db);
+    rename_with_semantics(&sema, position, new_name)
+}
 
-    match lex_single_valid_syntax_kind(new_name)? {
-        SyntaxKind::IDENT | SyntaxKind::UNDERSCORE => (),
-        SyntaxKind::SELF_KW => return rename_to_self(&sema, position),
-        _ => return None,
+pub(crate) fn rename_with_semantics(
+    sema: &Semantics<RootDatabase>,
+    position: FilePosition,
+    new_name: &str,
+) -> Result<RangeInfo<SourceChange>, RenameError> {
+    match lex_single_syntax_kind(new_name) {
+        Some(res) => match res {
+            (SyntaxKind::IDENT, _) => (),
+            (SyntaxKind::UNDERSCORE, _) => (),
+            (SyntaxKind::SELF_KW, _) => return rename_to_self(&sema, position),
+            (_, Some(syntax_error)) => {
+                return Err(RenameError(format!("Invalid name `{}`: {}", new_name, syntax_error)))
+            }
+            (_, None) => {
+                return Err(RenameError(format!("Invalid name `{}`: not an identifier", new_name)))
+            }
+        },
+        None => return Err(RenameError(format!("Invalid name `{}`: not an identifier", new_name))),
     }
 
     let source_file = sema.parse(position.file_id);
@@ -103,7 +135,7 @@ fn rename_mod(
     position: FilePosition,
     module: Module,
     new_name: &str,
-) -> Option<RangeInfo<SourceChange>> {
+) -> Result<RangeInfo<SourceChange>, RenameError> {
     let mut source_file_edits = Vec::new();
     let mut file_system_edits = Vec::new();
 
@@ -125,7 +157,7 @@ fn rename_mod(
 
     if let Some(src) = module.declaration_source(sema.db) {
         let file_id = src.file_id.original_file(sema.db);
-        let name = src.value.name()?;
+        let name = src.value.name().unwrap();
         let edit = SourceFileEdit {
             file_id,
             edit: TextEdit::replace(name.syntax().text_range(), new_name.into()),
@@ -133,35 +165,40 @@ fn rename_mod(
         source_file_edits.push(edit);
     }
 
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)?;
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)
+        .ok_or_else(|| RenameError("No references found at position".to_string()))?;
     let ref_edits = refs
         .references
         .into_iter()
         .map(|reference| source_edit_from_reference(reference, new_name));
     source_file_edits.extend(ref_edits);
 
-    Some(RangeInfo::new(range, SourceChange::from_edits(source_file_edits, file_system_edits)))
+    Ok(RangeInfo::new(range, SourceChange::from_edits(source_file_edits, file_system_edits)))
 }
 
 fn rename_to_self(
     sema: &Semantics<RootDatabase>,
     position: FilePosition,
-) -> Option<RangeInfo<SourceChange>> {
+) -> Result<RangeInfo<SourceChange>, RenameError> {
     let source_file = sema.parse(position.file_id);
     let syn = source_file.syntax();
 
-    let fn_def = find_node_at_offset::<ast::Fn>(syn, position.offset)?;
-    let params = fn_def.param_list()?;
+    let fn_def = find_node_at_offset::<ast::Fn>(syn, position.offset)
+        .ok_or_else(|| RenameError("No surrounding method declaration found".to_string()))?;
+    let params =
+        fn_def.param_list().ok_or_else(|| RenameError("Method has no parameters".to_string()))?;
     if params.self_param().is_some() {
-        return None; // method already has self param
+        return Err(RenameError("Method already has a self parameter".to_string()));
     }
-    let first_param = params.params().next()?;
+    let first_param =
+        params.params().next().ok_or_else(|| RenameError("Method has no parameters".into()))?;
     let mutable = match first_param.ty() {
         Some(ast::Type::RefType(rt)) => rt.mut_token().is_some(),
-        _ => return None, // not renaming other types
+        _ => return Err(RenameError("Not renaming other types".to_string())),
     };
 
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)?;
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)
+        .ok_or_else(|| RenameError("No reference found at position".to_string()))?;
 
     let param_range = first_param.syntax().text_range();
     let (param_ref, usages): (Vec<Reference>, Vec<Reference>) = refs
@@ -169,7 +206,7 @@ fn rename_to_self(
         .partition(|reference| param_range.intersect(reference.file_range.range).is_some());
 
     if param_ref.is_empty() {
-        return None;
+        return Err(RenameError("Parameter to rename not found".to_string()));
     }
 
     let mut edits = usages
@@ -185,7 +222,7 @@ fn rename_to_self(
         ),
     });
 
-    Some(RangeInfo::new(range, SourceChange::from(edits)))
+    Ok(RangeInfo::new(range, SourceChange::from(edits)))
 }
 
 fn text_edit_from_self_param(
@@ -216,12 +253,13 @@ fn rename_self_to_param(
     position: FilePosition,
     self_token: SyntaxToken,
     new_name: &str,
-) -> Option<RangeInfo<SourceChange>> {
+) -> Result<RangeInfo<SourceChange>, RenameError> {
     let source_file = sema.parse(position.file_id);
     let syn = source_file.syntax();
 
     let text = sema.db.file_text(position.file_id);
-    let fn_def = find_node_at_offset::<ast::Fn>(syn, position.offset)?;
+    let fn_def = find_node_at_offset::<ast::Fn>(syn, position.offset)
+        .ok_or_else(|| RenameError("No surrounding method declaration found".to_string()))?;
     let search_range = fn_def.syntax().text_range();
 
     let mut edits: Vec<SourceFileEdit> = vec![];
@@ -235,7 +273,8 @@ fn rename_self_to_param(
             syn.token_at_offset(offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
         {
             let edit = if let Some(ref self_param) = ast::SelfParam::cast(usage.parent()) {
-                text_edit_from_self_param(syn, self_param, new_name)?
+                text_edit_from_self_param(syn, self_param, new_name)
+                    .ok_or_else(|| RenameError("No target type found".to_string()))?
             } else {
                 TextEdit::replace(usage.text_range(), String::from(new_name))
             };
@@ -246,15 +285,18 @@ fn rename_self_to_param(
     let range = ast::SelfParam::cast(self_token.parent())
         .map_or(self_token.text_range(), |p| p.syntax().text_range());
 
-    Some(RangeInfo::new(range, SourceChange::from(edits)))
+    Ok(RangeInfo::new(range, SourceChange::from(edits)))
 }
 
 fn rename_reference(
     sema: &Semantics<RootDatabase>,
     position: FilePosition,
     new_name: &str,
-) -> Option<RangeInfo<SourceChange>> {
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)?;
+) -> Result<RangeInfo<SourceChange>, RenameError> {
+    let RangeInfo { range, info: refs } = match find_all_refs(sema, position, None) {
+        Some(range_info) => range_info,
+        None => return Err(RenameError("No references found at position".to_string())),
+    };
 
     let edit = refs
         .into_iter()
@@ -262,10 +304,10 @@ fn rename_reference(
         .collect::<Vec<_>>();
 
     if edit.is_empty() {
-        return None;
+        return Err(RenameError("No references found at position".to_string()));
     }
 
-    Some(RangeInfo::new(range, SourceChange::from(edit)))
+    Ok(RangeInfo::new(range, SourceChange::from(edit)))
 }
 
 #[cfg(test)]
@@ -280,25 +322,45 @@ mod tests {
     fn check(new_name: &str, ra_fixture_before: &str, ra_fixture_after: &str) {
         let ra_fixture_after = &trim_indent(ra_fixture_after);
         let (analysis, position) = fixture::position(ra_fixture_before);
-        let source_change = analysis.rename(position, new_name).unwrap();
-        let mut text_edit_builder = TextEdit::builder();
-        let mut file_id: Option<FileId> = None;
-        if let Some(change) = source_change {
-            for edit in change.info.source_file_edits {
-                file_id = Some(edit.file_id);
-                for indel in edit.edit.into_iter() {
-                    text_edit_builder.replace(indel.delete, indel.insert);
+        let rename_result = analysis
+            .rename(position, new_name)
+            .unwrap_or_else(|err| panic!("Rename to '{}' was cancelled: {}", new_name, err));
+        match rename_result {
+            Ok(source_change) => {
+                let mut text_edit_builder = TextEdit::builder();
+                let mut file_id: Option<FileId> = None;
+                for edit in source_change.info.source_file_edits {
+                    file_id = Some(edit.file_id);
+                    for indel in edit.edit.into_iter() {
+                        text_edit_builder.replace(indel.delete, indel.insert);
+                    }
                 }
+                let mut result = analysis.file_text(file_id.unwrap()).unwrap().to_string();
+                text_edit_builder.finish().apply(&mut result);
+                assert_eq_text!(ra_fixture_after, &*result);
             }
-        }
-        let mut result = analysis.file_text(file_id.unwrap()).unwrap().to_string();
-        text_edit_builder.finish().apply(&mut result);
-        assert_eq_text!(ra_fixture_after, &*result);
+            Err(err) => {
+                if ra_fixture_after.starts_with("error:") {
+                    let error_message = ra_fixture_after
+                        .chars()
+                        .into_iter()
+                        .skip("error:".len())
+                        .collect::<String>();
+                    assert_eq!(error_message.trim(), err.to_string());
+                    return;
+                } else {
+                    panic!("Rename to '{}' failed unexpectedly: {}", new_name, err)
+                }
+            }
+        };
     }
 
     fn check_expect(new_name: &str, ra_fixture: &str, expect: Expect) {
         let (analysis, position) = fixture::position(ra_fixture);
-        let source_change = analysis.rename(position, new_name).unwrap().unwrap();
+        let source_change = analysis
+            .rename(position, new_name)
+            .unwrap()
+            .expect("Expect returned RangeInfo to be Some, but was None");
         expect.assert_debug_eq(&source_change)
     }
 
@@ -313,11 +375,30 @@ mod tests {
     }
 
     #[test]
-    fn test_rename_to_invalid_identifier() {
-        let (analysis, position) = fixture::position(r#"fn main() { let i<|> = 1; }"#);
-        let new_name = "invalid!";
-        let source_change = analysis.rename(position, new_name).unwrap();
-        assert!(source_change.is_none());
+    fn test_rename_to_invalid_identifier1() {
+        check(
+            "invalid!",
+            r#"fn main() { let i<|> = 1; }"#,
+            "error: Invalid name `invalid!`: not an identifier",
+        );
+    }
+
+    #[test]
+    fn test_rename_to_invalid_identifier2() {
+        check(
+            "multiple tokens",
+            r#"fn main() { let i<|> = 1; }"#,
+            "error: Invalid name `multiple tokens`: not an identifier",
+        );
+    }
+
+    #[test]
+    fn test_rename_to_invalid_identifier3() {
+        check(
+            "let",
+            r#"fn main() { let i<|> = 1; }"#,
+            "error: Invalid name `let`: not an identifier",
+        );
     }
 
     #[test]
@@ -350,6 +431,15 @@ fn main() {
     }
 
     #[test]
+    fn test_rename_unresolved_reference() {
+        check(
+            "new_name",
+            r#"fn main() { let _ = unresolved_ref<|>; }"#,
+            "error: No references found at position",
+        );
+    }
+
+    #[test]
     fn test_rename_for_macro_args() {
         check(
             "b",
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);