7 files changed, 412 insertions, 15 deletions
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 std::iter::once;
-use ide_db::{defs::Definition, RootDatabase};
+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/lib.rs b/crates/ide/src/lib.rs
index d54c06b14..686cee3a1 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;
@@ -384,6 +384,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))
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);