11 files changed, 501 insertions, 313 deletions

diff --git a/crates/ide/src/completion.rs b/crates/ide/src/completion.rs
index 697f691b0..b0e35b2bd 100644
--- a/crates/ide/src/completion.rs
+++ b/crates/ide/src/completion.rs
@@ -61,6 +61,8 @@ pub use crate::completion::{
 // - `expr.refm` -> `&mut expr`
 // - `expr.not` -> `!expr`
 // - `expr.dbg` -> `dbg!(expr)`
+// - `expr.dbgr` -> `dbg!(&expr)`
+// - `expr.call` -> `(expr)`
 //
 // There also snippet completions:
 //
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index b30cdb6ed..1e5ea4617 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -5,6 +5,7 @@
 //! original files. So we need to map the ranges.
 
 mod fixes;
+mod field_shorthand;
 
 use std::cell::RefCell;
 
@@ -80,7 +81,7 @@ pub(crate) fn diagnostics(
 
     for node in parse.tree().syntax().descendants() {
         check_unnecessary_braces_in_use_statement(&mut res, file_id, &node);
-        check_struct_shorthand_initialization(&mut res, file_id, &node);
+        field_shorthand::check(&mut res, file_id, &node);
     }
     let res = RefCell::new(res);
     let sink_builder = DiagnosticSinkBuilder::new()
@@ -188,42 +189,6 @@ fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
     None
 }
 
-fn check_struct_shorthand_initialization(
-    acc: &mut Vec<Diagnostic>,
-    file_id: FileId,
-    node: &SyntaxNode,
-) -> Option<()> {
-    let record_lit = ast::RecordExpr::cast(node.clone())?;
-    let record_field_list = record_lit.record_expr_field_list()?;
-    for record_field in record_field_list.fields() {
-        if let (Some(name_ref), Some(expr)) = (record_field.name_ref(), record_field.expr()) {
-            let field_name = name_ref.syntax().text().to_string();
-            let field_expr = expr.syntax().text().to_string();
-            let field_name_is_tup_index = name_ref.as_tuple_field().is_some();
-            if field_name == field_expr && !field_name_is_tup_index {
-                let mut edit_builder = TextEdit::builder();
-                edit_builder.delete(record_field.syntax().text_range());
-                edit_builder.insert(record_field.syntax().text_range().start(), field_name);
-                let edit = edit_builder.finish();
-
-                let field_range = record_field.syntax().text_range();
-                acc.push(Diagnostic {
-                    // name: None,
-                    range: field_range,
-                    message: "Shorthand struct initialization".to_string(),
-                    severity: Severity::WeakWarning,
-                    fix: Some(Fix::new(
-                        "Use struct shorthand initialization",
-                        SourceFileEdit { file_id, edit }.into(),
-                        field_range,
-                    )),
-                });
-            }
-        }
-    }
-    Some(())
-}
-
 #[cfg(test)]
 mod tests {
     use expect_test::{expect, Expect};
@@ -237,7 +202,7 @@ mod tests {
     ///  * a diagnostic is produced
     ///  * this diagnostic fix trigger range touches the input cursor position
     ///  * that the contents of the file containing the cursor match `after` after the diagnostic fix is applied
-    fn check_fix(ra_fixture_before: &str, ra_fixture_after: &str) {
+    pub(super) fn check_fix(ra_fixture_before: &str, ra_fixture_after: &str) {
         let after = trim_indent(ra_fixture_after);
 
         let (analysis, file_position) = fixture::position(ra_fixture_before);
@@ -319,7 +284,7 @@ mod tests {
 
     /// Takes a multi-file input fixture with annotated cursor position and checks that no diagnostics
     /// apply to the file containing the cursor.
-    fn check_no_diagnostics(ra_fixture: &str) {
+    pub(crate) fn check_no_diagnostics(ra_fixture: &str) {
         let (analysis, files) = fixture::files(ra_fixture);
         let diagnostics = files
             .into_iter()
@@ -720,58 +685,6 @@ mod a {
     }
 
     #[test]
-    fn test_check_struct_shorthand_initialization() {
-        check_no_diagnostics(
-            r#"
-struct A { a: &'static str }
-fn main() { A { a: "hello" } }
-"#,
-        );
-        check_no_diagnostics(
-            r#"
-struct A(usize);
-fn main() { A { 0: 0 } }
-"#,
-        );
-
-        check_fix(
-            r#"
-struct A { a: &'static str }
-fn main() {
-    let a = "haha";
-    A { a<|>: a }
-}
-"#,
-            r#"
-struct A { a: &'static str }
-fn main() {
-    let a = "haha";
-    A { a }
-}
-"#,
-        );
-
-        check_fix(
-            r#"
-struct A { a: &'static str, b: &'static str }
-fn main() {
-    let a = "haha";
-    let b = "bb";
-    A { a<|>: a, b }
-}
-"#,
-            r#"
-struct A { a: &'static str, b: &'static str }
-fn main() {
-    let a = "haha";
-    let b = "bb";
-    A { a, b }
-}
-"#,
-        );
-    }
-
-    #[test]
     fn test_add_field_from_usage() {
         check_fix(
             r"
diff --git a/crates/ide/src/diagnostics/field_shorthand.rs b/crates/ide/src/diagnostics/field_shorthand.rs
new file mode 100644
index 000000000..2c4acd783
--- /dev/null
+++ b/crates/ide/src/diagnostics/field_shorthand.rs
@@ -0,0 +1,206 @@
+//! Suggests shortening `Foo { field: field }` to `Foo { field }` in both
+//! expressions and patterns.
+
+use base_db::FileId;
+use ide_db::source_change::SourceFileEdit;
+use syntax::{ast, match_ast, AstNode, SyntaxNode};
+use text_edit::TextEdit;
+
+use crate::{Diagnostic, Fix, Severity};
+
+pub(super) fn check(acc: &mut Vec<Diagnostic>, file_id: FileId, node: &SyntaxNode) {
+    match_ast! {
+        match node {
+            ast::RecordExpr(it) => check_expr_field_shorthand(acc, file_id, it),
+            ast::RecordPat(it) => check_pat_field_shorthand(acc, file_id, it),
+            _ => ()
+        }
+    };
+}
+
+fn check_expr_field_shorthand(
+    acc: &mut Vec<Diagnostic>,
+    file_id: FileId,
+    record_expr: ast::RecordExpr,
+) {
+    let record_field_list = match record_expr.record_expr_field_list() {
+        Some(it) => it,
+        None => return,
+    };
+    for record_field in record_field_list.fields() {
+        let (name_ref, expr) = match record_field.name_ref().zip(record_field.expr()) {
+            Some(it) => it,
+            None => continue,
+        };
+
+        let field_name = name_ref.syntax().text().to_string();
+        let field_expr = expr.syntax().text().to_string();
+        let field_name_is_tup_index = name_ref.as_tuple_field().is_some();
+        if field_name != field_expr || field_name_is_tup_index {
+            continue;
+        }
+
+        let mut edit_builder = TextEdit::builder();
+        edit_builder.delete(record_field.syntax().text_range());
+        edit_builder.insert(record_field.syntax().text_range().start(), field_name);
+        let edit = edit_builder.finish();
+
+        let field_range = record_field.syntax().text_range();
+        acc.push(Diagnostic {
+            // name: None,
+            range: field_range,
+            message: "Shorthand struct initialization".to_string(),
+            severity: Severity::WeakWarning,
+            fix: Some(Fix::new(
+                "Use struct shorthand initialization",
+                SourceFileEdit { file_id, edit }.into(),
+                field_range,
+            )),
+        });
+    }
+}
+
+fn check_pat_field_shorthand(
+    acc: &mut Vec<Diagnostic>,
+    file_id: FileId,
+    record_pat: ast::RecordPat,
+) {
+    let record_pat_field_list = match record_pat.record_pat_field_list() {
+        Some(it) => it,
+        None => return,
+    };
+    for record_pat_field in record_pat_field_list.fields() {
+        let (name_ref, pat) = match record_pat_field.name_ref().zip(record_pat_field.pat()) {
+            Some(it) => it,
+            None => continue,
+        };
+
+        let field_name = name_ref.syntax().text().to_string();
+        let field_pat = pat.syntax().text().to_string();
+        let field_name_is_tup_index = name_ref.as_tuple_field().is_some();
+        if field_name != field_pat || field_name_is_tup_index {
+            continue;
+        }
+
+        let mut edit_builder = TextEdit::builder();
+        edit_builder.delete(record_pat_field.syntax().text_range());
+        edit_builder.insert(record_pat_field.syntax().text_range().start(), field_name);
+        let edit = edit_builder.finish();
+
+        let field_range = record_pat_field.syntax().text_range();
+        acc.push(Diagnostic {
+            // name: None,
+            range: field_range,
+            message: "Shorthand struct pattern".to_string(),
+            severity: Severity::WeakWarning,
+            fix: Some(Fix::new(
+                "Use struct field shorthand",
+                SourceFileEdit { file_id, edit }.into(),
+                field_range,
+            )),
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::diagnostics::tests::{check_fix, check_no_diagnostics};
+
+    #[test]
+    fn test_check_expr_field_shorthand() {
+        check_no_diagnostics(
+            r#"
+struct A { a: &'static str }
+fn main() { A { a: "hello" } }
+"#,
+        );
+        check_no_diagnostics(
+            r#"
+struct A(usize);
+fn main() { A { 0: 0 } }
+"#,
+        );
+
+        check_fix(
+            r#"
+struct A { a: &'static str }
+fn main() {
+    let a = "haha";
+    A { a<|>: a }
+}
+"#,
+            r#"
+struct A { a: &'static str }
+fn main() {
+    let a = "haha";
+    A { a }
+}
+"#,
+        );
+
+        check_fix(
+            r#"
+struct A { a: &'static str, b: &'static str }
+fn main() {
+    let a = "haha";
+    let b = "bb";
+    A { a<|>: a, b }
+}
+"#,
+            r#"
+struct A { a: &'static str, b: &'static str }
+fn main() {
+    let a = "haha";
+    let b = "bb";
+    A { a, b }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn test_check_pat_field_shorthand() {
+        check_no_diagnostics(
+            r#"
+struct A { a: &'static str }
+fn f(a: A) { let A { a: hello } = a; }
+"#,
+        );
+        check_no_diagnostics(
+            r#"
+struct A(usize);
+fn f(a: A) { let A { 0: 0 } = a; }
+"#,
+        );
+
+        check_fix(
+            r#"
+struct A { a: &'static str }
+fn f(a: A) {
+    let A { a<|>: a } = a;
+}
+"#,
+            r#"
+struct A { a: &'static str }
+fn f(a: A) {
+    let A { a } = a;
+}
+"#,
+        );
+
+        check_fix(
+            r#"
+struct A { a: &'static str, b: &'static str }
+fn f(a: A) {
+    let A { a<|>: a, b } = a;
+}
+"#,
+            r#"
+struct A { a: &'static str, b: &'static str }
+fn f(a: A) {
+    let A { a, b } = a;
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index 06af36b73..d9dc63b33 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -1,9 +1,10 @@
 //! Resolves and rewrites links in markdown documentation.
 
+use std::convert::TryFrom;
 use std::iter::once;
 
 use itertools::Itertools;
-use pulldown_cmark::{CowStr, Event, LinkType, Options, Parser, Tag};
+use pulldown_cmark::{BrokenLink, CowStr, Event, InlineStr, LinkType, Options, Parser, Tag};
 use pulldown_cmark_to_cmark::{cmark_with_options, Options as CmarkOptions};
 use url::Url;
 
@@ -13,7 +14,7 @@ use hir::{
     ModuleDef,
 };
 use ide_db::{
-    defs::{classify_name, classify_name_ref, Definition},
+    defs::{Definition, NameClass, NameRefClass},
     RootDatabase,
 };
 use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
@@ -24,11 +25,13 @@ 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(
-        markdown,
-        Options::empty(),
-        Some(&|label, _| Some((/*url*/ label.to_string(), /*title*/ label.to_string()))),
-    );
+    let mut cb = |link: BrokenLink| {
+        Some((
+            /*url*/ link.reference.to_owned().into(),
+            /*title*/ link.reference.to_owned().into(),
+        ))
+    };
+    let doc = Parser::new_with_broken_link_callback(markdown, Options::empty(), Some(&mut cb));
 
     let doc = map_links(doc, |target, title: &str| {
         // This check is imperfect, there's some overlap between valid intra-doc links
@@ -66,11 +69,11 @@ pub fn remove_links(markdown: &str) -> String {
     let mut opts = Options::empty();
     opts.insert(Options::ENABLE_FOOTNOTES);
 
-    let doc = Parser::new_with_broken_link_callback(
-        markdown,
-        opts,
-        Some(&|_, _| Some((String::new(), String::new()))),
-    );
+    let mut cb = |_: BrokenLink| {
+        let empty = InlineStr::try_from("").unwrap();
+        Some((CowStr::Inlined(empty.clone()), CowStr::Inlined(empty)))
+    };
+    let doc = Parser::new_with_broken_link_callback(markdown, opts, Some(&mut cb));
     let doc = doc.filter_map(move |evt| match evt {
         Event::Start(Tag::Link(link_type, ref target, ref title)) => {
             if link_type == LinkType::Inline && target.contains("://") {
@@ -229,8 +232,8 @@ pub(crate) fn external_docs(
     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)),
+            ast::NameRef(name_ref) => NameRefClass::classify(&sema, &name_ref).map(|d| d.referenced(sema.db)),
+            ast::Name(name) => NameClass::classify(&sema, &name).map(|d| d.referenced_or_defined(sema.db)),
             _ => None,
         }
     };
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 582bf4837..a87e31019 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1,6 +1,6 @@
 use hir::Semantics;
 use ide_db::{
-    defs::{classify_name, classify_name_ref},
+    defs::{NameClass, NameRefClass},
     symbol_index, RootDatabase,
 };
 use syntax::{
@@ -40,7 +40,7 @@ pub(crate) fn goto_definition(
                 reference_definition(&sema, &name_ref).to_vec()
             },
             ast::Name(name) => {
-                let def = classify_name(&sema, &name)?.definition(sema.db);
+                let def = NameClass::classify(&sema, &name)?.referenced_or_defined(sema.db);
                 let nav = def.try_to_nav(sema.db)?;
                 vec![nav]
             },
@@ -81,9 +81,9 @@ pub(crate) fn reference_definition(
     sema: &Semantics<RootDatabase>,
     name_ref: &ast::NameRef,
 ) -> ReferenceResult {
-    let name_kind = classify_name_ref(sema, name_ref);
+    let name_kind = NameRefClass::classify(sema, name_ref);
     if let Some(def) = name_kind {
-        let def = def.definition(sema.db);
+        let def = def.referenced(sema.db);
         return match def.try_to_nav(sema.db) {
             Some(nav) => ReferenceResult::Exact(nav),
             None => ReferenceResult::Approximate(Vec::new()),
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 6290b35bd..845333e2a 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -4,7 +4,7 @@ use hir::{
     Module, ModuleDef, ModuleSource, Semantics,
 };
 use ide_db::{
-    defs::{classify_name, classify_name_ref, Definition},
+    defs::{Definition, NameClass, NameRefClass},
     RootDatabase,
 };
 use itertools::Itertools;
@@ -107,8 +107,8 @@ pub(crate) fn hover(
     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)),
+            ast::Name(name) => NameClass::classify(&sema, &name).and_then(|d| d.defined(sema.db)),
+            ast::NameRef(name_ref) => NameRefClass::classify(&sema, &name_ref).map(|d| d.referenced(sema.db)),
             _ => None,
         }
     };
@@ -3232,4 +3232,27 @@ fn main() { let foo_test = name_with_dashes::wrapper::Thing::new<|>(); }
             "#]],
         )
     }
+
+    #[test]
+    fn hover_field_pat_shorthand_ref_match_ergonomics() {
+        check(
+            r#"
+struct S {
+    f: i32,
+}
+
+fn main() {
+    let s = S { f: 0 };
+    let S { f<|> } = &s;
+}
+"#,
+            expect![[r#"
+                *f*
+
+                ```rust
+                &i32
+                ```
+            "#]],
+        );
+    }
 }
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 88e2f2db3..67ec257a8 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -13,7 +13,7 @@ pub(crate) mod rename;
 
 use hir::Semantics;
 use ide_db::{
-    defs::{classify_name, classify_name_ref, Definition},
+    defs::{Definition, NameClass, NameRefClass},
     search::SearchScope,
     RootDatabase,
 };
@@ -132,13 +132,13 @@ fn find_name(
     opt_name: Option<ast::Name>,
 ) -> Option<RangeInfo<Definition>> {
     if let Some(name) = opt_name {
-        let def = classify_name(sema, &name)?.definition(sema.db);
+        let def = NameClass::classify(sema, &name)?.referenced_or_defined(sema.db);
         let range = name.syntax().text_range();
         return Some(RangeInfo::new(range, def));
     }
     let name_ref =
         sema.find_node_at_offset_with_descend::<ast::NameRef>(&syntax, position.offset)?;
-    let def = classify_name_ref(sema, &name_ref)?.definition(sema.db);
+    let def = NameRefClass::classify(sema, &name_ref)?.referenced(sema.db);
     let range = name_ref.syntax().text_range();
     Some(RangeInfo::new(range, def))
 }
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index f9a11e43d..35aafc49d 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -3,7 +3,7 @@
 use base_db::SourceDatabaseExt;
 use hir::{Module, ModuleDef, ModuleSource, Semantics};
 use ide_db::{
-    defs::{classify_name, classify_name_ref, Definition, NameClass, NameRefClass},
+    defs::{Definition, NameClass, NameRefClass},
     RootDatabase,
 };
 
@@ -88,13 +88,13 @@ fn find_module_at_offset(
     let module = match_ast! {
         match (ident.parent()) {
             ast::NameRef(name_ref) => {
-                match classify_name_ref(sema, &name_ref)? {
+                match NameRefClass::classify(sema, &name_ref)? {
                     NameRefClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
                     _ => return None,
                 }
             },
             ast::Name(name) => {
-                match classify_name(&sema, &name)? {
+                match NameClass::classify(&sema, &name)? {
                     NameClass::Definition(Definition::ModuleDef(ModuleDef::Module(module))) => module,
                     _ => return None,
                 }
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 6aafd6fd5..b35c03162 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -1,12 +1,14 @@
-mod tags;
+mod format;
 mod html;
 mod injection;
+mod macro_rules;
+mod tags;
 #[cfg(test)]
 mod tests;
 
 use hir::{Local, Name, Semantics, VariantDef};
 use ide_db::{
-    defs::{classify_name, classify_name_ref, Definition, NameClass, NameRefClass},
+    defs::{Definition, NameClass, NameRefClass},
     RootDatabase,
 };
 use rustc_hash::FxHashMap;
@@ -17,9 +19,11 @@ use syntax::{
     SyntaxNode, SyntaxToken, TextRange, WalkEvent, T,
 };
 
-use crate::FileId;
+use crate::{
+    syntax_highlighting::{format::FormatStringHighlighter, macro_rules::MacroRulesHighlighter},
+    FileId,
+};
 
-use ast::FormatSpecifier;
 pub(crate) use html::highlight_as_html;
 pub use tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag};
 
@@ -68,8 +72,9 @@ 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, Option<MacroMatcherParseState>)> = None;
-    let mut format_string: Option<SyntaxElement> = None;
+    let mut current_macro_call: Option<ast::MacroCall> = None;
+    let mut format_string_highlighter = FormatStringHighlighter::default();
+    let mut macro_rules_highlighter = MacroRulesHighlighter::default();
 
     // Walk all nodes, keeping track of whether we are inside a macro or not.
     // If in macro, expand it first and highlight the expanded code.
@@ -99,9 +104,8 @@ 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());
+                    macro_rules_highlighter.init();
                     if let Some((highlight, binding_hash)) = highlight_element(
                         &sema,
                         &mut bindings_shadow_count,
@@ -115,13 +119,14 @@ pub(crate) fn highlight(
                         });
                     }
                 }
-                current_macro_call = Some((mc.clone(), is_macro_rules));
+                current_macro_call = Some(mc.clone());
                 continue;
             }
             WalkEvent::Leave(Some(mc)) => {
-                assert!(current_macro_call.map(|it| it.0) == Some(mc));
+                assert!(current_macro_call == Some(mc));
                 current_macro_call = None;
-                format_string = None;
+                format_string_highlighter = FormatStringHighlighter::default();
+                macro_rules_highlighter = MacroRulesHighlighter::default();
             }
             _ => (),
         }
@@ -148,20 +153,6 @@ 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 {
@@ -173,29 +164,9 @@ pub(crate) fn highlight(
             let token = sema.descend_into_macros(token.clone());
             let parent = token.parent();
 
-            // Check if macro takes a format string and remember it for highlighting later.
-            // The macros that accept a format string expand to a compiler builtin macros
-            // `format_args` and `format_args_nl`.
-            if let Some(name) = parent
-                .parent()
-                .and_then(ast::MacroCall::cast)
-                .and_then(|mc| mc.path())
-                .and_then(|p| p.segment())
-                .and_then(|s| s.name_ref())
-            {
-                match name.text().as_str() {
-                    "format_args" | "format_args_nl" => {
-                        format_string = parent
-                            .children_with_tokens()
-                            .filter(|t| t.kind() != WHITESPACE)
-                            .nth(1)
-                            .filter(|e| {
-                                ast::String::can_cast(e.kind())
-                                    || ast::RawString::can_cast(e.kind())
-                            })
-                    }
-                    _ => {}
-                }
+            format_string_highlighter.check_for_format_string(&parent);
+            if let Some(tok) = element.as_token() {
+                macro_rules_highlighter.advance(tok);
             }
 
             // We only care Name and Name_ref
@@ -214,31 +185,20 @@ pub(crate) fn highlight(
             }
         }
 
-        let is_format_string = format_string.as_ref() == Some(&element_to_highlight);
-
         if let Some((highlight, binding_hash)) = highlight_element(
             &sema,
             &mut bindings_shadow_count,
             syntactic_name_ref_highlighting,
             element_to_highlight.clone(),
         ) {
-            stack.add(HighlightedRange { range, highlight, binding_hash });
+            if macro_rules_highlighter.highlight(element_to_highlight.clone()).is_none() {
+                stack.add(HighlightedRange { range, highlight, binding_hash });
+            }
+
             if let Some(string) =
                 element_to_highlight.as_token().cloned().and_then(ast::String::cast)
             {
-                if is_format_string {
-                    stack.push();
-                    string.lex_format_specifier(|piece_range, kind| {
-                        if let Some(highlight) = highlight_format_specifier(kind) {
-                            stack.add(HighlightedRange {
-                                range: piece_range + range.start(),
-                                highlight: highlight.into(),
-                                binding_hash: None,
-                            });
-                        }
-                    });
-                    stack.pop();
-                }
+                format_string_highlighter.highlight_format_string(&mut stack, &string, range);
                 // Highlight escape sequences
                 if let Some(char_ranges) = string.char_ranges() {
                     stack.push();
@@ -256,19 +216,7 @@ pub(crate) fn highlight(
             } else if let Some(string) =
                 element_to_highlight.as_token().cloned().and_then(ast::RawString::cast)
             {
-                if is_format_string {
-                    stack.push();
-                    string.lex_format_specifier(|piece_range, kind| {
-                        if let Some(highlight) = highlight_format_specifier(kind) {
-                            stack.add(HighlightedRange {
-                                range: piece_range + range.start(),
-                                highlight: highlight.into(),
-                                binding_hash: None,
-                            });
-                        }
-                    });
-                    stack.pop();
-                }
+                format_string_highlighter.highlight_format_string(&mut stack, &string, range);
             }
         }
     }
@@ -436,24 +384,6 @@ impl HighlightedRangeStack {
     }
 }
 
-fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HighlightTag> {
-    Some(match kind {
-        FormatSpecifier::Open
-        | FormatSpecifier::Close
-        | FormatSpecifier::Colon
-        | FormatSpecifier::Fill
-        | FormatSpecifier::Align
-        | FormatSpecifier::Sign
-        | FormatSpecifier::NumberSign
-        | FormatSpecifier::DollarSign
-        | FormatSpecifier::Dot
-        | FormatSpecifier::Asterisk
-        | FormatSpecifier::QuestionMark => HighlightTag::FormatSpecifier,
-        FormatSpecifier::Integer | FormatSpecifier::Zero => HighlightTag::NumericLiteral,
-        FormatSpecifier::Identifier => HighlightTag::Local,
-    })
-}
-
 fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
     let path = macro_call.path()?;
     let name_ref = path.segment()?.name_ref()?;
@@ -513,7 +443,7 @@ fn highlight_element(
         // Highlight definitions depending on the "type" of the definition.
         NAME => {
             let name = element.into_node().and_then(ast::Name::cast).unwrap();
-            let name_kind = classify_name(sema, &name);
+            let name_kind = NameClass::classify(sema, &name);
 
             if let Some(NameClass::Definition(Definition::Local(local))) = &name_kind {
                 if let Some(name) = local.name(db) {
@@ -529,9 +459,9 @@ fn highlight_element(
                     highlight_def(db, def) | HighlightModifier::Definition
                 }
                 Some(NameClass::ConstReference(def)) => highlight_def(db, def),
-                Some(NameClass::FieldShorthand { field, .. }) => {
+                Some(NameClass::PatFieldShorthand { field_ref, .. }) => {
                     let mut h = HighlightTag::Field.into();
-                    if let Definition::Field(field) = field {
+                    if let Definition::Field(field) = field_ref {
                         if let VariantDef::Union(_) = field.parent_def(db) {
                             h |= HighlightModifier::Unsafe;
                         }
@@ -550,7 +480,7 @@ fn highlight_element(
         NAME_REF => {
             let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
             highlight_func_by_name_ref(sema, &name_ref).unwrap_or_else(|| {
-                match classify_name_ref(sema, &name_ref) {
+                match NameRefClass::classify(sema, &name_ref) {
                     Some(name_kind) => match name_kind {
                         NameRefClass::ExternCrate(_) => HighlightTag::Module.into(),
                         NameRefClass::Definition(def) => {
@@ -934,99 +864,3 @@ 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/format.rs b/crates/ide/src/syntax_highlighting/format.rs
new file mode 100644
index 000000000..71bde24f0
--- /dev/null
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -0,0 +1,78 @@
+//! Syntax highlighting for format macro strings.
+use syntax::{
+    ast::{self, FormatSpecifier, HasFormatSpecifier},
+    AstNode, AstToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange,
+};
+
+use crate::{syntax_highlighting::HighlightedRangeStack, HighlightTag, HighlightedRange};
+
+#[derive(Default)]
+pub(super) struct FormatStringHighlighter {
+    format_string: Option<SyntaxElement>,
+}
+
+impl FormatStringHighlighter {
+    pub(super) fn check_for_format_string(&mut self, parent: &SyntaxNode) {
+        // Check if macro takes a format string and remember it for highlighting later.
+        // The macros that accept a format string expand to a compiler builtin macros
+        // `format_args` and `format_args_nl`.
+        if let Some(name) = parent
+            .parent()
+            .and_then(ast::MacroCall::cast)
+            .and_then(|mc| mc.path())
+            .and_then(|p| p.segment())
+            .and_then(|s| s.name_ref())
+        {
+            match name.text().as_str() {
+                "format_args" | "format_args_nl" => {
+                    self.format_string = parent
+                        .children_with_tokens()
+                        .filter(|t| t.kind() != SyntaxKind::WHITESPACE)
+                        .nth(1)
+                        .filter(|e| {
+                            ast::String::can_cast(e.kind()) || ast::RawString::can_cast(e.kind())
+                        })
+                }
+                _ => {}
+            }
+        }
+    }
+    pub(super) fn highlight_format_string(
+        &self,
+        range_stack: &mut HighlightedRangeStack,
+        string: &impl HasFormatSpecifier,
+        range: TextRange,
+    ) {
+        if self.format_string.as_ref() == Some(&SyntaxElement::from(string.syntax().clone())) {
+            range_stack.push();
+            string.lex_format_specifier(|piece_range, kind| {
+                if let Some(highlight) = highlight_format_specifier(kind) {
+                    range_stack.add(HighlightedRange {
+                        range: piece_range + range.start(),
+                        highlight: highlight.into(),
+                        binding_hash: None,
+                    });
+                }
+            });
+            range_stack.pop();
+        }
+    }
+}
+
+fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HighlightTag> {
+    Some(match kind {
+        FormatSpecifier::Open
+        | FormatSpecifier::Close
+        | FormatSpecifier::Colon
+        | FormatSpecifier::Fill
+        | FormatSpecifier::Align
+        | FormatSpecifier::Sign
+        | FormatSpecifier::NumberSign
+        | FormatSpecifier::DollarSign
+        | FormatSpecifier::Dot
+        | FormatSpecifier::Asterisk
+        | FormatSpecifier::QuestionMark => HighlightTag::FormatSpecifier,
+        FormatSpecifier::Integer | FormatSpecifier::Zero => HighlightTag::NumericLiteral,
+        FormatSpecifier::Identifier => HighlightTag::Local,
+    })
+}
diff --git a/crates/ide/src/syntax_highlighting/macro_rules.rs b/crates/ide/src/syntax_highlighting/macro_rules.rs
new file mode 100644
index 000000000..4462af47e
--- /dev/null
+++ b/crates/ide/src/syntax_highlighting/macro_rules.rs
@@ -0,0 +1,129 @@
+//! Syntax highlighting for macro_rules!.
+use syntax::{SyntaxElement, SyntaxKind, SyntaxToken, TextRange, T};
+
+use crate::{HighlightTag, HighlightedRange};
+
+#[derive(Default)]
+pub(super) struct MacroRulesHighlighter {
+    state: Option<MacroMatcherParseState>,
+}
+
+impl MacroRulesHighlighter {
+    pub(super) fn init(&mut self) {
+        self.state = Some(MacroMatcherParseState::default());
+    }
+
+    pub(super) fn advance(&mut self, token: &SyntaxToken) {
+        if let Some(state) = self.state.as_mut() {
+            update_macro_rules_state(state, token);
+        }
+    }
+
+    pub(super) fn highlight(&self, element: SyntaxElement) -> Option<HighlightedRange> {
+        if let Some(state) = self.state.as_ref() {
+            if matches!(state.rule_state, RuleState::Matcher | RuleState::Expander) {
+                if let Some(range) = is_metavariable(element) {
+                    return Some(HighlightedRange {
+                        range,
+                        highlight: HighlightTag::UnresolvedReference.into(),
+                        binding_hash: None,
+                    });
+                }
+            }
+        }
+        None
+    }
+}
+
+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 Default for MacroMatcherParseState {
+    fn default() -> Self {
+        MacroMatcherParseState {
+            paren_ty: None,
+            paren_level: 0,
+            in_invoc_body: false,
+            rule_state: RuleState::None,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, 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(state: &mut MacroMatcherParseState, tok: &SyntaxToken) {
+    if !state.in_invoc_body {
+        if tok.kind() == T!['{'] {
+            state.in_invoc_body = true;
+        }
+        return;
+    }
+
+    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 {
+                    state.rule_state.transition();
+                    state.paren_ty = None;
+                }
+            }
+        }
+        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();
+            }
+        }
+    }
+}
+
+fn is_metavariable(element: SyntaxElement) -> Option<TextRange> {
+    let tok = element.as_token()?;
+    match tok.kind() {
+        kind if kind == SyntaxKind::IDENT || kind.is_keyword() => {
+            if let Some(_dollar) = tok.prev_token().filter(|t| t.kind() == SyntaxKind::DOLLAR) {
+                return Some(tok.text_range());
+            }
+        }
+        _ => (),
+    };
+    None
+}