45 files changed, 2584 insertions, 2256 deletions

diff --git a/crates/ide/src/call_hierarchy.rs b/crates/ide/src/call_hierarchy.rs
index 3c2d39f5d..e8999a7f3 100644
--- a/crates/ide/src/call_hierarchy.rs
+++ b/crates/ide/src/call_hierarchy.rs
@@ -5,7 +5,7 @@ use indexmap::IndexMap;
 use hir::Semantics;
 use ide_db::call_info::FnCallNode;
 use ide_db::RootDatabase;
-use syntax::{ast, match_ast, AstNode, TextRange};
+use syntax::{ast, AstNode, TextRange};
 
 use crate::{
     display::TryToNav, goto_definition, references, FilePosition, NavigationTarget, RangeInfo,
@@ -47,28 +47,23 @@ pub(crate) fn incoming_calls(db: &RootDatabase, position: FilePosition) -> Optio
 
     let mut calls = CallLocations::default();
 
-    for reference in refs.info.references() {
-        let file_id = reference.file_range.file_id;
+    for (&file_id, references) in refs.info.references().iter() {
         let file = sema.parse(file_id);
         let file = file.syntax();
-        let token = file.token_at_offset(reference.file_range.range.start()).next()?;
-        let token = sema.descend_into_macros(token);
-        let syntax = token.parent();
-
-        // This target is the containing function
-        if let Some(nav) = syntax.ancestors().find_map(|node| {
-            match_ast! {
-                match node {
-                    ast::Fn(it) => {
-                        let def = sema.to_def(&it)?;
-                        def.try_to_nav(sema.db)
-                    },
-                    _ => None,
-                }
+        for reference in references {
+            let token = file.token_at_offset(reference.range.start()).next()?;
+            let token = sema.descend_into_macros(token);
+            let syntax = token.parent();
+
+            // This target is the containing function
+            if let Some(nav) = syntax.ancestors().find_map(|node| {
+                let fn_ = ast::Fn::cast(node)?;
+                let def = sema.to_def(&fn_)?;
+                def.try_to_nav(sema.db)
+            }) {
+                let relative_range = reference.range;
+                calls.add(&nav, relative_range);
             }
-        }) {
-            let relative_range = reference.file_range.range;
-            calls.add(&nav, relative_range);
         }
     }
 
@@ -91,17 +86,12 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
         .filter_map(|node| FnCallNode::with_node_exact(&node))
         .filter_map(|call_node| {
             let name_ref = call_node.name_ref()?;
-
-            if let Some(func_target) = match &call_node {
+            let func_target = match call_node {
                 FnCallNode::CallExpr(expr) => {
                     //FIXME: Type::as_callable is broken
                     let callable = sema.type_of_expr(&expr.expr()?)?.as_callable(db)?;
                     match callable.kind() {
-                        hir::CallableKind::Function(it) => {
-                            let fn_def: hir::Function = it.into();
-                            let nav = fn_def.try_to_nav(db)?;
-                            Some(nav)
-                        }
+                        hir::CallableKind::Function(it) => it.try_to_nav(db),
                         _ => None,
                     }
                 }
@@ -109,11 +99,8 @@ pub(crate) fn outgoing_calls(db: &RootDatabase, position: FilePosition) -> Optio
                     let function = sema.resolve_method_call(&expr)?;
                     function.try_to_nav(db)
                 }
-            } {
-                Some((func_target, name_ref.syntax().text_range()))
-            } else {
-                None
-            }
+            }?;
+            Some((func_target, name_ref.syntax().text_range()))
         })
         .for_each(|(nav, range)| calls.add(&nav, range));
 
@@ -178,7 +165,7 @@ mod tests {
 //- /lib.rs
 fn callee() {}
 fn caller() {
-    call<|>ee();
+    call$0ee();
 }
 "#,
             "callee Function FileId(0) 0..14 3..9",
@@ -192,7 +179,7 @@ fn caller() {
         check_hierarchy(
             r#"
 //- /lib.rs
-fn call<|>ee() {}
+fn call$0ee() {}
 fn caller() {
     callee();
 }
@@ -210,7 +197,7 @@ fn caller() {
 //- /lib.rs
 fn callee() {}
 fn caller() {
-    call<|>ee();
+    call$0ee();
     callee();
 }
 "#,
@@ -227,7 +214,7 @@ fn caller() {
 //- /lib.rs
 fn callee() {}
 fn caller1() {
-    call<|>ee();
+    call$0ee();
 }
 
 fn caller2() {
@@ -250,7 +237,7 @@ fn caller2() {
 //- /lib.rs cfg:test
 fn callee() {}
 fn caller1() {
-    call<|>ee();
+    call$0ee();
 }
 
 #[cfg(test)]
@@ -281,7 +268,7 @@ mod foo;
 use foo::callee;
 
 fn caller() {
-    call<|>ee();
+    call$0ee();
 }
 
 //- /foo/mod.rs
@@ -299,7 +286,7 @@ pub fn callee() {}
             r#"
 //- /lib.rs
 fn callee() {}
-fn call<|>er() {
+fn call$0er() {
     callee();
     callee();
 }
@@ -318,7 +305,7 @@ fn call<|>er() {
 mod foo;
 use foo::callee;
 
-fn call<|>er() {
+fn call$0er() {
     callee();
 }
 
@@ -337,7 +324,7 @@ pub fn callee() {}
             r#"
 //- /lib.rs
 fn caller1() {
-    call<|>er2();
+    call$0er2();
 }
 
 fn caller2() {
@@ -365,7 +352,7 @@ fn a() {
 fn b() {}
 
 fn main() {
-    a<|>()
+    a$0()
 }
 "#,
             "a Function FileId(0) 0..18 3..4",
@@ -376,7 +363,7 @@ fn main() {
         check_hierarchy(
             r#"
 fn a() {
-    b<|>()
+    b$0()
 }
 
 fn b() {}
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 79d126ff2..055c0a79c 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -125,7 +125,7 @@ pub(crate) fn diagnostics(
         .on::<hir::diagnostics::MissingFields, _>(|d| {
             res.borrow_mut().push(diagnostic_with_fix(d, &sema));
         })
-        .on::<hir::diagnostics::MissingOkInTailExpr, _>(|d| {
+        .on::<hir::diagnostics::MissingOkOrSomeInTailExpr, _>(|d| {
             res.borrow_mut().push(diagnostic_with_fix(d, &sema));
         })
         .on::<hir::diagnostics::NoSuchField, _>(|d| {
@@ -305,6 +305,40 @@ mod tests {
     }
 
     #[test]
+    fn test_wrap_return_type_option() {
+        check_fix(
+            r#"
+//- /main.rs crate:main deps:core
+use core::option::Option::{self, Some, None};
+
+fn div(x: i32, y: i32) -> Option<i32> {
+    if y == 0 {
+        return None;
+    }
+    x / y$0
+}
+//- /core/lib.rs crate:core
+pub mod result {
+    pub enum Result<T, E> { Ok(T), Err(E) }
+}
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
+"#,
+            r#"
+use core::option::Option::{self, Some, None};
+
+fn div(x: i32, y: i32) -> Option<i32> {
+    if y == 0 {
+        return None;
+    }
+    Some(x / y)
+}
+"#,
+        );
+    }
+
+    #[test]
     fn test_wrap_return_type() {
         check_fix(
             r#"
@@ -315,12 +349,15 @@ fn div(x: i32, y: i32) -> Result<i32, ()> {
     if y == 0 {
         return Err(());
     }
-    x / y<|>
+    x / y$0
 }
 //- /core/lib.rs crate:core
 pub mod result {
     pub enum Result<T, E> { Ok(T), Err(E) }
 }
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
 "#,
             r#"
 use core::result::Result::{self, Ok, Err};
@@ -346,12 +383,15 @@ fn div<T>(x: T) -> Result<T, i32> {
     if x == 0 {
         return Err(7);
     }
-    <|>x
+    $0x
 }
 //- /core/lib.rs crate:core
 pub mod result {
     pub enum Result<T, E> { Ok(T), Err(E) }
 }
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
 "#,
             r#"
 use core::result::Result::{self, Ok, Err};
@@ -379,12 +419,15 @@ fn div(x: i32, y: i32) -> MyResult<i32> {
     if y == 0 {
         return Err(());
     }
-    x <|>/ y
+    x $0/ y
 }
 //- /core/lib.rs crate:core
 pub mod result {
     pub enum Result<T, E> { Ok(T), Err(E) }
 }
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
 "#,
             r#"
 use core::result::Result::{self, Ok, Err};
@@ -414,12 +457,15 @@ fn foo() -> Result<(), i32> { 0 }
 pub mod result {
     pub enum Result<T, E> { Ok(T), Err(E) }
 }
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
 "#,
         );
     }
 
     #[test]
-    fn test_wrap_return_type_not_applicable_when_return_type_is_not_result() {
+    fn test_wrap_return_type_not_applicable_when_return_type_is_not_result_or_option() {
         check_no_diagnostics(
             r#"
 //- /main.rs crate:main deps:core
@@ -433,6 +479,9 @@ fn foo() -> SomeOtherEnum { 0 }
 pub mod result {
     pub enum Result<T, E> { Ok(T), Err(E) }
 }
+pub mod option {
+    pub enum Option<T> { Some(T), None }
+}
 "#,
         );
     }
@@ -444,7 +493,7 @@ pub mod result {
 struct TestStruct { one: i32, two: i64 }
 
 fn test_fn() {
-    let s = TestStruct {<|>};
+    let s = TestStruct {$0};
 }
 "#,
             r#"
@@ -464,7 +513,7 @@ fn test_fn() {
 struct TestStruct { one: i32 }
 
 impl TestStruct {
-    fn test_fn() { let s = Self {<|>}; }
+    fn test_fn() { let s = Self {$0}; }
 }
 "#,
             r#"
@@ -487,7 +536,7 @@ enum Expr {
 
 impl Expr {
     fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr {
-        Expr::Bin {<|> }
+        Expr::Bin {$0 }
     }
 }
 "#,
@@ -512,7 +561,7 @@ impl Expr {
 struct TestStruct { one: i32, two: i64 }
 
 fn test_fn() {
-    let s = TestStruct{ two: 2<|> };
+    let s = TestStruct{ two: 2$0 };
 }
 "#,
             r"
@@ -608,7 +657,7 @@ fn here() {}
 macro_rules! id { ($($tt:tt)*) => { $($tt)*}; }
 
 fn main() {
-    let _x = id![Foo { a: <|>42 }];
+    let _x = id![Foo { a: $042 }];
 }
 
 pub struct Foo { pub a: i32, pub b: i32 }
@@ -663,7 +712,7 @@ mod a {
         check_fix(
             r"
             mod b {}
-            use {<|>b};
+            use {$0b};
             ",
             r"
             mod b {}
@@ -673,7 +722,7 @@ mod a {
         check_fix(
             r"
             mod b {}
-            use {b<|>};
+            use {b$0};
             ",
             r"
             mod b {}
@@ -683,7 +732,7 @@ mod a {
         check_fix(
             r"
             mod a { mod c {} }
-            use a::{c<|>};
+            use a::{c$0};
             ",
             r"
             mod a { mod c {} }
@@ -693,7 +742,7 @@ mod a {
         check_fix(
             r"
             mod a {}
-            use a::{self<|>};
+            use a::{self$0};
             ",
             r"
             mod a {}
@@ -703,7 +752,7 @@ mod a {
         check_fix(
             r"
             mod a { mod c {} mod d { mod e {} } }
-            use a::{c, d::{e<|>}};
+            use a::{c, d::{e$0}};
             ",
             r"
             mod a { mod c {} mod d { mod e {} } }
@@ -717,7 +766,7 @@ mod a {
         check_fix(
             r"
 fn main() {
-    Foo { bar: 3, baz<|>: false};
+    Foo { bar: 3, baz$0: false};
 }
 struct Foo {
     bar: i32
@@ -743,7 +792,7 @@ struct Foo {
 mod foo;
 
 fn main() {
-    foo::Foo { bar: 3, <|>baz: false};
+    foo::Foo { bar: 3, $0baz: false};
 }
 //- /foo.rs
 struct Foo {
@@ -777,7 +826,7 @@ struct Foo {
     fn test_rename_incorrect_case() {
         check_fix(
             r#"
-pub struct test_struct<|> { one: i32 }
+pub struct test_struct$0 { one: i32 }
 
 pub fn some_fn(val: test_struct) -> test_struct {
     test_struct { one: val.one + 1 }
@@ -794,7 +843,7 @@ pub fn some_fn(val: TestStruct) -> TestStruct {
 
         check_fix(
             r#"
-pub fn some_fn(NonSnakeCase<|>: u8) -> u8 {
+pub fn some_fn(NonSnakeCase$0: u8) -> u8 {
     NonSnakeCase
 }
 "#,
@@ -807,7 +856,7 @@ pub fn some_fn(non_snake_case: u8) -> u8 {
 
         check_fix(
             r#"
-pub fn SomeFn<|>(val: u8) -> u8 {
+pub fn SomeFn$0(val: u8) -> u8 {
     if val != 0 { SomeFn(val - 1) } else { val }
 }
 "#,
@@ -821,7 +870,7 @@ pub fn some_fn(val: u8) -> u8 {
         check_fix(
             r#"
 fn some_fn() {
-    let whatAWeird_Formatting<|> = 10;
+    let whatAWeird_Formatting$0 = 10;
     another_func(whatAWeird_Formatting);
 }
 "#,
@@ -839,7 +888,7 @@ fn some_fn() {
         check_no_diagnostics(
             r#"
 fn foo() {
-    const ANOTHER_ITEM<|>: &str = "some_item";
+    const ANOTHER_ITEM$0: &str = "some_item";
 }
 "#,
         );
@@ -852,7 +901,7 @@ fn foo() {
 pub struct TestStruct;
 
 impl TestStruct {
-    pub fn SomeFn<|>() -> TestStruct {
+    pub fn SomeFn$0() -> TestStruct {
         TestStruct
     }
 }
@@ -871,7 +920,7 @@ impl TestStruct {
 
     #[test]
     fn test_single_incorrect_case_diagnostic_in_function_name_issue_6970() {
-        let input = r#"fn FOO<|>() {}"#;
+        let input = r#"fn FOO$0() {}"#;
         let expected = r#"fn foo() {}"#;
 
         let (analysis, file_position) = fixture::position(input);
diff --git a/crates/ide/src/diagnostics/field_shorthand.rs b/crates/ide/src/diagnostics/field_shorthand.rs
index f41bcd619..16c6ea827 100644
--- a/crates/ide/src/diagnostics/field_shorthand.rs
+++ b/crates/ide/src/diagnostics/field_shorthand.rs
@@ -120,7 +120,7 @@ fn main() { A { 0: 0 } }
 struct A { a: &'static str }
 fn main() {
     let a = "haha";
-    A { a<|>: a }
+    A { a$0: a }
 }
 "#,
             r#"
@@ -138,7 +138,7 @@ struct A { a: &'static str, b: &'static str }
 fn main() {
     let a = "haha";
     let b = "bb";
-    A { a<|>: a, b }
+    A { a$0: a, b }
 }
 "#,
             r#"
@@ -171,7 +171,7 @@ fn f(a: A) { let A { 0: 0 } = a; }
             r#"
 struct A { a: &'static str }
 fn f(a: A) {
-    let A { a<|>: a } = a;
+    let A { a$0: a } = a;
 }
 "#,
             r#"
@@ -186,7 +186,7 @@ fn f(a: A) {
             r#"
 struct A { a: &'static str, b: &'static str }
 fn f(a: A) {
-    let A { a<|>: a, b } = a;
+    let A { a$0: a, b } = a;
 }
 "#,
             r#"
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index ec0f840e9..d7ad88ed5 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -3,7 +3,7 @@
 use hir::{
     db::AstDatabase,
     diagnostics::{
-        Diagnostic, IncorrectCase, MissingFields, MissingOkInTailExpr, NoSuchField,
+        Diagnostic, IncorrectCase, MissingFields, MissingOkOrSomeInTailExpr, NoSuchField,
         RemoveThisSemicolon, UnresolvedModule,
     },
     HasSource, HirDisplay, InFile, Semantics, VariantDef,
@@ -94,15 +94,17 @@ impl DiagnosticWithFix for MissingFields {
     }
 }
 
-impl DiagnosticWithFix for MissingOkInTailExpr {
+impl DiagnosticWithFix for MissingOkOrSomeInTailExpr {
     fn fix(&self, sema: &Semantics<RootDatabase>) -> Option<Fix> {
         let root = sema.db.parse_or_expand(self.file)?;
         let tail_expr = self.expr.to_node(&root);
         let tail_expr_range = tail_expr.syntax().text_range();
-        let edit = TextEdit::replace(tail_expr_range, format!("Ok({})", tail_expr.syntax()));
+        let replacement = format!("{}({})", self.required, tail_expr.syntax());
+        let edit = TextEdit::replace(tail_expr_range, replacement);
         let source_change =
             SourceFileEdit { file_id: self.file.original_file(sema.db), edit }.into();
-        Some(Fix::new("Wrap with ok", source_change, tail_expr_range))
+        let name = if self.required == "Ok" { "Wrap with Ok" } else { "Wrap with Some" };
+        Some(Fix::new(name, source_change, tail_expr_range))
     }
 }
 
@@ -156,7 +158,6 @@ fn missing_record_expr_field_fix(
     let record_fields = match VariantDef::from(def_id) {
         VariantDef::Struct(s) => {
             module = s.module(sema.db);
-            #[allow(deprecated)]
             let source = s.source(sema.db)?;
             def_file_id = source.file_id;
             let fields = source.value.field_list()?;
@@ -164,14 +165,12 @@ fn missing_record_expr_field_fix(
         }
         VariantDef::Union(u) => {
             module = u.module(sema.db);
-            #[allow(deprecated)]
             let source = u.source(sema.db)?;
             def_file_id = source.file_id;
             source.value.record_field_list()?
         }
         VariantDef::Variant(e) => {
             module = e.module(sema.db);
-            #[allow(deprecated)]
             let source = e.source(sema.db)?;
             def_file_id = source.file_id;
             let fields = source.value.field_list()?;
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index e24c78301..4eecae697 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -215,10 +215,8 @@ impl TryToNav for Definition {
             Definition::ModuleDef(it) => it.try_to_nav(db),
             Definition::SelfType(it) => it.try_to_nav(db),
             Definition::Local(it) => Some(it.to_nav(db)),
-            Definition::TypeParam(it) => it.try_to_nav(db),
-            Definition::LifetimeParam(it) => it.try_to_nav(db),
+            Definition::GenericParam(it) => it.try_to_nav(db),
             Definition::Label(it) => Some(it.to_nav(db)),
-            Definition::ConstParam(it) => it.try_to_nav(db),
         }
     }
 }
@@ -389,6 +387,16 @@ impl TryToNav for hir::AssocItem {
     }
 }
 
+impl TryToNav for hir::GenericParam {
+    fn try_to_nav(&self, db: &RootDatabase) -> Option<NavigationTarget> {
+        match self {
+            hir::GenericParam::TypeParam(it) => it.try_to_nav(db),
+            hir::GenericParam::ConstParam(it) => it.try_to_nav(db),
+            hir::GenericParam::LifetimeParam(it) => it.try_to_nav(db),
+        }
+    }
+}
+
 impl ToNav for hir::Local {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.source(db);
diff --git a/crates/ide/src/doc_links.rs b/crates/ide/src/doc_links.rs
index 367fac05e..de10406bc 100644
--- a/crates/ide/src/doc_links.rs
+++ b/crates/ide/src/doc_links.rs
@@ -1,6 +1,6 @@
 //! Resolves and rewrites links in markdown documentation.
 
-use std::{convert::TryFrom, iter::once};
+use std::{convert::TryFrom, iter::once, ops::Range};
 
 use itertools::Itertools;
 use pulldown_cmark::{BrokenLink, CowStr, Event, InlineStr, LinkType, Options, Parser, Tag};
@@ -39,7 +39,7 @@ pub(crate) fn rewrite_links(db: &RootDatabase, markdown: &str, definition: &Defi
         if target.contains("://") {
             (target.to_string(), title.to_string())
         } else {
-            // Two posibilities:
+            // Two possibilities:
             // * path-based links: `../../module/struct.MyStruct.html`
             // * module-based links (AKA intra-doc links): `super::super::module::MyStruct`
             if let Some(rewritten) = rewrite_intra_doc_link(db, *definition, target, title) {
@@ -61,6 +61,30 @@ pub(crate) fn rewrite_links(db: &RootDatabase, markdown: &str, definition: &Defi
     out
 }
 
+pub(crate) fn extract_definitions_from_markdown(
+    markdown: &str,
+) -> Vec<(String, Option<hir::Namespace>, Range<usize>)> {
+    let mut res = vec![];
+    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));
+    for (event, range) in doc.into_offset_iter() {
+        match event {
+            Event::Start(Tag::Link(_link_type, ref target, ref title)) => {
+                let link = if target.is_empty() { title } else { target };
+                let (link, ns) = parse_link(link);
+                res.push((link.to_string(), ns, range));
+            }
+            _ => {}
+        }
+    }
+    res
+}
+
 /// Remove all links in markdown documentation.
 pub(crate) fn remove_links(markdown: &str) -> String {
     let mut drop_link = false;
@@ -192,9 +216,7 @@ fn rewrite_intra_doc_link(
         Definition::Field(it) => it.resolve_doc_path(db, link, ns),
         Definition::SelfType(_)
         | Definition::Local(_)
-        | Definition::TypeParam(_)
-        | Definition::ConstParam(_)
-        | Definition::LifetimeParam(_)
+        | Definition::GenericParam(_)
         | Definition::Label(_) => return None,
     }?;
     let krate = resolved.module(db)?.krate();
@@ -420,7 +442,7 @@ fn get_symbol_fragment(db: &dyn HirDatabase, field_or_assoc: &FieldOrAssocItem)
                     function.as_assoc_item(db).map(|assoc| assoc.container(db)),
                     Some(AssocItemContainer::Trait(..))
                 );
-                // This distinction may get more complicated when specialisation is available.
+                // This distinction may get more complicated when specialization 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) {
@@ -464,7 +486,7 @@ mod tests {
     fn test_doc_url_struct() {
         check(
             r#"
-pub struct Fo<|>o;
+pub struct Fo$0o;
 "#,
             expect![[r#"https://docs.rs/test/*/test/struct.Foo.html"#]],
         );
@@ -474,7 +496,7 @@ pub struct Fo<|>o;
     fn test_doc_url_fn() {
         check(
             r#"
-pub fn fo<|>o() {}
+pub fn fo$0o() {}
 "#,
             expect![[r##"https://docs.rs/test/*/test/fn.foo.html#method.foo"##]],
         );
@@ -487,7 +509,7 @@ pub fn fo<|>o() {}
 pub struct Foo;
 
 impl Foo {
-    pub fn met<|>hod() {}
+    pub fn met$0hod() {}
 }
 
 "#,
@@ -500,7 +522,7 @@ impl Foo {
         check(
             r#"
 pub trait Bar {
-    fn met<|>hod() {}
+    fn met$0hod() {}
 }
 
 "#,
@@ -513,7 +535,7 @@ pub trait Bar {
         check(
             r#"
 pub trait Foo {
-    fn met<|>hod();
+    fn met$0hod();
 }
 
 "#,
@@ -526,7 +548,7 @@ pub trait Foo {
         check(
             r#"
 pub struct Foo {
-    pub fie<|>ld: ()
+    pub fie$0ld: ()
 }
 
 "#,
@@ -539,7 +561,7 @@ pub struct Foo {
         check(
             r#"
 pub mod foo {
-    pub mod ba<|>r {}
+    pub mod ba$0r {}
 }
         "#,
             expect![[r#"https://docs.rs/test/*/test/foo/bar/index.html"#]],
@@ -564,7 +586,7 @@ pub mod wrapper {
 }
 
 fn foo() {
-    let bar: wrapper::It<|>em;
+    let bar: wrapper::It$0em;
 }
         "#,
             expect![[r#"https://docs.rs/test/*/test/wrapper/module/struct.Item.html"#]],
diff --git a/crates/ide/src/expand_macro.rs b/crates/ide/src/expand_macro.rs
index 8d75e0f05..ffb3a6f7d 100644
--- a/crates/ide/src/expand_macro.rs
+++ b/crates/ide/src/expand_macro.rs
@@ -144,7 +144,7 @@ macro_rules! foo {
 macro_rules! baz {
     () => { foo!(); }
 }
-f<|>oo!();
+f$0oo!();
 "#,
             expect![[r#"
                 foo
@@ -165,7 +165,7 @@ macro_rules! foo {
         }
     }
 }
-f<|>oo!();
+f$0oo!();
         "#,
             expect![[r#"
             foo
@@ -192,7 +192,7 @@ macro_rules! match_ast {
 }
 
 fn main() {
-    mat<|>ch_ast! {
+    mat$0ch_ast! {
         match container {
             ast::TraitDef(it) => {},
             ast::ImplDef(it) => {},
@@ -226,7 +226,7 @@ macro_rules! match_ast {
 
 fn main() {
     let p = f(|it| {
-        let res = mat<|>ch_ast! { match c {}};
+        let res = mat$0ch_ast! { match c {}};
         Some(res)
     })?;
 }
@@ -250,7 +250,7 @@ macro_rules! foo {
 }
 
 fn main() {
-    let res = fo<|>o!();
+    let res = fo$0o!();
 }
 "#,
             expect![[r#"
@@ -272,7 +272,7 @@ macro_rules! foo {
 }
 
 fn main() {
-    let res = fo<|>o!();
+    let res = fo$0o!();
 }
 "#,
             expect![[r#"
diff --git a/crates/ide/src/extend_selection.rs b/crates/ide/src/extend_selection.rs
index 6f3022dfd..56418c960 100644
--- a/crates/ide/src/extend_selection.rs
+++ b/crates/ide/src/extend_selection.rs
@@ -334,29 +334,29 @@ mod tests {
 
     #[test]
     fn test_extend_selection_arith() {
-        do_check(r#"fn foo() { <|>1 + 1 }"#, &["1", "1 + 1", "{ 1 + 1 }"]);
+        do_check(r#"fn foo() { $01 + 1 }"#, &["1", "1 + 1", "{ 1 + 1 }"]);
     }
 
     #[test]
     fn test_extend_selection_list() {
-        do_check(r#"fn foo(<|>x: i32) {}"#, &["x", "x: i32"]);
-        do_check(r#"fn foo(<|>x: i32, y: i32) {}"#, &["x", "x: i32", "x: i32, "]);
-        do_check(r#"fn foo(<|>x: i32,y: i32) {}"#, &["x", "x: i32", "x: i32,", "(x: i32,y: i32)"]);
-        do_check(r#"fn foo(x: i32, <|>y: i32) {}"#, &["y", "y: i32", ", y: i32"]);
-        do_check(r#"fn foo(x: i32, <|>y: i32, ) {}"#, &["y", "y: i32", "y: i32, "]);
-        do_check(r#"fn foo(x: i32,<|>y: i32) {}"#, &["y", "y: i32", ",y: i32"]);
+        do_check(r#"fn foo($0x: i32) {}"#, &["x", "x: i32"]);
+        do_check(r#"fn foo($0x: i32, y: i32) {}"#, &["x", "x: i32", "x: i32, "]);
+        do_check(r#"fn foo($0x: i32,y: i32) {}"#, &["x", "x: i32", "x: i32,", "(x: i32,y: i32)"]);
+        do_check(r#"fn foo(x: i32, $0y: i32) {}"#, &["y", "y: i32", ", y: i32"]);
+        do_check(r#"fn foo(x: i32, $0y: i32, ) {}"#, &["y", "y: i32", "y: i32, "]);
+        do_check(r#"fn foo(x: i32,$0y: i32) {}"#, &["y", "y: i32", ",y: i32"]);
 
-        do_check(r#"const FOO: [usize; 2] = [ 22<|> , 33];"#, &["22", "22 , "]);
-        do_check(r#"const FOO: [usize; 2] = [ 22 , 33<|>];"#, &["33", ", 33"]);
-        do_check(r#"const FOO: [usize; 2] = [ 22 , 33<|> ,];"#, &["33", "33 ,", "[ 22 , 33 ,]"]);
+        do_check(r#"const FOO: [usize; 2] = [ 22$0 , 33];"#, &["22", "22 , "]);
+        do_check(r#"const FOO: [usize; 2] = [ 22 , 33$0];"#, &["33", ", 33"]);
+        do_check(r#"const FOO: [usize; 2] = [ 22 , 33$0 ,];"#, &["33", "33 ,", "[ 22 , 33 ,]"]);
 
-        do_check(r#"fn main() { (1, 2<|>) }"#, &["2", ", 2", "(1, 2)"]);
+        do_check(r#"fn main() { (1, 2$0) }"#, &["2", ", 2", "(1, 2)"]);
 
         do_check(
             r#"
 const FOO: [usize; 2] = [
     22,
-    <|>33,
+    $033,
 ]"#,
             &["33", "33,"],
         );
@@ -365,7 +365,7 @@ const FOO: [usize; 2] = [
             r#"
 const FOO: [usize; 2] = [
     22
-    , 33<|>,
+    , 33$0,
 ]"#,
             &["33", "33,"],
         );
@@ -376,7 +376,7 @@ const FOO: [usize; 2] = [
         do_check(
             r#"
 impl S {
-<|>    fn foo() {
+$0    fn foo() {
 
     }
 }"#,
@@ -393,7 +393,7 @@ struct A;
 /// bla
 /// bla
 struct B {
-    <|>
+    $0
 }
             "#,
             &["\n    \n", "{\n    \n}", "/// bla\n/// bla\nstruct B {\n    \n}"],
@@ -407,7 +407,7 @@ struct B {
 fn bar(){}
 
 // fn foo() {
-// 1 + <|>1
+// 1 + $01
 // }
 
 // fn foo(){}
@@ -419,7 +419,7 @@ fn bar(){}
             r#"
 // #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 // pub enum Direction {
-//  <|>   Next,
+//  $0   Next,
 //     Prev
 // }
 "#,
@@ -433,27 +433,27 @@ fn bar(){}
             r#"
 /*
 foo
-_bar1<|>*/
+_bar1$0*/
 "#,
             &["_bar1", "/*\nfoo\n_bar1*/"],
         );
 
-        do_check(r#"//!<|>foo_2 bar"#, &["foo_2", "//!foo_2 bar"]);
+        do_check(r#"//!$0foo_2 bar"#, &["foo_2", "//!foo_2 bar"]);
 
-        do_check(r#"/<|>/foo bar"#, &["//foo bar"]);
+        do_check(r#"/$0/foo bar"#, &["//foo bar"]);
     }
 
     #[test]
     fn test_extend_selection_prefer_idents() {
         do_check(
             r#"
-fn main() { foo<|>+bar;}
+fn main() { foo$0+bar;}
 "#,
             &["foo", "foo+bar"],
         );
         do_check(
             r#"
-fn main() { foo+<|>bar;}
+fn main() { foo+$0bar;}
 "#,
             &["bar", "foo+bar"],
         );
@@ -461,18 +461,18 @@ fn main() { foo+<|>bar;}
 
     #[test]
     fn test_extend_selection_prefer_lifetimes() {
-        do_check(r#"fn foo<<|>'a>() {}"#, &["'a", "<'a>"]);
-        do_check(r#"fn foo<'a<|>>() {}"#, &["'a", "<'a>"]);
+        do_check(r#"fn foo<$0'a>() {}"#, &["'a", "<'a>"]);
+        do_check(r#"fn foo<'a$0>() {}"#, &["'a", "<'a>"]);
     }
 
     #[test]
     fn test_extend_selection_select_first_word() {
-        do_check(r#"// foo bar b<|>az quxx"#, &["baz", "// foo bar baz quxx"]);
+        do_check(r#"// foo bar b$0az quxx"#, &["baz", "// foo bar baz quxx"]);
         do_check(
             r#"
 impl S {
 fn foo() {
-// hel<|>lo world
+// hel$0lo world
 }
 }
 "#,
@@ -486,7 +486,7 @@ fn foo() {
             r#"
 fn bar(){}
 
-" fn f<|>oo() {"
+" fn f$0oo() {"
 "#,
             &["foo", "\" fn foo() {\""],
         );
@@ -499,7 +499,7 @@ fn bar(){}
 fn foo<R>()
     where
         R: req::Request + 'static,
-        R::Params: DeserializeOwned<|> + panic::UnwindSafe + 'static,
+        R::Params: DeserializeOwned$0 + panic::UnwindSafe + 'static,
         R::Result: Serialize + 'static,
 "#,
             &[
@@ -510,26 +510,26 @@ fn foo<R>()
                 "R::Params: DeserializeOwned + panic::UnwindSafe + 'static,",
             ],
         );
-        do_check(r#"fn foo<T>() where T: <|>Copy"#, &["Copy"]);
-        do_check(r#"fn foo<T>() where T: <|>Copy + Display"#, &["Copy", "Copy + "]);
-        do_check(r#"fn foo<T>() where T: <|>Copy +Display"#, &["Copy", "Copy +"]);
-        do_check(r#"fn foo<T>() where T: <|>Copy+Display"#, &["Copy", "Copy+"]);
-        do_check(r#"fn foo<T>() where T: Copy + <|>Display"#, &["Display", "+ Display"]);
-        do_check(r#"fn foo<T>() where T: Copy + <|>Display + Sync"#, &["Display", "Display + "]);
-        do_check(r#"fn foo<T>() where T: Copy +<|>Display"#, &["Display", "+Display"]);
+        do_check(r#"fn foo<T>() where T: $0Copy"#, &["Copy"]);
+        do_check(r#"fn foo<T>() where T: $0Copy + Display"#, &["Copy", "Copy + "]);
+        do_check(r#"fn foo<T>() where T: $0Copy +Display"#, &["Copy", "Copy +"]);
+        do_check(r#"fn foo<T>() where T: $0Copy+Display"#, &["Copy", "Copy+"]);
+        do_check(r#"fn foo<T>() where T: Copy + $0Display"#, &["Display", "+ Display"]);
+        do_check(r#"fn foo<T>() where T: Copy + $0Display + Sync"#, &["Display", "Display + "]);
+        do_check(r#"fn foo<T>() where T: Copy +$0Display"#, &["Display", "+Display"]);
     }
 
     #[test]
     fn test_extend_trait_bounds_list_inline() {
-        do_check(r#"fn foo<T: <|>Copy>() {}"#, &["Copy"]);
-        do_check(r#"fn foo<T: <|>Copy + Display>() {}"#, &["Copy", "Copy + "]);
-        do_check(r#"fn foo<T: <|>Copy +Display>() {}"#, &["Copy", "Copy +"]);
-        do_check(r#"fn foo<T: <|>Copy+Display>() {}"#, &["Copy", "Copy+"]);
-        do_check(r#"fn foo<T: Copy + <|>Display>() {}"#, &["Display", "+ Display"]);
-        do_check(r#"fn foo<T: Copy + <|>Display + Sync>() {}"#, &["Display", "Display + "]);
-        do_check(r#"fn foo<T: Copy +<|>Display>() {}"#, &["Display", "+Display"]);
+        do_check(r#"fn foo<T: $0Copy>() {}"#, &["Copy"]);
+        do_check(r#"fn foo<T: $0Copy + Display>() {}"#, &["Copy", "Copy + "]);
+        do_check(r#"fn foo<T: $0Copy +Display>() {}"#, &["Copy", "Copy +"]);
+        do_check(r#"fn foo<T: $0Copy+Display>() {}"#, &["Copy", "Copy+"]);
+        do_check(r#"fn foo<T: Copy + $0Display>() {}"#, &["Display", "+ Display"]);
+        do_check(r#"fn foo<T: Copy + $0Display + Sync>() {}"#, &["Display", "Display + "]);
+        do_check(r#"fn foo<T: Copy +$0Display>() {}"#, &["Display", "+Display"]);
         do_check(
-            r#"fn foo<T: Copy<|> + Display, U: Copy>() {}"#,
+            r#"fn foo<T: Copy$0 + Display, U: Copy>() {}"#,
             &[
                 "Copy",
                 "Copy + ",
@@ -544,19 +544,19 @@ fn foo<R>()
     #[test]
     fn test_extend_selection_on_tuple_in_type() {
         do_check(
-            r#"fn main() { let _: (krate, <|>_crate_def_map, module_id) = (); }"#,
+            r#"fn main() { let _: (krate, $0_crate_def_map, module_id) = (); }"#,
             &["_crate_def_map", "_crate_def_map, ", "(krate, _crate_def_map, module_id)"],
         );
         // white space variations
         do_check(
-            r#"fn main() { let _: (krate,<|>_crate_def_map,module_id) = (); }"#,
+            r#"fn main() { let _: (krate,$0_crate_def_map,module_id) = (); }"#,
             &["_crate_def_map", "_crate_def_map,", "(krate,_crate_def_map,module_id)"],
         );
         do_check(
             r#"
 fn main() { let _: (
     krate,
-    _crate<|>_def_map,
+    _crate$0_def_map,
     module_id
 ) = (); }"#,
             &[
@@ -570,19 +570,19 @@ fn main() { let _: (
     #[test]
     fn test_extend_selection_on_tuple_in_rvalue() {
         do_check(
-            r#"fn main() { let var = (krate, _crate_def_map<|>, module_id); }"#,
+            r#"fn main() { let var = (krate, _crate_def_map$0, module_id); }"#,
             &["_crate_def_map", "_crate_def_map, ", "(krate, _crate_def_map, module_id)"],
         );
         // white space variations
         do_check(
-            r#"fn main() { let var = (krate,_crate<|>_def_map,module_id); }"#,
+            r#"fn main() { let var = (krate,_crate$0_def_map,module_id); }"#,
             &["_crate_def_map", "_crate_def_map,", "(krate,_crate_def_map,module_id)"],
         );
         do_check(
             r#"
 fn main() { let var = (
     krate,
-    _crate_def_map<|>,
+    _crate_def_map$0,
     module_id
 ); }"#,
             &[
@@ -596,19 +596,19 @@ fn main() { let var = (
     #[test]
     fn test_extend_selection_on_tuple_pat() {
         do_check(
-            r#"fn main() { let (krate, _crate_def_map<|>, module_id) = var; }"#,
+            r#"fn main() { let (krate, _crate_def_map$0, module_id) = var; }"#,
             &["_crate_def_map", "_crate_def_map, ", "(krate, _crate_def_map, module_id)"],
         );
         // white space variations
         do_check(
-            r#"fn main() { let (krate,_crate<|>_def_map,module_id) = var; }"#,
+            r#"fn main() { let (krate,_crate$0_def_map,module_id) = var; }"#,
             &["_crate_def_map", "_crate_def_map,", "(krate,_crate_def_map,module_id)"],
         );
         do_check(
             r#"
 fn main() { let (
     krate,
-    _crate_def_map<|>,
+    _crate_def_map$0,
     module_id
 ) = var; }"#,
             &[
@@ -623,7 +623,7 @@ fn main() { let (
     fn extend_selection_inside_macros() {
         do_check(
             r#"macro_rules! foo { ($item:item) => {$item} }
-                foo!{fn hello(na<|>me:usize){}}"#,
+                foo!{fn hello(na$0me:usize){}}"#,
             &[
                 "name",
                 "name:usize",
@@ -640,7 +640,7 @@ fn main() { let (
         do_check(
             r#" macro_rules! foo2 { ($item:item) => {$item} }
                 macro_rules! foo { ($item:item) => {foo2!($item);} }
-                foo!{fn hello(na<|>me:usize){}}"#,
+                foo!{fn hello(na$0me:usize){}}"#,
             &[
                 "name",
                 "name:usize",
diff --git a/crates/ide/src/fixture.rs b/crates/ide/src/fixture.rs
index eb57f9224..cc8218885 100644
--- a/crates/ide/src/fixture.rs
+++ b/crates/ide/src/fixture.rs
@@ -20,12 +20,12 @@ pub(crate) fn files(ra_fixture: &str) -> (Analysis, Vec<FileId>) {
     (host.analysis(), change_fixture.files)
 }
 
-/// Creates analysis from a multi-file fixture, returns positions marked with <|>.
+/// Creates analysis from a multi-file fixture, returns positions marked with $0.
 pub(crate) fn position(ra_fixture: &str) -> (Analysis, FilePosition) {
     let mut host = AnalysisHost::default();
     let change_fixture = ChangeFixture::parse(ra_fixture);
     host.db.apply_change(change_fixture.change);
-    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker (<|>)");
+    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
     let offset = match range_or_offset {
         RangeOrOffset::Range(_) => panic!(),
         RangeOrOffset::Offset(it) => it,
@@ -33,12 +33,12 @@ pub(crate) fn position(ra_fixture: &str) -> (Analysis, FilePosition) {
     (host.analysis(), FilePosition { file_id, offset })
 }
 
-/// Creates analysis for a single file, returns range marked with a pair of <|>.
+/// Creates analysis for a single file, returns range marked with a pair of $0.
 pub(crate) fn range(ra_fixture: &str) -> (Analysis, FileRange) {
     let mut host = AnalysisHost::default();
     let change_fixture = ChangeFixture::parse(ra_fixture);
     host.db.apply_change(change_fixture.change);
-    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker (<|>)");
+    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
     let range = match range_or_offset {
         RangeOrOffset::Range(it) => it,
         RangeOrOffset::Offset(_) => panic!(),
@@ -46,12 +46,12 @@ pub(crate) fn range(ra_fixture: &str) -> (Analysis, FileRange) {
     (host.analysis(), FileRange { file_id, range })
 }
 
-/// Creates analysis from a multi-file fixture, returns positions marked with <|>.
+/// Creates analysis from a multi-file fixture, returns positions marked with $0.
 pub(crate) fn annotations(ra_fixture: &str) -> (Analysis, FilePosition, Vec<(FileRange, String)>) {
     let mut host = AnalysisHost::default();
     let change_fixture = ChangeFixture::parse(ra_fixture);
     host.db.apply_change(change_fixture.change);
-    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker (<|>)");
+    let (file_id, range_or_offset) = change_fixture.file_position.expect("expected a marker ($0)");
     let offset = match range_or_offset {
         RangeOrOffset::Range(_) => panic!(),
         RangeOrOffset::Offset(it) => it,
diff --git a/crates/ide/src/fn_references.rs b/crates/ide/src/fn_references.rs
index 5cbbe306e..f6e5a522b 100644
--- a/crates/ide/src/fn_references.rs
+++ b/crates/ide/src/fn_references.rs
@@ -34,7 +34,7 @@ mod tests {
     fn test_find_all_methods() {
         let (analysis, pos) = fixture::position(
             r#"
-            fn private_fn() {<|>}
+            fn private_fn() {$0}
 
             pub fn pub_fn() {}
 
@@ -51,7 +51,7 @@ mod tests {
         let (analysis, pos) = fixture::position(
             r#"
             trait Foo {
-                fn bar() {<|>}
+                fn bar() {$0}
                 fn baz() {}
             }
         "#,
@@ -67,7 +67,7 @@ mod tests {
             r#"
             //- /lib.rs
             #[test]
-            fn foo() {<|>}
+            fn foo() {$0}
 
             pub fn pub_fn() {}
 
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 912144f8b..cd4afc804 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1,14 +1,18 @@
 use either::Either;
-use hir::Semantics;
+use hir::{HasAttrs, ModuleDef, Semantics};
 use ide_db::{
     base_db::FileId,
-    defs::{NameClass, NameRefClass},
+    defs::{Definition, NameClass, NameRefClass},
     symbol_index, RootDatabase,
 };
-use syntax::{ast, match_ast, AstNode, SyntaxKind::*, SyntaxToken, TokenAtOffset, T};
+use syntax::{
+    ast, match_ast, AstNode, AstToken, SyntaxKind::*, SyntaxToken, TextSize, TokenAtOffset, T,
+};
 
 use crate::{
     display::{ToNav, TryToNav},
+    doc_links::extract_definitions_from_markdown,
+    runnables::doc_owner_to_def,
     FilePosition, NavigationTarget, RangeInfo, SymbolKind,
 };
 
@@ -30,6 +34,10 @@ pub(crate) fn goto_definition(
     let original_token = pick_best(file.token_at_offset(position.offset))?;
     let token = sema.descend_into_macros(original_token.clone());
     let parent = token.parent();
+    if let Some(comment) = ast::Comment::cast(token.clone()) {
+        let nav = def_for_doc_comment(&sema, position, &comment)?.try_to_nav(db)?;
+        return Some(RangeInfo::new(original_token.text_range(), vec![nav]));
+    }
 
     let nav_targets = match_ast! {
         match parent {
@@ -68,11 +76,58 @@ pub(crate) fn goto_definition(
     Some(RangeInfo::new(original_token.text_range(), nav_targets))
 }
 
+fn def_for_doc_comment(
+    sema: &Semantics<RootDatabase>,
+    position: FilePosition,
+    doc_comment: &ast::Comment,
+) -> Option<hir::ModuleDef> {
+    let parent = doc_comment.syntax().parent();
+    let (link, ns) = extract_positioned_link_from_comment(position, doc_comment)?;
+
+    let def = doc_owner_to_def(sema, parent)?;
+    match def {
+        Definition::ModuleDef(def) => match def {
+            ModuleDef::Module(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Function(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Adt(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Variant(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Const(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Static(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::Trait(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::TypeAlias(it) => it.resolve_doc_path(sema.db, &link, ns),
+            ModuleDef::BuiltinType(_) => return None,
+        },
+        Definition::Macro(it) => it.resolve_doc_path(sema.db, &link, ns),
+        Definition::Field(it) => it.resolve_doc_path(sema.db, &link, ns),
+        Definition::SelfType(_)
+        | Definition::Local(_)
+        | Definition::GenericParam(_)
+        | Definition::Label(_) => return None,
+    }
+}
+
+fn extract_positioned_link_from_comment(
+    position: FilePosition,
+    comment: &ast::Comment,
+) -> Option<(String, Option<hir::Namespace>)> {
+    let comment_range = comment.syntax().text_range();
+    let doc_comment = comment.doc_comment()?;
+    let def_links = extract_definitions_from_markdown(doc_comment);
+    let (def_link, ns, _) = def_links.iter().min_by_key(|(_, _, def_link_range)| {
+        let matched_position = comment_range.start() + TextSize::from(def_link_range.start as u32);
+        match position.offset.checked_sub(matched_position) {
+            Some(distance) => distance,
+            None => comment_range.end(),
+        }
+    })?;
+    Some((def_link.to_string(), ns.clone()))
+}
+
 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 | LIFETIME_IDENT | T![self] => 2,
+            IDENT | INT_NUMBER | LIFETIME_IDENT | T![self] | COMMENT => 2,
             kind if kind.is_trivia() => 0,
             _ => 1,
         }
@@ -166,7 +221,7 @@ mod tests {
         check(
             r#"
             //- /main.rs crate:main deps:std
-            extern crate std<|>;
+            extern crate std$0;
             //- /std/lib.rs crate:std
             // empty
             //^ file
@@ -179,7 +234,7 @@ mod tests {
         check(
             r#"
             //- /main.rs crate:main deps:std
-            extern crate std as abc<|>;
+            extern crate std as abc$0;
             //- /std/lib.rs crate:std
             // empty
             //^ file
@@ -193,7 +248,7 @@ mod tests {
             r#"
 struct Foo;
      //^^^
-enum E { X(Foo<|>) }
+enum E { X(Foo$0) }
 "#,
         );
     }
@@ -204,7 +259,7 @@ enum E { X(Foo<|>) }
             r#"
 struct Foo;
      //^^^
-enum E { X(<|>Foo) }
+enum E { X($0Foo) }
 "#,
         );
     }
@@ -217,7 +272,7 @@ enum E { X(<|>Foo) }
 use a::Foo;
 mod a;
 mod b;
-enum E { X(Foo<|>) }
+enum E { X(Foo$0) }
 
 //- /a.rs
 struct Foo;
@@ -233,7 +288,7 @@ struct Foo;
         check(
             r#"
 //- /lib.rs
-mod <|>foo;
+mod $0foo;
 
 //- /foo.rs
 // empty
@@ -244,7 +299,7 @@ mod <|>foo;
         check(
             r#"
 //- /lib.rs
-mod <|>foo;
+mod $0foo;
 
 //- /foo/mod.rs
 // empty
@@ -260,7 +315,7 @@ mod <|>foo;
 macro_rules! foo { () => { () } }
            //^^^
 fn bar() {
-    <|>foo!();
+    $0foo!();
 }
 "#,
         );
@@ -273,7 +328,7 @@ fn bar() {
 //- /lib.rs
 use foo::foo;
 fn bar() {
-    <|>foo!();
+    $0foo!();
 }
 
 //- /foo/lib.rs
@@ -289,7 +344,7 @@ macro_rules! foo { () => { () } }
         check(
             r#"
 //- /lib.rs
-use foo::foo<|>;
+use foo::foo$0;
 
 //- /foo/lib.rs
 #[macro_export]
@@ -312,7 +367,7 @@ define_fn!(foo);
          //^^^
 
 fn bar() {
-   <|>foo();
+   $0foo();
 }
 "#,
         );
@@ -331,7 +386,7 @@ macro_rules! define_fn {
 //^^^^^^^^^^^^^
 
 fn bar() {
-   <|>foo();
+   $0foo();
 }
 "#,
         );
@@ -347,7 +402,7 @@ macro_rules! foo {() => {0}}
 
 fn bar() {
     match (0,1) {
-        (<|>foo!(), _) => {}
+        ($0foo!(), _) => {}
     }
 }
 "#,
@@ -363,7 +418,7 @@ macro_rules! foo {() => {0}}
            //^^^
 fn bar() {
     match 0 {
-        <|>foo!() => {}
+        $0foo!() => {}
     }
 }
 "#,
@@ -375,7 +430,7 @@ fn bar() {
         check(
             r#"
 //- /lib.rs crate:main deps:foo
-use foo as bar<|>;
+use foo as bar$0;
 
 //- /foo/lib.rs crate:foo
 // empty
@@ -389,7 +444,7 @@ use foo as bar<|>;
         check(
             r#"
 //- /lib.rs crate:main deps:foo
-use foo::foo as bar<|>;
+use foo::foo as bar$0;
 
 //- /foo/lib.rs crate:foo
 #[macro_export]
@@ -410,7 +465,7 @@ impl Foo {
 }
 
 fn bar(foo: &Foo) {
-    foo.frobnicate<|>();
+    foo.frobnicate$0();
 }
 "#,
         );
@@ -425,7 +480,7 @@ struct Foo {
 } //^^^^
 
 fn bar(foo: &Foo) {
-    foo.spam<|>;
+    foo.spam$0;
 }
 "#,
         );
@@ -442,7 +497,7 @@ struct Foo {
 
 fn bar() -> Foo {
     Foo {
-        spam<|>: 0,
+        spam$0: 0,
     }
 }
 "#,
@@ -459,7 +514,7 @@ struct Foo {
 } //^^^^
 
 fn bar(foo: Foo) -> Foo {
-    let Foo { spam<|>: _, } = foo
+    let Foo { spam$0: _, } = foo
 }
 "#,
         );
@@ -474,7 +529,7 @@ struct Foo { spam: u32 }
            //^^^^
 
 fn bar() -> Foo {
-    Foo { spam<|>: m!() }
+    Foo { spam$0: m!() }
 }
 ",
         );
@@ -489,7 +544,7 @@ struct Foo(u32);
 
 fn bar() {
     let foo = Foo(0);
-    foo.<|>0;
+    foo.$00;
 }
 "#,
         );
@@ -505,7 +560,7 @@ impl Foo {
 }    //^^^^^^^^^^
 
 fn bar(foo: &Foo) {
-    Foo::frobnicate<|>();
+    Foo::frobnicate$0();
 }
 "#,
         );
@@ -520,7 +575,7 @@ trait Foo {
 }    //^^^^^^^^^^
 
 fn bar() {
-    Foo::frobnicate<|>();
+    Foo::frobnicate$0();
 }
 "#,
         );
@@ -537,7 +592,7 @@ trait Trait {
 impl Trait for Foo {}
 
 fn bar() {
-    Foo::frobnicate<|>();
+    Foo::frobnicate$0();
 }
 "#,
         );
@@ -551,7 +606,7 @@ struct Foo;
 impl Foo {
    //^^^
     pub fn new() -> Self {
-        Self<|> {}
+        Self$0 {}
     }
 }
 "#,
@@ -561,7 +616,7 @@ impl Foo {
 struct Foo;
 impl Foo {
    //^^^
-    pub fn new() -> Self<|> {
+    pub fn new() -> Self$0 {
         Self {}
     }
 }
@@ -573,7 +628,7 @@ impl Foo {
 enum Foo { A }
 impl Foo {
    //^^^
-    pub fn new() -> Self<|> {
+    pub fn new() -> Self$0 {
         Foo::A
     }
 }
@@ -585,7 +640,7 @@ impl Foo {
 enum Foo { A }
 impl Foo {
    //^^^
-    pub fn thing(a: &Self<|>) {
+    pub fn thing(a: &Self$0) {
     }
 }
 "#,
@@ -603,7 +658,7 @@ trait Make {
 impl Make for Foo {
             //^^^
     fn new() -> Self {
-        Self<|> {}
+        Self$0 {}
     }
 }
 "#,
@@ -617,7 +672,7 @@ trait Make {
 }
 impl Make for Foo {
             //^^^
-    fn new() -> Self<|> {
+    fn new() -> Self$0 {
         Self {}
     }
 }
@@ -629,7 +684,7 @@ impl Make for Foo {
     fn goto_def_when_used_on_definition_name_itself() {
         check(
             r#"
-struct Foo<|> { value: u32 }
+struct Foo$0 { value: u32 }
      //^^^
             "#,
         );
@@ -637,21 +692,21 @@ struct Foo<|> { value: u32 }
         check(
             r#"
 struct Foo {
-    field<|>: string,
+    field$0: string,
 } //^^^^^
 "#,
         );
 
         check(
             r#"
-fn foo_test<|>() { }
+fn foo_test$0() { }
  //^^^^^^^^
 "#,
         );
 
         check(
             r#"
-enum Foo<|> { Variant }
+enum Foo$0 { Variant }
    //^^^
 "#,
         );
@@ -660,7 +715,7 @@ enum Foo<|> { Variant }
             r#"
 enum Foo {
     Variant1,
-    Variant2<|>,
+    Variant2$0,
   //^^^^^^^^
     Variant3,
 }
@@ -669,35 +724,35 @@ enum Foo {
 
         check(
             r#"
-static INNER<|>: &str = "";
+static INNER$0: &str = "";
      //^^^^^
 "#,
         );
 
         check(
             r#"
-const INNER<|>: &str = "";
+const INNER$0: &str = "";
     //^^^^^
 "#,
         );
 
         check(
             r#"
-type Thing<|> = Option<()>;
+type Thing$0 = Option<()>;
    //^^^^^
 "#,
         );
 
         check(
             r#"
-trait Foo<|> { }
+trait Foo$0 { }
     //^^^
 "#,
         );
 
         check(
             r#"
-mod bar<|> { }
+mod bar$0 { }
   //^^^
 "#,
         );
@@ -714,7 +769,7 @@ fn foo() {}
  //^^^
 id! {
     fn bar() {
-        fo<|>o();
+        fo$0o();
     }
 }
 mod confuse_index { fn foo(); }
@@ -743,7 +798,7 @@ pub mod __export {
 fn foo() -> i8 {}
  //^^^
 fn test() {
-    format!("{}", fo<|>o())
+    format!("{}", fo$0o())
 }
 "#,
         );
@@ -761,7 +816,7 @@ macro_rules! include {}
 //^^^^^^^^^^^^^^^^^^^
 
 fn f() {
-    foo<|>();
+    foo$0();
 }
 
 mod confuse_index {
@@ -778,7 +833,7 @@ fn foo() {}
     fn goto_for_type_param() {
         check(
             r#"
-struct Foo<T: Clone> { t: <|>T }
+struct Foo<T: Clone> { t: $0T }
          //^
 "#,
         );
@@ -796,7 +851,7 @@ fn foo() {
     let x = 1;
       //^
     id!({
-        let y = <|>x;
+        let y = $0x;
         let z = y;
     });
 }
@@ -814,7 +869,7 @@ fn foo() {
     id!({
         let y = x;
           //^
-        let z = <|>y;
+        let z = $0y;
     });
 }
 "#,
@@ -829,7 +884,7 @@ fn main() {
     fn foo() {
         let x = 92;
           //^
-        <|>x;
+        $0x;
     }
 }
 "#,
@@ -843,7 +898,7 @@ fn main() {
 fn bar() {
     macro_rules! foo { () => { () } }
                //^^^
-    <|>foo!();
+    $0foo!();
 }
 "#,
         );
@@ -857,7 +912,7 @@ struct Foo { x: i32 }
 fn main() {
     let x = 92;
       //^
-    Foo { x<|> };
+    Foo { x$0 };
 }
 "#,
         )
@@ -872,7 +927,7 @@ enum Foo {
 }       //^
 fn baz(foo: Foo) {
     match foo {
-        Foo::Bar { x<|> } => x
+        Foo::Bar { x$0 } => x
     };
 }
 "#,
@@ -887,7 +942,7 @@ enum Foo { Bar }
          //^^^
 impl Foo {
     fn baz(self) {
-        match self { Self::Bar<|> => {} }
+        match self { Self::Bar$0 => {} }
     }
 }
 "#,
@@ -902,7 +957,7 @@ enum Foo { Bar { val: i32 } }
          //^^^
 impl Foo {
     fn baz(self) -> i32 {
-        match self { Self::Bar<|> { val } => {} }
+        match self { Self::Bar$0 { val } => {} }
     }
 }
 "#,
@@ -916,7 +971,7 @@ impl Foo {
 enum Foo { Bar }
          //^^^
 impl Foo {
-    fn baz(self) { Self::Bar<|>; }
+    fn baz(self) { Self::Bar$0; }
 }
 "#,
         );
@@ -929,7 +984,7 @@ impl Foo {
 enum Foo { Bar { val: i32 } }
          //^^^
 impl Foo {
-    fn baz(self) { Self::Bar<|> {val: 4}; }
+    fn baz(self) { Self::Bar$0 {val: 4}; }
 }
 "#,
         );
@@ -939,7 +994,7 @@ impl Foo {
     fn goto_def_for_type_alias_generic_parameter() {
         check(
             r#"
-type Alias<T> = T<|>;
+type Alias<T> = T$0;
          //^
 "#,
         )
@@ -950,7 +1005,7 @@ type Alias<T> = T<|>;
         check(
             r#"
 //- /lib.rs
-foo::module<|>::mac!();
+foo::module$0::mac!();
 
 //- /foo/lib.rs
 pub mod module {
@@ -972,7 +1027,7 @@ trait Iterator {
        //^^^^
 }
 
-fn f() -> impl Iterator<Item<|> = u8> {}
+fn f() -> impl Iterator<Item$0 = u8> {}
 "#,
         );
     }
@@ -987,7 +1042,7 @@ trait Iterator {
     type B;
 }
 
-fn f() -> impl Iterator<A<|> = u8, B = ()> {}
+fn f() -> impl Iterator<A$0 = u8, B = ()> {}
 "#,
         );
         check(
@@ -998,7 +1053,7 @@ trait Iterator {
        //^
 }
 
-fn f() -> impl Iterator<A = u8, B<|> = ()> {}
+fn f() -> impl Iterator<A = u8, B$0 = ()> {}
 "#,
         );
     }
@@ -1012,7 +1067,7 @@ trait Iterator {
        //^^^^
 }
 
-fn g() -> <() as Iterator<Item<|> = ()>>::Item {}
+fn g() -> <() as Iterator<Item$0 = ()>>::Item {}
 "#,
         );
     }
@@ -1027,7 +1082,7 @@ trait Iterator {
     type B;
 }
 
-fn g() -> <() as Iterator<A<|> = (), B = u8>>::B {}
+fn g() -> <() as Iterator<A$0 = (), B = u8>>::B {}
 "#,
         );
         check(
@@ -1038,7 +1093,7 @@ trait Iterator {
        //^
 }
 
-fn g() -> <() as Iterator<A = (), B<|> = u8>>::A {}
+fn g() -> <() as Iterator<A = (), B$0 = u8>>::A {}
 "#,
         );
     }
@@ -1052,7 +1107,7 @@ struct Foo {}
 impl Foo {
     fn bar(self: &Foo) {
          //^^^^
-        let foo = sel<|>f;
+        let foo = sel$0f;
     }
 }"#,
         )
@@ -1065,7 +1120,7 @@ impl Foo {
 struct Foo {}
 
 impl Foo {
-    fn bar(&self<|>) {
+    fn bar(&self$0) {
           //^^^^
     }
 }"#,
@@ -1076,7 +1131,7 @@ impl Foo {
     fn goto_lifetime_param_on_decl() {
         check(
             r#"
-fn foo<'foobar<|>>(_: &'foobar ()) {
+fn foo<'foobar$0>(_: &'foobar ()) {
      //^^^^^^^
 }"#,
         )
@@ -1086,7 +1141,7 @@ fn foo<'foobar<|>>(_: &'foobar ()) {
     fn goto_lifetime_param_decl() {
         check(
             r#"
-fn foo<'foobar>(_: &'foobar<|> ()) {
+fn foo<'foobar>(_: &'foobar$0 ()) {
      //^^^^^^^
 }"#,
         )
@@ -1097,7 +1152,7 @@ fn foo<'foobar>(_: &'foobar<|> ()) {
         check(
             r#"
 fn foo<'foobar>(_: &'foobar ()) {
-    fn foo<'foobar>(_: &'foobar<|> ()) {}
+    fn foo<'foobar>(_: &'foobar$0 ()) {}
          //^^^^^^^
 }"#,
         )
@@ -1108,13 +1163,13 @@ fn foo<'foobar>(_: &'foobar ()) {
     fn goto_lifetime_hrtb() {
         check(
             r#"trait Foo<T> {}
-fn foo<T>() where for<'a> T: Foo<&'a<|> (u8, u16)>, {}
+fn foo<T>() where for<'a> T: Foo<&'a$0 (u8, u16)>, {}
                     //^^
 "#,
         );
         check(
             r#"trait Foo<T> {}
-fn foo<T>() where for<'a<|>> T: Foo<&'a (u8, u16)>, {}
+fn foo<T>() where for<'a$0> T: Foo<&'a (u8, u16)>, {}
                     //^^
 "#,
         );
@@ -1125,7 +1180,7 @@ fn foo<T>() where for<'a<|>> T: Foo<&'a (u8, u16)>, {}
     fn goto_lifetime_hrtb_for_type() {
         check(
             r#"trait Foo<T> {}
-fn foo<T>() where T: for<'a> Foo<&'a<|> (u8, u16)>, {}
+fn foo<T>() where T: for<'a> Foo<&'a$0 (u8, u16)>, {}
                        //^^
 "#,
         );
@@ -1139,10 +1194,40 @@ fn foo<'foo>(_: &'foo ()) {
     'foo: {
   //^^^^
         'bar: loop {
-            break 'foo<|>;
+            break 'foo$0;
         }
     }
 }"#,
         )
     }
+
+    #[test]
+    fn goto_def_for_intra_doc_link_same_file() {
+        check(
+            r#"
+/// Blah, [`bar`](bar) .. [`foo`](foo)$0 has [`bar`](bar)
+pub fn bar() { }
+
+/// You might want to see [`std::fs::read()`] too.
+pub fn foo() { }
+     //^^^
+
+}"#,
+        )
+    }
+
+    #[test]
+    fn goto_def_for_intra_doc_link_inner() {
+        check(
+            r#"
+//- /main.rs
+mod m;
+struct S;
+     //^
+
+//- /m.rs
+//! [`super::S$0`]
+"#,
+        )
+    }
 }
diff --git a/crates/ide/src/goto_implementation.rs b/crates/ide/src/goto_implementation.rs
index da9378a97..761a98b2c 100644
--- a/crates/ide/src/goto_implementation.rs
+++ b/crates/ide/src/goto_implementation.rs
@@ -107,7 +107,7 @@ mod tests {
     fn goto_implementation_works() {
         check(
             r#"
-struct Foo<|>;
+struct Foo$0;
 impl Foo {}
    //^^^
 "#,
@@ -118,7 +118,7 @@ impl Foo {}
     fn goto_implementation_works_multiple_blocks() {
         check(
             r#"
-struct Foo<|>;
+struct Foo$0;
 impl Foo {}
    //^^^
 impl Foo {}
@@ -131,7 +131,7 @@ impl Foo {}
     fn goto_implementation_works_multiple_mods() {
         check(
             r#"
-struct Foo<|>;
+struct Foo$0;
 mod a {
     impl super::Foo {}
        //^^^^^^^^^^
@@ -149,7 +149,7 @@ mod b {
         check(
             r#"
 //- /lib.rs
-struct Foo<|>;
+struct Foo$0;
 mod a;
 mod b;
 //- /a.rs
@@ -166,7 +166,7 @@ impl crate::Foo {}
     fn goto_implementation_for_trait() {
         check(
             r#"
-trait T<|> {}
+trait T$0 {}
 struct Foo;
 impl T for Foo {}
          //^^^
@@ -179,7 +179,7 @@ impl T for Foo {}
         check(
             r#"
 //- /lib.rs
-trait T<|> {};
+trait T$0 {};
 struct Foo;
 mod a;
 mod b;
@@ -199,7 +199,7 @@ impl crate::T for crate::Foo {}
             r#"
 //- /lib.rs
 trait T {}
-struct Foo<|>;
+struct Foo$0;
 impl Foo {}
    //^^^
 impl T for Foo {}
@@ -216,7 +216,7 @@ impl T for &Foo {}
             r#"
   #[derive(Copy)]
 //^^^^^^^^^^^^^^^
-struct Foo<|>;
+struct Foo$0;
 
 mod marker {
     trait Copy {}
diff --git a/crates/ide/src/goto_type_definition.rs b/crates/ide/src/goto_type_definition.rs
index 7e84e06be..369a59820 100644
--- a/crates/ide/src/goto_type_definition.rs
+++ b/crates/ide/src/goto_type_definition.rs
@@ -76,7 +76,7 @@ mod tests {
 struct Foo;
      //^^^
 fn foo() {
-    let f: Foo; f<|>
+    let f: Foo; f$0
 }
 "#,
         );
@@ -89,7 +89,7 @@ fn foo() {
 struct Foo;
      //^^^
 fn foo() {
-    let f: &Foo; f<|>
+    let f: &Foo; f$0
 }
 "#,
         );
@@ -103,7 +103,7 @@ macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
 struct Foo {}
      //^^^
 id! {
-    fn bar() { let f<|> = Foo {}; }
+    fn bar() { let f$0 = Foo {}; }
 }
 "#,
         );
@@ -115,7 +115,7 @@ id! {
             r#"
 struct Foo;
      //^^^
-fn foo(<|>f: Foo) {}
+fn foo($0f: Foo) {}
 "#,
         );
     }
@@ -129,7 +129,7 @@ struct Foo;
 struct Bar(Foo);
 fn foo() {
     let bar = Bar(Foo);
-    bar.<|>0;
+    bar.$00;
 }
 "#,
         );
@@ -142,7 +142,7 @@ fn foo() {
 struct Foo;
      //^^^
 impl Foo {
-    fn f(&self<|>) {}
+    fn f(&self$0) {}
 }
 "#,
         )
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index f2ad95cb6..317b6f011 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -1,6 +1,6 @@
 use hir::{
-    Adt, AsAssocItem, AssocItemContainer, FieldSource, HasAttrs, HasSource, HirDisplay, Module,
-    ModuleDef, ModuleSource, Semantics,
+    Adt, AsAssocItem, AssocItemContainer, FieldSource, GenericParam, HasAttrs, HasSource,
+    HirDisplay, Module, ModuleDef, ModuleSource, Semantics,
 };
 use ide_db::base_db::SourceDatabase;
 use ide_db::{
@@ -17,7 +17,7 @@ use crate::{
     doc_links::{remove_links, rewrite_links},
     markdown_remove::remove_markdown,
     markup::Markup,
-    runnables::runnable,
+    runnables::{runnable_fn, runnable_mod},
     FileId, FilePosition, NavigationTarget, RangeInfo, Runnable,
 };
 
@@ -31,19 +31,6 @@ pub struct HoverConfig {
     pub markdown: bool,
 }
 
-impl Default for HoverConfig {
-    fn default() -> Self {
-        Self {
-            implementations: true,
-            run: true,
-            debug: true,
-            goto_type_def: true,
-            links_in_hover: true,
-            markdown: true,
-        }
-    }
-}
-
 impl HoverConfig {
     pub const NO_ACTIONS: Self = Self {
         implementations: false,
@@ -188,12 +175,7 @@ fn show_implementations_action(db: &RootDatabase, def: Definition) -> Option<Hov
         Definition::SelfType(it) => it.target_ty(db).as_adt(),
         _ => None,
     }?;
-    match adt {
-        Adt::Struct(it) => it.try_to_nav(db),
-        Adt::Union(it) => it.try_to_nav(db),
-        Adt::Enum(it) => it.try_to_nav(db),
-    }
-    .map(to_action)
+    adt.try_to_nav(db).map(to_action)
 }
 
 fn runnable_action(
@@ -204,22 +186,20 @@ fn runnable_action(
     match def {
         Definition::ModuleDef(it) => match it {
             ModuleDef::Module(it) => match it.definition_source(sema.db).value {
-                ModuleSource::Module(it) => runnable(&sema, it.syntax().clone(), file_id)
-                    .map(|it| HoverAction::Runnable(it)),
+                ModuleSource::Module(it) => {
+                    runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it))
+                }
                 _ => None,
             },
-            ModuleDef::Function(it) => {
-                #[allow(deprecated)]
-                let src = it.source(sema.db)?;
+            ModuleDef::Function(func) => {
+                let src = func.source(sema.db)?;
                 if src.file_id != file_id.into() {
                     mark::hit!(hover_macro_generated_struct_fn_doc_comment);
                     mark::hit!(hover_macro_generated_struct_fn_doc_attr);
-
                     return None;
                 }
 
-                runnable(&sema, src.value.syntax().clone(), file_id)
-                    .map(|it| HoverAction::Runnable(it))
+                runnable_fn(&sema, func).map(HoverAction::Runnable)
             }
             _ => None,
         },
@@ -235,12 +215,12 @@ fn goto_type_action(db: &RootDatabase, def: Definition) -> Option<HoverAction> {
         }
     };
 
-    if let Definition::TypeParam(it) = def {
+    if let Definition::GenericParam(GenericParam::TypeParam(it)) = def {
         it.trait_bounds(db).into_iter().for_each(|it| push_new_def(it.into()));
     } else {
         let ty = match def {
             Definition::Local(it) => it.ty(db),
-            Definition::ConstParam(it) => it.ty(db),
+            Definition::GenericParam(GenericParam::ConstParam(it)) => it.ty(db),
             _ => return None,
         };
 
@@ -335,7 +315,6 @@ fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
             from_def_source_labeled(db, it, Some(label), mod_path)
         }
         Definition::Field(def) => {
-            #[allow(deprecated)]
             let src = def.source(db)?.value;
             if let FieldSource::Named(it) = src {
                 from_def_source_labeled(db, def, it.short_label(), mod_path)
@@ -373,9 +352,11 @@ fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
             })
         }
         Definition::Label(it) => Some(Markup::fenced_block(&it.name(db))),
-        Definition::LifetimeParam(it) => Some(Markup::fenced_block(&it.name(db))),
-        Definition::TypeParam(type_param) => Some(Markup::fenced_block(&type_param.display(db))),
-        Definition::ConstParam(it) => from_def_source(db, it, None),
+        Definition::GenericParam(it) => match it {
+            GenericParam::TypeParam(it) => Some(Markup::fenced_block(&it.display(db))),
+            GenericParam::LifetimeParam(it) => Some(Markup::fenced_block(&it.name(db))),
+            GenericParam::ConstParam(it) => from_def_source(db, it, None),
+        },
     };
 
     fn from_def_source<A, D>(db: &RootDatabase, def: D, mod_path: Option<String>) -> Option<Markup>
@@ -383,7 +364,6 @@ fn hover_for_definition(db: &RootDatabase, def: Definition) -> Option<Markup> {
         D: HasSource<Ast = A> + HasAttrs + Copy,
         A: ShortLabel,
     {
-        #[allow(deprecated)]
         let short_label = def.source(db)?.value.short_label();
         from_def_source_labeled(db, def, short_label, mod_path)
     }
@@ -474,7 +454,7 @@ mod tests {
 pub fn foo() -> u32 { 1 }
 
 fn main() {
-    let foo_test = foo()<|>;
+    let foo_test = foo()$0;
 }
 "#,
             expect![[r#"
@@ -493,7 +473,7 @@ fn main() {
 pub fn foo() -> u32 { 1 }
 
 fn main() {
-    let foo_test = foo()<|>;
+    let foo_test = foo()$0;
 }
 "#,
             expect![[r#"
@@ -523,7 +503,7 @@ fn main() {
         Option::Some(*memo + value)
     };
     let number = 5u32;
-    let mut iter<|> = scan(OtherStruct { i: num }, closure, number);
+    let mut iter$0 = scan(OtherStruct { i: num }, closure, number);
 }
 "#,
             expect![[r#"
@@ -543,7 +523,7 @@ fn main() {
             r#"
 pub fn foo() -> u32 { 1 }
 
-fn main() { let foo_test = fo<|>o(); }
+fn main() { let foo_test = fo$0o(); }
 "#,
             expect![[r#"
                 *foo*
@@ -575,7 +555,7 @@ mod a;
 mod b;
 mod c;
 
-fn main() { let foo_test = fo<|>o(); }
+fn main() { let foo_test = fo$0o(); }
         "#,
             expect![[r#"
                 *foo*
@@ -592,7 +572,7 @@ fn main() { let foo_test = fo<|>o(); }
             r#"
 pub fn foo<'a, T: AsRef<str>>(b: &'a T) -> &'a str { }
 
-fn main() { let foo_test = fo<|>o(); }
+fn main() { let foo_test = fo$0o(); }
         "#,
             expect![[r#"
                 *foo*
@@ -612,7 +592,7 @@ fn main() { let foo_test = fo<|>o(); }
     fn hover_shows_fn_signature_on_fn_name() {
         check(
             r#"
-pub fn foo<|>(a: u32, b: u32) -> u32 {}
+pub fn foo$0(a: u32, b: u32) -> u32 {}
 
 fn main() { }
 "#,
@@ -640,7 +620,7 @@ fn main() { }
 /// #
 /// foo(Path::new("hello, world!"))
 /// ```
-pub fn foo<|>(_: &Path) {}
+pub fn foo$0(_: &Path) {}
 
 fn main() { }
 "#,
@@ -673,7 +653,7 @@ fn main() { }
         check(
             r##"
 #[doc = r#"Raw string doc attr"#]
-pub fn foo<|>(_: &Path) {}
+pub fn foo$0(_: &Path) {}
 
 fn main() { }
 "##,
@@ -703,7 +683,7 @@ fn main() { }
 struct Foo { field_a: u32 }
 
 fn main() {
-    let foo = Foo { field_a<|>: 0, };
+    let foo = Foo { field_a$0: 0, };
 }
 "#,
             expect![[r#"
@@ -722,7 +702,7 @@ fn main() {
         // Hovering over the field in the definition
         check(
             r#"
-struct Foo { field_a<|>: u32 }
+struct Foo { field_a$0: u32 }
 
 fn main() {
     let foo = Foo { field_a: 0 };
@@ -745,7 +725,7 @@ fn main() {
     #[test]
     fn hover_const_static() {
         check(
-            r#"const foo<|>: u32 = 123;"#,
+            r#"const foo$0: u32 = 123;"#,
             expect![[r#"
                 *foo*
 
@@ -759,7 +739,7 @@ fn main() {
             "#]],
         );
         check(
-            r#"static foo<|>: u32 = 456;"#,
+            r#"static foo$0: u32 = 456;"#,
             expect![[r#"
                 *foo*
 
@@ -781,7 +761,7 @@ fn main() {
 struct Test<K, T = u8> { k: K, t: T }
 
 fn main() {
-    let zz<|> = Test { t: 23u8, k: 33 };
+    let zz$0 = Test { t: 23u8, k: 33 };
 }"#,
             expect![[r#"
                 *zz*
@@ -800,7 +780,7 @@ fn main() {
 enum Option<T> { Some(T) }
 use Option::Some;
 
-fn main() { So<|>me(12); }
+fn main() { So$0me(12); }
 "#,
             expect![[r#"
                 *Some*
@@ -820,7 +800,7 @@ fn main() { So<|>me(12); }
 enum Option<T> { Some(T) }
 use Option::Some;
 
-fn main() { let b<|>ar = Some(12); }
+fn main() { let b$0ar = Some(12); }
 "#,
             expect![[r#"
                 *bar*
@@ -838,7 +818,7 @@ fn main() { let b<|>ar = Some(12); }
             r#"
 enum Option<T> {
     /// The None variant
-    Non<|>e
+    Non$0e
 }
 "#,
             expect![[r#"
@@ -865,7 +845,7 @@ enum Option<T> {
     Some(T)
 }
 fn main() {
-    let s = Option::Som<|>e(12);
+    let s = Option::Som$0e(12);
 }
 "#,
             expect![[r#"
@@ -889,7 +869,7 @@ fn main() {
     #[test]
     fn hover_for_local_variable() {
         check(
-            r#"fn func(foo: i32) { fo<|>o; }"#,
+            r#"fn func(foo: i32) { fo$0o; }"#,
             expect![[r#"
                 *foo*
 
@@ -903,7 +883,7 @@ fn main() {
     #[test]
     fn hover_for_local_variable_pat() {
         check(
-            r#"fn func(fo<|>o: i32) {}"#,
+            r#"fn func(fo$0o: i32) {}"#,
             expect![[r#"
                 *foo*
 
@@ -917,7 +897,7 @@ fn main() {
     #[test]
     fn hover_local_var_edge() {
         check(
-            r#"fn func(foo: i32) { if true { <|>foo; }; }"#,
+            r#"fn func(foo: i32) { if true { $0foo; }; }"#,
             expect![[r#"
                 *foo*
 
@@ -931,7 +911,7 @@ fn main() {
     #[test]
     fn hover_for_param_edge() {
         check(
-            r#"fn func(<|>foo: i32) {}"#,
+            r#"fn func($0foo: i32) {}"#,
             expect![[r#"
                 *foo*
 
@@ -951,7 +931,7 @@ fn main() {
             trait DerefMut {
                 type Target: ?Sized;
             }
-            fn f(_x<|>: impl Deref<Target=u8> + DerefMut<Target=u8>) {}"#,
+            fn f(_x$0: impl Deref<Target=u8> + DerefMut<Target=u8>) {}"#,
             expect![[r#"
                 *_x*
 
@@ -972,7 +952,7 @@ impl Thing {
     fn new() -> Thing { Thing { x: 0 } }
 }
 
-fn main() { let foo_<|>test = Thing::new(); }
+fn main() { let foo_$0test = Thing::new(); }
             "#,
             expect![[r#"
                 *foo_test*
@@ -996,7 +976,7 @@ mod wrapper {
     }
 }
 
-fn main() { let foo_test = wrapper::Thing::new<|>(); }
+fn main() { let foo_test = wrapper::Thing::new$0(); }
 "#,
             expect![[r#"
                 *new*
@@ -1023,7 +1003,7 @@ impl X {
 
 fn main() {
     match 1 {
-        X::C<|> => {},
+        X::C$0 => {},
         2 => {},
         _ => {}
     };
@@ -1049,7 +1029,7 @@ fn main() {
             r#"
 struct Thing { x: u32 }
 impl Thing {
-    fn new() -> Self { Self<|> { x: 0 } }
+    fn new() -> Self { Self$0 { x: 0 } }
 }
 "#,
             expect![[r#"
@@ -1068,7 +1048,7 @@ impl Thing {
             r#"
 struct Thing { x: u32 }
 impl Thing {
-    fn new() -> Self<|> { Self { x: 0 } }
+    fn new() -> Self$0 { Self { x: 0 } }
 }
 "#,
             expect![[r#"
@@ -1087,7 +1067,7 @@ impl Thing {
             r#"
 enum Thing { A }
 impl Thing {
-    pub fn new() -> Self<|> { Thing::A }
+    pub fn new() -> Self$0 { Thing::A }
 }
 "#,
             expect![[r#"
@@ -1106,7 +1086,7 @@ impl Thing {
             r#"
         enum Thing { A }
         impl Thing {
-            pub fn thing(a: Self<|>) {}
+            pub fn thing(a: Self$0) {}
         }
         "#,
             expect![[r#"
@@ -1131,7 +1111,7 @@ fn x() {}
 
 fn y() {
     let x = 0i32;
-    x<|>;
+    x$0;
 }
 "#,
             expect![[r#"
@@ -1150,7 +1130,7 @@ fn y() {
             r#"
 macro_rules! foo { () => {} }
 
-fn f() { fo<|>o!(); }
+fn f() { fo$0o!(); }
 "#,
             expect![[r#"
                 *foo*
@@ -1169,7 +1149,7 @@ fn f() { fo<|>o!(); }
     #[test]
     fn test_hover_tuple_field() {
         check(
-            r#"struct TS(String, i32<|>);"#,
+            r#"struct TS(String, i32$0);"#,
             expect![[r#"
                 *i32*
 
@@ -1187,7 +1167,7 @@ fn f() { fo<|>o!(); }
 macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
 fn foo() {}
 id! {
-    fn bar() { fo<|>o(); }
+    fn bar() { fo$0o(); }
 }
 "#,
             expect![[r#"
@@ -1209,7 +1189,7 @@ id! {
         check(
             r#"
 macro_rules! id { ($($tt:tt)*) => { $($tt)* } }
-fn foo(bar:u32) { let a = id!(ba<|>r); }
+fn foo(bar:u32) { let a = id!(ba$0r); }
 "#,
             expect![[r#"
                 *bar*
@@ -1227,7 +1207,7 @@ fn foo(bar:u32) { let a = id!(ba<|>r); }
             r#"
 macro_rules! id_deep { ($($tt:tt)*) => { $($tt)* } }
 macro_rules! id { ($($tt:tt)*) => { id_deep!($($tt)*) } }
-fn foo(bar:u32) { let a = id!(ba<|>r); }
+fn foo(bar:u32) { let a = id!(ba$0r); }
 "#,
             expect![[r#"
                 *bar*
@@ -1246,7 +1226,7 @@ fn foo(bar:u32) { let a = id!(ba<|>r); }
 macro_rules! id_deep { ($($tt:tt)*) => { $($tt)* } }
 macro_rules! id { ($($tt:tt)*) => { id_deep!($($tt)*) } }
 fn bar() -> u32 { 0 }
-fn foo() { let a = id!([0u32, bar(<|>)] ); }
+fn foo() { let a = id!([0u32, bar($0)] ); }
 "#,
             expect![[r#"
                 *bar()*
@@ -1264,7 +1244,7 @@ fn foo() { let a = id!([0u32, bar(<|>)] ); }
 macro_rules! arr { ($($tt:tt)*) => { [$($tt)*)] } }
 fn foo() {
     let mastered_for_itunes = "";
-    let _ = arr!("Tr<|>acks", &mastered_for_itunes);
+    let _ = arr!("Tr$0acks", &mastered_for_itunes);
 }
 "#,
             expect![[r#"
@@ -1285,7 +1265,7 @@ macro_rules! assert {}
 
 fn bar() -> bool { true }
 fn foo() {
-    assert!(ba<|>r());
+    assert!(ba$0r());
 }
 "#,
             expect![[r#"
@@ -1310,7 +1290,7 @@ fn foo() {
             macro_rules! format {}
 
             fn foo() {
-                format!("hel<|>lo {}", 0);
+                format!("hel$0lo {}", 0);
             }
             "#,
         );
@@ -1323,7 +1303,7 @@ fn foo() {
 ///　<- `\u{3000}` here
 fn foo() { }
 
-fn bar() { fo<|>o(); }
+fn bar() { fo$0o(); }
 ",
             expect![[r#"
                 *foo*
@@ -1346,7 +1326,7 @@ fn bar() { fo<|>o(); }
     #[test]
     fn test_hover_function_show_qualifiers() {
         check(
-            r#"async fn foo<|>() {}"#,
+            r#"async fn foo$0() {}"#,
             expect![[r#"
                 *foo*
 
@@ -1360,7 +1340,7 @@ fn bar() { fo<|>o(); }
             "#]],
         );
         check(
-            r#"pub const unsafe fn foo<|>() {}"#,
+            r#"pub const unsafe fn foo$0() {}"#,
             expect![[r#"
                 *foo*
 
@@ -1374,7 +1354,7 @@ fn bar() { fo<|>o(); }
             "#]],
         );
         check(
-            r#"pub(crate) async unsafe extern "C" fn foo<|>() {}"#,
+            r#"pub(crate) async unsafe extern "C" fn foo$0() {}"#,
             expect![[r#"
                 *foo*
 
@@ -1392,7 +1372,7 @@ fn bar() { fo<|>o(); }
     #[test]
     fn test_hover_trait_show_qualifiers() {
         check_actions(
-            r"unsafe trait foo<|>() {}",
+            r"unsafe trait foo$0() {}",
             expect![[r#"
                 [
                     Implementation(
@@ -1413,7 +1393,7 @@ fn bar() { fo<|>o(); }
         check(
             r#"
 //- /main.rs crate:main deps:std
-extern crate st<|>d;
+extern crate st$0d;
 //- /std/lib.rs crate:std
 //! Standard library for this test
 //!
@@ -1431,7 +1411,7 @@ extern crate st<|>d;
         check(
             r#"
 //- /main.rs crate:main deps:std
-extern crate std as ab<|>c;
+extern crate std as ab$0c;
 //- /std/lib.rs crate:std
 //! Standard library for this test
 //!
@@ -1452,7 +1432,7 @@ extern crate std as ab<|>c;
     fn test_hover_mod_with_same_name_as_function() {
         check(
             r#"
-use self::m<|>y::Bar;
+use self::m$0y::Bar;
 mod my { pub struct Bar; }
 
 fn my() {}
@@ -1478,7 +1458,7 @@ fn my() {}
 /// bar docs
 struct Bar;
 
-fn foo() { let bar = Ba<|>r; }
+fn foo() { let bar = Ba$0r; }
 "#,
             expect![[r#"
                 *Bar*
@@ -1505,7 +1485,7 @@ fn foo() { let bar = Ba<|>r; }
 #[doc = "bar docs"]
 struct Bar;
 
-fn foo() { let bar = Ba<|>r; }
+fn foo() { let bar = Ba$0r; }
 "#,
             expect![[r#"
                 *Bar*
@@ -1534,7 +1514,7 @@ fn foo() { let bar = Ba<|>r; }
 #[doc = "bar docs 2"]
 struct Bar;
 
-fn foo() { let bar = Ba<|>r; }
+fn foo() { let bar = Ba$0r; }
 "#,
             expect![[r#"
                 *Bar*
@@ -1562,7 +1542,7 @@ fn foo() { let bar = Ba<|>r; }
             r#"
 pub struct Foo;
 /// [Foo](struct.Foo.html)
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1588,7 +1568,7 @@ pub struct B<|>ar
             r#"
 pub struct Foo;
 /// [struct Foo](struct.Foo.html)
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1616,7 +1596,7 @@ pub struct B<|>ar
 pub struct Foo;
 pub struct Bar {
     /// [Foo](struct.Foo.html)
-    fie<|>ld: ()
+    fie$0ld: ()
 }
 "#,
             expect![[r#"
@@ -1645,7 +1625,7 @@ pub mod foo {
     pub struct Foo;
 }
 /// [Foo](foo::Foo)
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1675,7 +1655,7 @@ pub mod foo {
     pub struct Foo;
 }
 /// [Foo](foo::Foo)
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1701,7 +1681,7 @@ pub struct B<|>ar
             r#"
 pub struct Foo;
 /// [Foo]
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1727,7 +1707,7 @@ pub struct B<|>ar
             r#"
 pub struct Foo;
 /// [`Foo`]
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1754,7 +1734,7 @@ pub struct B<|>ar
 pub struct Foo;
 fn Foo() {}
 /// [Foo()]
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1780,7 +1760,7 @@ pub struct B<|>ar
             r#"
 pub struct Foo;
 /// [`struct Foo`]
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1806,7 +1786,7 @@ pub struct B<|>ar
             r#"
 pub struct Foo;
 /// [`struct@Foo`]
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1834,7 +1814,7 @@ pub struct Foo;
 /// [my Foo][foo]
 ///
 /// [foo]: Foo
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1860,7 +1840,7 @@ pub struct B<|>ar
             r#"
 pub struct Foo;
 /// [external](https://www.google.com)
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1887,7 +1867,7 @@ pub struct B<|>ar
             r#"
 pub struct Foo;
 /// [baz](Baz)
-pub struct B<|>ar
+pub struct B$0ar
 "#,
             expect![[r#"
                 *Bar*
@@ -1913,7 +1893,7 @@ pub struct B<|>ar
             r#"
 enum E {
     /// [E]
-    V<|> { field: i32 }
+    V$0 { field: i32 }
 }
 "#,
             expect![[r#"
@@ -1940,7 +1920,7 @@ enum E {
             r#"
 struct S {
     /// [`S`]
-    field<|>: i32
+    field$0: i32
 }
 "#,
             expect![[r#"
@@ -1968,16 +1948,16 @@ struct S {
 /// Test cases:
 /// case 1.  bare URL: https://www.example.com/
 /// case 2.  inline URL with title: [example](https://www.example.com/)
-/// case 3.  code refrence: [`Result`]
-/// case 4.  code refrence but miss footnote: [`String`]
+/// case 3.  code reference: [`Result`]
+/// case 4.  code reference but miss footnote: [`String`]
 /// case 5.  autolink: <http://www.example.com/>
 /// case 6.  email address: <[email protected]>
-/// case 7.  refrence: [example][example]
+/// case 7.  reference: [example][example]
 /// case 8.  collapsed link: [example][]
 /// case 9.  shortcut link: [example]
 /// case 10. inline without URL: [example]()
-/// case 11. refrence: [foo][foo]
-/// case 12. refrence: [foo][bar]
+/// case 11. reference: [foo][foo]
+/// case 12. reference: [foo][bar]
 /// case 13. collapsed link: [foo][]
 /// case 14. shortcut link: [foo]
 /// case 15. inline without URL: [foo]()
@@ -1986,7 +1966,7 @@ struct S {
 ///
 /// [`Result`]: ../../std/result/enum.Result.html
 /// [^example]: https://www.example.com/
-pub fn fo<|>o() {}
+pub fn fo$0o() {}
 "#,
             expect![[r#"
                 *foo*
@@ -2004,16 +1984,16 @@ pub fn fo<|>o() {}
                 Test cases:
                 case 1.  bare URL: https://www.example.com/
                 case 2.  inline URL with title: [example](https://www.example.com/)
-                case 3.  code refrence: `Result`
-                case 4.  code refrence but miss footnote: `String`
+                case 3.  code reference: `Result`
+                case 4.  code reference but miss footnote: `String`
                 case 5.  autolink: http://www.example.com/
                 case 6.  email address: [email protected]
-                case 7.  refrence: example
+                case 7.  reference: example
                 case 8.  collapsed link: example
                 case 9.  shortcut link: example
                 case 10. inline without URL: example
-                case 11. refrence: foo
-                case 12. refrence: foo
+                case 11. reference: foo
+                case 12. reference: foo
                 case 13. collapsed link: foo
                 case 14. shortcut link: foo
                 case 15. inline without URL: foo
@@ -2043,7 +2023,7 @@ macro_rules! bar {
 
 bar!();
 
-fn foo() { let bar = Bar; bar.fo<|>o(); }
+fn foo() { let bar = Bar; bar.fo$0o(); }
 "#,
             expect![[r#"
                 *foo*
@@ -2081,7 +2061,7 @@ macro_rules! bar {
 
 bar!();
 
-fn foo() { let bar = Bar; bar.fo<|>o(); }
+fn foo() { let bar = Bar; bar.fo$0o(); }
 "#,
             expect![[r#"
                 *foo*
@@ -2104,7 +2084,7 @@ fn foo() { let bar = Bar; bar.fo<|>o(); }
     #[test]
     fn test_hover_trait_has_impl_action() {
         check_actions(
-            r#"trait foo<|>() {}"#,
+            r#"trait foo$0() {}"#,
             expect![[r#"
                 [
                     Implementation(
@@ -2123,7 +2103,7 @@ fn foo() { let bar = Bar; bar.fo<|>o(); }
     #[test]
     fn test_hover_struct_has_impl_action() {
         check_actions(
-            r"struct foo<|>() {}",
+            r"struct foo$0() {}",
             expect![[r#"
                 [
                     Implementation(
@@ -2142,7 +2122,7 @@ fn foo() { let bar = Bar; bar.fo<|>o(); }
     #[test]
     fn test_hover_union_has_impl_action() {
         check_actions(
-            r#"union foo<|>() {}"#,
+            r#"union foo$0() {}"#,
             expect![[r#"
                 [
                     Implementation(
@@ -2161,7 +2141,7 @@ fn foo() { let bar = Bar; bar.fo<|>o(); }
     #[test]
     fn test_hover_enum_has_impl_action() {
         check_actions(
-            r"enum foo<|>() { A, B }",
+            r"enum foo$0() { A, B }",
             expect![[r#"
                 [
                     Implementation(
@@ -2180,7 +2160,7 @@ fn foo() { let bar = Bar; bar.fo<|>o(); }
     #[test]
     fn test_hover_self_has_impl_action() {
         check_actions(
-            r#"struct foo where Self<|>:;"#,
+            r#"struct foo where Self$0:;"#,
             expect![[r#"
                 [
                     Implementation(
@@ -2201,7 +2181,7 @@ fn foo() { let bar = Bar; bar.fo<|>o(); }
         check_actions(
             r#"
 #[test]
-fn foo_<|>test() {}
+fn foo_$0test() {}
 "#,
             expect![[r#"
                 [
@@ -2236,7 +2216,7 @@ fn foo_<|>test() {}
     fn test_hover_test_mod_has_action() {
         check_actions(
             r#"
-mod tests<|> {
+mod tests$0 {
     #[test]
     fn foo_test() {}
 }
@@ -2271,7 +2251,7 @@ mod tests<|> {
             r#"
 struct S{ f1: u32 }
 
-fn main() { let s<|>t = S{ f1:0 }; }
+fn main() { let s$0t = S{ f1:0 }; }
             "#,
             expect![[r#"
                 [
@@ -2304,7 +2284,7 @@ fn main() { let s<|>t = S{ f1:0 }; }
 struct Arg(u32);
 struct S<T>{ f1: T }
 
-fn main() { let s<|>t = S{ f1:Arg(0) }; }
+fn main() { let s$0t = S{ f1:Arg(0) }; }
 "#,
             expect![[r#"
                 [
@@ -2350,7 +2330,7 @@ fn main() { let s<|>t = S{ f1:Arg(0) }; }
 struct Arg(u32);
 struct S<T>{ f1: T }
 
-fn main() { let s<|>t = S{ f1: S{ f1: Arg(0) } }; }
+fn main() { let s$0t = S{ f1: S{ f1: Arg(0) } }; }
             "#,
             expect![[r#"
                 [
@@ -2399,7 +2379,7 @@ mod M {
     pub struct C(u32);
 }
 
-fn main() { let s<|>t = (A(1), B(2), M::C(3) ); }
+fn main() { let s$0t = (A(1), B(2), M::C(3) ); }
 "#,
             expect![[r#"
                 [
@@ -2458,7 +2438,7 @@ fn main() { let s<|>t = (A(1), B(2), M::C(3) ); }
 trait Foo {}
 fn foo() -> impl Foo {}
 
-fn main() { let s<|>t = foo(); }
+fn main() { let s$0t = foo(); }
 "#,
             expect![[r#"
                 [
@@ -2492,7 +2472,7 @@ trait Foo<T> {}
 struct S;
 fn foo() -> impl Foo<S> {}
 
-fn main() { let s<|>t = foo(); }
+fn main() { let s$0t = foo(); }
 "#,
             expect![[r#"
                 [
@@ -2539,7 +2519,7 @@ trait Foo {}
 trait Bar {}
 fn foo() -> impl Foo + Bar {}
 
-fn main() { let s<|>t = foo(); }
+fn main() { let s$0t = foo(); }
             "#,
             expect![[r#"
                 [
@@ -2589,7 +2569,7 @@ struct S2 {}
 
 fn foo() -> impl Foo<S1> + Bar<S2> {}
 
-fn main() { let s<|>t = foo(); }
+fn main() { let s$0t = foo(); }
 "#,
             expect![[r#"
                 [
@@ -2659,7 +2639,7 @@ fn main() { let s<|>t = foo(); }
         check_actions(
             r#"
 trait Foo {}
-fn foo(ar<|>g: &impl Foo) {}
+fn foo(ar$0g: &impl Foo) {}
 "#,
             expect![[r#"
                 [
@@ -2693,7 +2673,7 @@ trait Foo {}
 trait Bar<T> {}
 struct S{}
 
-fn foo(ar<|>g: &impl Foo + Bar<S>) {}
+fn foo(ar$0g: &impl Foo + Bar<S>) {}
 "#,
             expect![[r#"
                 [
@@ -2751,7 +2731,7 @@ fn foo(ar<|>g: &impl Foo + Bar<S>) {}
             r#"
 struct S;
 fn foo() {
-    let fo<|>o = async { S };
+    let fo$0o = async { S };
 }
 
 #[prelude_import] use future::*;
@@ -2803,7 +2783,7 @@ mod future {
             r#"
 trait Foo<T> {}
 struct S {}
-fn foo(ar<|>g: &impl Foo<S>) {}
+fn foo(ar$0g: &impl Foo<S>) {}
 "#,
             expect![[r#"
                 [
@@ -2853,7 +2833,7 @@ impl Foo for S {}
 struct B<T>{}
 fn foo() -> B<dyn Foo> {}
 
-fn main() { let s<|>t = foo(); }
+fn main() { let s$0t = foo(); }
 "#,
             expect![[r#"
                 [
@@ -2897,7 +2877,7 @@ fn main() { let s<|>t = foo(); }
         check_actions(
             r#"
 trait Foo {}
-fn foo(ar<|>g: &dyn Foo) {}
+fn foo(ar$0g: &dyn Foo) {}
 "#,
             expect![[r#"
                 [
@@ -2929,7 +2909,7 @@ fn foo(ar<|>g: &dyn Foo) {}
             r#"
 trait Foo<T> {}
 struct S {}
-fn foo(ar<|>g: &dyn Foo<S>) {}
+fn foo(ar$0g: &dyn Foo<S>) {}
 "#,
             expect![[r#"
                 [
@@ -2977,7 +2957,7 @@ trait DynTrait<T> {}
 struct B<T> {}
 struct S {}
 
-fn foo(a<|>rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
+fn foo(a$0rg: &impl ImplTrait<B<dyn DynTrait<B<S>>>>) {}
             "#,
             expect![[r#"
                 [
@@ -3058,7 +3038,7 @@ impl Foo for S { type Item = Bar; }
 
 fn test() -> impl Foo { S {} }
 
-fn main() { let s<|>t = test().get(); }
+fn main() { let s$0t = test().get(); }
 "#,
             expect![[r#"
                 [
@@ -3091,7 +3071,7 @@ fn main() { let s<|>t = test().get(); }
 struct Bar;
 struct Foo<const BAR: Bar>;
 
-impl<const BAR: Bar> Foo<BAR<|>> {}
+impl<const BAR: Bar> Foo<BAR$0> {}
 "#,
             expect![[r#"
                 [
@@ -3123,7 +3103,7 @@ impl<const BAR: Bar> Foo<BAR<|>> {}
             r#"
 trait Foo {}
 
-fn foo<T: Foo>(t: T<|>){}
+fn foo<T: Foo>(t: T$0){}
 "#,
             expect![[r#"
                 [
@@ -3163,7 +3143,7 @@ pub mod wrapper {
 }
 
 //- /main.rs crate:main deps:name-with-dashes
-fn main() { let foo_test = name_with_dashes::wrapper::Thing::new<|>(); }
+fn main() { let foo_test = name_with_dashes::wrapper::Thing::new$0(); }
 "#,
             expect![[r#"
             *new*
@@ -3189,7 +3169,7 @@ struct S {
 
 fn main() {
     let s = S { f: 0 };
-    let S { f<|> } = &s;
+    let S { f$0 } = &s;
 }
 "#,
             expect![[r#"
@@ -3208,7 +3188,7 @@ fn main() {
             r#"
 struct Foo {}
 impl Foo {
-    fn bar(&sel<|>f) {}
+    fn bar(&sel$0f) {}
 }
 "#,
             expect![[r#"
@@ -3227,7 +3207,7 @@ impl Foo {
 struct Arc<T>(T);
 struct Foo {}
 impl Foo {
-    fn bar(sel<|>f: Arc<Foo>) {}
+    fn bar(sel$0f: Arc<Foo>) {}
 }
 "#,
             expect![[r#"
@@ -3244,7 +3224,7 @@ impl Foo {
         check(
             r#"
 /// Be quick;
-mod Foo<|> {
+mod Foo$0 {
     //! time is mana
 
     /// This comment belongs to the function
@@ -3275,7 +3255,7 @@ mod Foo<|> {
         check(
             r#"
 #[doc = "Be quick;"]
-mod Foo<|> {
+mod Foo$0 {
     #![doc = "time is mana"]
 
     #[doc = "This comment belongs to the function"]
@@ -3306,7 +3286,7 @@ mod Foo<|> {
         check_hover_no_result(
             r#"
 fn no_hover() {
-    // no<|>hover
+    // no$0hover
 }
 "#,
         );
@@ -3317,7 +3297,7 @@ fn no_hover() {
         check(
             r#"
 fn foo() {
-    'label<|>: loop {}
+    'label$0: loop {}
 }
 "#,
             expect![[r#"
@@ -3333,7 +3313,7 @@ fn foo() {
     #[test]
     fn hover_lifetime() {
         check(
-            r#"fn foo<'lifetime>(_: &'lifetime<|> ()) {}"#,
+            r#"fn foo<'lifetime>(_: &'lifetime$0 ()) {}"#,
             expect![[r#"
             *'lifetime*
 
@@ -3352,7 +3332,7 @@ struct Foo<T>(T);
 trait Copy {}
 trait Clone {}
 trait Sized {}
-impl<T: Copy + Clone> Foo<T<|>> where T: Sized {}
+impl<T: Copy + Clone> Foo<T$0> where T: Sized {}
 "#,
             expect![[r#"
                 *T*
@@ -3365,7 +3345,7 @@ impl<T: Copy + Clone> Foo<T<|>> where T: Sized {}
         check(
             r#"
 struct Foo<T>(T);
-impl<T> Foo<T<|>> {}
+impl<T> Foo<T$0> {}
 "#,
             expect![[r#"
                 *T*
@@ -3379,7 +3359,7 @@ impl<T> Foo<T<|>> {}
         check(
             r#"
 struct Foo<T>(T);
-impl<T: 'static> Foo<T<|>> {}
+impl<T: 'static> Foo<T$0> {}
 "#,
             expect![[r#"
                 *T*
@@ -3396,7 +3376,7 @@ impl<T: 'static> Foo<T<|>> {}
         check(
             r#"
 struct Foo<const LEN: usize>;
-impl<const LEN: usize> Foo<LEN<|>> {}
+impl<const LEN: usize> Foo<LEN$0> {}
 "#,
             expect![[r#"
                 *LEN*
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index 65df7979c..3e9a65d9c 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -18,12 +18,6 @@ pub struct InlayHintsConfig {
     pub max_length: Option<usize>,
 }
 
-impl Default for InlayHintsConfig {
-    fn default() -> Self {
-        Self { type_hints: true, parameter_hints: true, chaining_hints: true, max_length: None }
-    }
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum InlayKind {
     TypeHint,
@@ -359,9 +353,25 @@ fn is_argument_similar_to_param_name(
     }
     match get_string_representation(argument) {
         None => false,
-        Some(repr) => {
-            let argument_string = repr.trim_start_matches('_');
-            argument_string.starts_with(param_name) || argument_string.ends_with(param_name)
+        Some(argument_string) => {
+            let num_leading_underscores =
+                argument_string.bytes().take_while(|&c| c == b'_').count();
+
+            // Does the argument name begin with the parameter name? Ignore leading underscores.
+            let mut arg_bytes = argument_string.bytes().skip(num_leading_underscores);
+            let starts_with_pattern = param_name.bytes().all(
+                |expected| matches!(arg_bytes.next(), Some(actual) if expected.eq_ignore_ascii_case(&actual)),
+            );
+
+            if starts_with_pattern {
+                return true;
+            }
+
+            // Does the argument name end with the parameter name?
+            let mut arg_bytes = argument_string.bytes().skip(num_leading_underscores);
+            param_name.bytes().rev().all(
+                |expected| matches!(arg_bytes.next_back(), Some(actual) if expected.eq_ignore_ascii_case(&actual)),
+            )
         }
     }
 }
@@ -433,8 +443,15 @@ mod tests {
 
     use crate::{fixture, inlay_hints::InlayHintsConfig};
 
+    const TEST_CONFIG: InlayHintsConfig = InlayHintsConfig {
+        type_hints: true,
+        parameter_hints: true,
+        chaining_hints: true,
+        max_length: None,
+    };
+
     fn check(ra_fixture: &str) {
-        check_with_config(InlayHintsConfig::default(), ra_fixture);
+        check_with_config(TEST_CONFIG, ra_fixture);
     }
 
     fn check_with_config(config: InlayHintsConfig, ra_fixture: &str) {
@@ -748,7 +765,7 @@ fn main() {
     #[test]
     fn hint_truncation() {
         check_with_config(
-            InlayHintsConfig { max_length: Some(8), ..Default::default() },
+            InlayHintsConfig { max_length: Some(8), ..TEST_CONFIG },
             r#"
 struct Smol<T>(T);
 
@@ -831,7 +848,7 @@ fn main() {
     #[test]
     fn omitted_parameters_hints_heuristics() {
         check_with_config(
-            InlayHintsConfig { max_length: Some(8), ..Default::default() },
+            InlayHintsConfig { max_length: Some(8), ..TEST_CONFIG },
             r#"
 fn map(f: i32) {}
 fn filter(predicate: i32) {}
@@ -900,6 +917,9 @@ fn main() {
     twiddle(true);
     doo(true);
 
+    const TWIDDLE_UPPERCASE: bool = true;
+    twiddle(TWIDDLE_UPPERCASE);
+
     let mut param_begin: Param = Param {};
     different_order(&param_begin);
     different_order(&mut param_begin);
@@ -924,7 +944,7 @@ fn main() {
     #[test]
     fn unit_structs_have_no_type_hints() {
         check_with_config(
-            InlayHintsConfig { max_length: Some(8), ..Default::default() },
+            InlayHintsConfig { max_length: Some(8), ..TEST_CONFIG },
             r#"
 enum Result<T, E> { Ok(T), Err(E) }
 use Result::*;
diff --git a/crates/ide/src/join_lines.rs b/crates/ide/src/join_lines.rs
index b5a6f66fd..05380f2a1 100644
--- a/crates/ide/src/join_lines.rs
+++ b/crates/ide/src/join_lines.rs
@@ -104,7 +104,7 @@ fn remove_newline(edit: &mut TextEditBuilder, token: &SyntaxToken, offset: TextS
     // Special case that turns something like:
     //
     // ```
-    // my_function({<|>
+    // my_function({$0
     //    <some-expr>
     // })
     // ```
@@ -116,7 +116,7 @@ fn remove_newline(edit: &mut TextEditBuilder, token: &SyntaxToken, offset: TextS
     // ditto for
     //
     // ```
-    // use foo::{<|>
+    // use foo::{$0
     //    bar
     // };
     // ```
@@ -198,8 +198,8 @@ mod tests {
 
     use super::*;
 
-    fn check_join_lines(before: &str, after: &str) {
-        let (before_cursor_pos, before) = extract_offset(before);
+    fn check_join_lines(ra_fixture_before: &str, ra_fixture_after: &str) {
+        let (before_cursor_pos, before) = extract_offset(ra_fixture_before);
         let file = SourceFile::parse(&before).ok().unwrap();
 
         let range = TextRange::empty(before_cursor_pos);
@@ -214,7 +214,7 @@ mod tests {
             .apply_to_offset(before_cursor_pos)
             .expect("cursor position is affected by the edit");
         let actual = add_cursor(&actual, actual_cursor_pos);
-        assert_eq_text!(after, &actual);
+        assert_eq_text!(ra_fixture_after, &actual);
     }
 
     #[test]
@@ -222,13 +222,13 @@ mod tests {
         check_join_lines(
             r"
 fn foo() {
-    <|>foo(1,
+    $0foo(1,
     )
 }
 ",
             r"
 fn foo() {
-    <|>foo(1)
+    $0foo(1)
 }
 ",
         );
@@ -239,14 +239,14 @@ fn foo() {
         check_join_lines(
             r"
 pub fn reparse(&self, edit: &AtomTextEdit) -> File {
-    <|>self.incremental_reparse(edit).unwrap_or_else(|| {
+    $0self.incremental_reparse(edit).unwrap_or_else(|| {
         self.full_reparse(edit)
     })
 }
 ",
             r"
 pub fn reparse(&self, edit: &AtomTextEdit) -> File {
-    <|>self.incremental_reparse(edit).unwrap_or_else(|| self.full_reparse(edit))
+    $0self.incremental_reparse(edit).unwrap_or_else(|| self.full_reparse(edit))
 }
 ",
         );
@@ -257,13 +257,13 @@ pub fn reparse(&self, edit: &AtomTextEdit) -> File {
         check_join_lines(
             r"
 fn foo() {
-    foo(<|>{
+    foo($0{
         92
     })
 }",
             r"
 fn foo() {
-    foo(<|>92)
+    foo($092)
 }",
         );
     }
@@ -274,7 +274,7 @@ fn foo() {
             fn foo() {
                 loop {
                     match x {
-                        92 => <|>{
+                        92 => $0{
                             continue;
                         }
                     }
@@ -285,7 +285,7 @@ fn foo() {
             fn foo() {
                 loop {
                     match x {
-                        92 => <|>continue,
+                        92 => $0continue,
                     }
                 }
             }
@@ -299,7 +299,7 @@ fn foo() {
             r"
 fn foo(e: Result<U, V>) {
     match e {
-        Ok(u) => <|>{
+        Ok(u) => $0{
             u.foo()
         }
         Err(v) => v,
@@ -308,7 +308,7 @@ fn foo(e: Result<U, V>) {
             r"
 fn foo(e: Result<U, V>) {
     match e {
-        Ok(u) => <|>u.foo(),
+        Ok(u) => $0u.foo(),
         Err(v) => v,
     }
 }",
@@ -321,7 +321,7 @@ fn foo(e: Result<U, V>) {
             r"
 fn foo() {
     match ty {
-        <|> Some(ty) => {
+        $0 Some(ty) => {
             match ty {
                 _ => false,
             }
@@ -333,7 +333,7 @@ fn foo() {
             r"
 fn foo() {
     match ty {
-        <|> Some(ty) => match ty {
+        $0 Some(ty) => match ty {
                 _ => false,
             },
         _ => true,
@@ -350,7 +350,7 @@ fn foo() {
             r"
 fn foo(e: Result<U, V>) {
     match e {
-        Ok(u) => <|>{
+        Ok(u) => $0{
             u.foo()
         },
         Err(v) => v,
@@ -359,7 +359,7 @@ fn foo(e: Result<U, V>) {
             r"
 fn foo(e: Result<U, V>) {
     match e {
-        Ok(u) => <|>u.foo(),
+        Ok(u) => $0u.foo(),
         Err(v) => v,
     }
 }",
@@ -370,7 +370,7 @@ fn foo(e: Result<U, V>) {
             r"
 fn foo(e: Result<U, V>) {
     match e {
-        Ok(u) => <|>{
+        Ok(u) => $0{
             u.foo()
         }    ,
         Err(v) => v,
@@ -379,7 +379,7 @@ fn foo(e: Result<U, V>) {
             r"
 fn foo(e: Result<U, V>) {
     match e {
-        Ok(u) => <|>u.foo()    ,
+        Ok(u) => $0u.foo()    ,
         Err(v) => v,
     }
 }",
@@ -390,7 +390,7 @@ fn foo(e: Result<U, V>) {
             r"
 fn foo(e: Result<U, V>) {
     match e {
-        Ok(u) => <|>{
+        Ok(u) => $0{
             u.foo()
         }
         ,
@@ -400,7 +400,7 @@ fn foo(e: Result<U, V>) {
             r"
 fn foo(e: Result<U, V>) {
     match e {
-        Ok(u) => <|>u.foo()
+        Ok(u) => $0u.foo()
         ,
         Err(v) => v,
     }
@@ -414,13 +414,13 @@ fn foo(e: Result<U, V>) {
         check_join_lines(
             r"
 fn foo() {
-    let x = (<|>{
+    let x = ($0{
        4
     },);
 }",
             r"
 fn foo() {
-    let x = (<|>4,);
+    let x = ($04,);
 }",
         );
 
@@ -428,13 +428,13 @@ fn foo() {
         check_join_lines(
             r"
 fn foo() {
-    let x = (<|>{
+    let x = ($0{
        4
     }   ,);
 }",
             r"
 fn foo() {
-    let x = (<|>4   ,);
+    let x = ($04   ,);
 }",
         );
 
@@ -442,14 +442,14 @@ fn foo() {
         check_join_lines(
             r"
 fn foo() {
-    let x = (<|>{
+    let x = ($0{
        4
     }
     ,);
 }",
             r"
 fn foo() {
-    let x = (<|>4
+    let x = ($04
     ,);
 }",
         );
@@ -460,11 +460,11 @@ fn foo() {
         // No space after the '{'
         check_join_lines(
             r"
-<|>use syntax::{
+$0use syntax::{
     TextSize, TextRange,
 };",
             r"
-<|>use syntax::{TextSize, TextRange,
+$0use syntax::{TextSize, TextRange,
 };",
         );
     }
@@ -475,11 +475,11 @@ fn foo() {
         check_join_lines(
             r"
 use syntax::{
-<|>    TextSize, TextRange
+$0    TextSize, TextRange
 };",
             r"
 use syntax::{
-<|>    TextSize, TextRange};",
+$0    TextSize, TextRange};",
         );
     }
 
@@ -489,11 +489,11 @@ use syntax::{
         check_join_lines(
             r"
 use syntax::{
-<|>    TextSize, TextRange,
+$0    TextSize, TextRange,
 };",
             r"
 use syntax::{
-<|>    TextSize, TextRange};",
+$0    TextSize, TextRange};",
         );
     }
 
@@ -502,14 +502,14 @@ use syntax::{
         check_join_lines(
             r"
 use syntax::{
-    algo::<|>{
+    algo::$0{
         find_token_at_offset,
     },
     ast,
 };",
             r"
 use syntax::{
-    algo::<|>find_token_at_offset,
+    algo::$0find_token_at_offset,
     ast,
 };",
         );
@@ -520,13 +520,13 @@ use syntax::{
         check_join_lines(
             r"
 fn foo() {
-    // Hello<|>
+    // Hello$0
     // world!
 }
 ",
             r"
 fn foo() {
-    // Hello<|> world!
+    // Hello$0 world!
 }
 ",
         );
@@ -537,13 +537,13 @@ fn foo() {
         check_join_lines(
             r"
 fn foo() {
-    /// Hello<|>
+    /// Hello$0
     /// world!
 }
 ",
             r"
 fn foo() {
-    /// Hello<|> world!
+    /// Hello$0 world!
 }
 ",
         );
@@ -554,13 +554,13 @@ fn foo() {
         check_join_lines(
             r"
 fn foo() {
-    //! Hello<|>
+    //! Hello$0
     //! world!
 }
 ",
             r"
 fn foo() {
-    //! Hello<|> world!
+    //! Hello$0 world!
 }
 ",
         );
@@ -571,13 +571,13 @@ fn foo() {
         check_join_lines(
             r"
 fn foo() {
-    // Hello<|>
+    // Hello$0
     /* world! */
 }
 ",
             r"
 fn foo() {
-    // Hello<|> world! */
+    // Hello$0 world! */
 }
 ",
         );
@@ -588,7 +588,7 @@ fn foo() {
         check_join_lines(
             r"
 fn foo() {
-    // The<|>
+    // The$0
     /* quick
     brown
     fox! */
@@ -596,7 +596,7 @@ fn foo() {
 ",
             r"
 fn foo() {
-    // The<|> quick
+    // The$0 quick
     brown
     fox! */
 }
@@ -604,8 +604,8 @@ fn foo() {
         );
     }
 
-    fn check_join_lines_sel(before: &str, after: &str) {
-        let (sel, before) = extract_range(before);
+    fn check_join_lines_sel(ra_fixture_before: &str, ra_fixture_after: &str) {
+        let (sel, before) = extract_range(ra_fixture_before);
         let parse = SourceFile::parse(&before);
         let result = join_lines(&parse.tree(), sel);
         let actual = {
@@ -613,7 +613,7 @@ fn foo() {
             result.apply(&mut actual);
             actual
         };
-        assert_eq_text!(after, &actual);
+        assert_eq_text!(ra_fixture_after, &actual);
     }
 
     #[test]
@@ -621,10 +621,10 @@ fn foo() {
         check_join_lines_sel(
             r"
 fn foo() {
-    <|>foo(1,
+    $0foo(1,
         2,
         3,
-    <|>)
+    $0)
 }
     ",
             r"
@@ -639,9 +639,9 @@ fn foo() {
     fn test_join_lines_selection_struct() {
         check_join_lines_sel(
             r"
-struct Foo <|>{
+struct Foo $0{
     f: u32,
-}<|>
+}$0
     ",
             r"
 struct Foo { f: u32 }
@@ -654,9 +654,9 @@ struct Foo { f: u32 }
         check_join_lines_sel(
             r"
 fn foo() {
-    join(<|>type_params.type_params()
+    join($0type_params.type_params()
             .filter_map(|it| it.name())
-            .map(|it| it.text())<|>)
+            .map(|it| it.text())$0)
 }",
             r"
 fn foo() {
@@ -671,9 +671,9 @@ fn foo() {
             r"
 pub fn handle_find_matching_brace() {
     params.offsets
-        .map(|offset| <|>{
+        .map(|offset| $0{
             world.analysis().matching_brace(&file, offset).unwrap_or(offset)
-        }<|>)
+        }$0)
         .collect();
 }",
             r"
@@ -691,7 +691,7 @@ pub fn handle_find_matching_brace() {
             r"
 fn main() {
     let _ = {
-        // <|>foo
+        // $0foo
         // bar
         92
     };
@@ -700,7 +700,7 @@ fn main() {
             r"
 fn main() {
     let _ = {
-        // <|>foo bar
+        // $0foo bar
         92
     };
 }
@@ -712,12 +712,12 @@ fn main() {
     fn join_lines_mandatory_blocks_block() {
         check_join_lines(
             r"
-<|>fn foo() {
+$0fn foo() {
     92
 }
         ",
             r"
-<|>fn foo() { 92
+$0fn foo() { 92
 }
         ",
         );
@@ -725,14 +725,14 @@ fn main() {
         check_join_lines(
             r"
 fn foo() {
-    <|>if true {
+    $0if true {
         92
     }
 }
         ",
             r"
 fn foo() {
-    <|>if true { 92
+    $0if true { 92
     }
 }
         ",
@@ -741,14 +741,14 @@ fn foo() {
         check_join_lines(
             r"
 fn foo() {
-    <|>loop {
+    $0loop {
         92
     }
 }
         ",
             r"
 fn foo() {
-    <|>loop { 92
+    $0loop { 92
     }
 }
         ",
@@ -757,14 +757,14 @@ fn foo() {
         check_join_lines(
             r"
 fn foo() {
-    <|>unsafe {
+    $0unsafe {
         92
     }
 }
         ",
             r"
 fn foo() {
-    <|>unsafe { 92
+    $0unsafe { 92
     }
 }
         ",
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index a450794f3..1e03832ec 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -76,14 +76,14 @@ pub use crate::{
     references::{rename::RenameError, Declaration, ReferenceSearchResult},
     runnables::{Runnable, RunnableKind, TestId},
     syntax_highlighting::{
-        tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag},
-        HighlightedRange,
+        tags::{Highlight, HlMod, HlMods, HlPunct, HlTag},
+        HlRange,
     },
 };
-pub use assists::{Assist, AssistConfig, AssistId, AssistKind};
+pub use assists::{Assist, AssistConfig, AssistId, AssistKind, InsertUseConfig};
 pub use completion::{
-    CompletionConfig, CompletionItem, CompletionItemKind, CompletionResolveCapability,
-    CompletionScore, ImportEdit, InsertTextFormat,
+    CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, ImportEdit,
+    InsertTextFormat,
 };
 pub use hir::{Documentation, Semantics};
 pub use ide_db::base_db::{
@@ -92,7 +92,7 @@ pub use ide_db::base_db::{
 };
 pub use ide_db::{
     call_info::CallInfo,
-    search::{Reference, ReferenceAccess, ReferenceKind},
+    search::{FileReference, ReferenceAccess, ReferenceKind},
 };
 pub use ide_db::{
     label::Label,
@@ -449,12 +449,12 @@ impl Analysis {
     }
 
     /// Computes syntax highlighting for the given file
-    pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
+    pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HlRange>> {
         self.with_db(|db| syntax_highlighting::highlight(db, file_id, None, false))
     }
 
     /// Computes syntax highlighting for the given file range.
-    pub fn highlight_range(&self, frange: FileRange) -> Cancelable<Vec<HighlightedRange>> {
+    pub fn highlight_range(&self, frange: FileRange) -> Cancelable<Vec<HlRange>> {
         self.with_db(|db| {
             syntax_highlighting::highlight(db, frange.file_id, Some(frange.range), false)
         })
diff --git a/crates/ide/src/matching_brace.rs b/crates/ide/src/matching_brace.rs
index d70248afe..1bfa1439d 100644
--- a/crates/ide/src/matching_brace.rs
+++ b/crates/ide/src/matching_brace.rs
@@ -58,15 +58,15 @@ mod tests {
             assert_eq_text!(after, &actual);
         }
 
-        do_check("struct Foo { a: i32, }<|>", "struct Foo <|>{ a: i32, }");
-        do_check("fn main() { |x: i32|<|> x * 2;}", "fn main() { <|>|x: i32| x * 2;}");
-        do_check("fn main() { <|>|x: i32| x * 2;}", "fn main() { |x: i32<|>| x * 2;}");
+        do_check("struct Foo { a: i32, }$0", "struct Foo $0{ a: i32, }");
+        do_check("fn main() { |x: i32|$0 x * 2;}", "fn main() { $0|x: i32| x * 2;}");
+        do_check("fn main() { $0|x: i32| x * 2;}", "fn main() { |x: i32$0| x * 2;}");
 
         {
             mark::check!(pipes_not_braces);
             do_check(
-                "fn main() { match 92 { 1 | 2 |<|> 3 => 92 } }",
-                "fn main() { match 92 { 1 | 2 |<|> 3 => 92 } }",
+                "fn main() { match 92 { 1 | 2 |$0 3 => 92 } }",
+                "fn main() { match 92 { 1 | 2 |$0 3 => 92 } }",
             );
         }
     }
diff --git a/crates/ide/src/parent_module.rs b/crates/ide/src/parent_module.rs
index be344a09b..d343638fb 100644
--- a/crates/ide/src/parent_module.rs
+++ b/crates/ide/src/parent_module.rs
@@ -74,7 +74,7 @@ mod tests {
             //- /lib.rs
             mod foo;
             //- /foo.rs
-            <|>// empty
+            $0// empty
             ",
         );
         let nav = analysis.parent_module(pos).unwrap().pop().unwrap();
@@ -90,7 +90,7 @@ mod tests {
             mod foo;
 
             //- /foo.rs
-            mod <|>bar;
+            mod $0bar;
 
             //- /foo/bar.rs
             // empty
@@ -107,7 +107,7 @@ mod tests {
             //- /lib.rs
             mod foo {
                 mod bar {
-                    mod baz { <|> }
+                    mod baz { $0 }
                 }
             }
             ",
@@ -123,7 +123,7 @@ mod tests {
 //- /main.rs
 mod foo;
 //- /foo.rs
-<|>
+$0
 "#,
         );
         assert_eq!(analysis.crate_for(file_id).unwrap().len(), 1);
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index fa58fc319..7d4757e02 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -3,7 +3,7 @@
 //! or `ast::NameRef`. If it's a `ast::NameRef`, at the classification step we
 //! try to resolve the direct tree parent of this element, otherwise we
 //! already have a definition and just need to get its HIR together with
-//! some information that is needed for futher steps of searching.
+//! some information that is needed for further steps of searching.
 //! After that, we collect files that might contain references and look
 //! for text occurrences of the identifier. If there's an `ast::NameRef`
 //! at the index that the match starts at and its tree parent is
@@ -13,15 +13,15 @@ pub(crate) mod rename;
 
 use hir::Semantics;
 use ide_db::{
+    base_db::FileId,
     defs::{Definition, NameClass, NameRefClass},
-    search::Reference,
-    search::{ReferenceAccess, ReferenceKind, SearchScope},
+    search::{FileReference, ReferenceAccess, ReferenceKind, SearchScope, UsageSearchResult},
     RootDatabase,
 };
 use syntax::{
     algo::find_node_at_offset,
     ast::{self, NameOwner},
-    match_ast, AstNode, SyntaxKind, SyntaxNode, TextRange, TokenAtOffset,
+    match_ast, AstNode, SyntaxNode, TextRange, TokenAtOffset, T,
 };
 
 use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo, SymbolKind};
@@ -29,7 +29,7 @@ use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeI
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
     declaration: Declaration,
-    references: Vec<Reference>,
+    references: UsageSearchResult,
 }
 
 #[derive(Debug, Clone)]
@@ -48,10 +48,21 @@ impl ReferenceSearchResult {
         &self.declaration.nav
     }
 
-    pub fn references(&self) -> &[Reference] {
+    pub fn references(&self) -> &UsageSearchResult {
         &self.references
     }
 
+    pub fn references_with_declaration(mut self) -> UsageSearchResult {
+        let decl_ref = FileReference {
+            range: self.declaration.nav.focus_or_full_range(),
+            kind: self.declaration.kind,
+            access: self.declaration.access,
+        };
+        let file_id = self.declaration.nav.file_id;
+        self.references.references.entry(file_id).or_default().push(decl_ref);
+        self.references
+    }
+
     /// Total number of references
     /// At least 1 since all valid references should
     /// Have a declaration
@@ -63,21 +74,11 @@ impl ReferenceSearchResult {
 // allow turning ReferenceSearchResult into an iterator
 // over References
 impl IntoIterator for ReferenceSearchResult {
-    type Item = Reference;
-    type IntoIter = std::vec::IntoIter<Reference>;
-
-    fn into_iter(mut self) -> Self::IntoIter {
-        let mut v = Vec::with_capacity(self.len());
-        v.push(Reference {
-            file_range: FileRange {
-                file_id: self.declaration.nav.file_id,
-                range: self.declaration.nav.focus_or_full_range(),
-            },
-            kind: self.declaration.kind,
-            access: self.declaration.access,
-        });
-        v.append(&mut self.references);
-        v.into_iter()
+    type Item = (FileId, Vec<FileReference>);
+    type IntoIter = std::collections::hash_map::IntoIter<FileId, Vec<FileReference>>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.references_with_declaration().into_iter()
     }
 }
 
@@ -109,13 +110,12 @@ pub(crate) fn find_all_refs(
 
     let RangeInfo { range, info: def } = find_name(&sema, &syntax, position, opt_name)?;
 
-    let references = def
-        .usages(sema)
-        .set_scope(search_scope)
-        .all()
-        .into_iter()
-        .filter(|r| search_kind == ReferenceKind::Other || search_kind == r.kind)
-        .collect();
+    let mut usages = def.usages(sema).set_scope(search_scope).all();
+    usages
+        .references
+        .values_mut()
+        .for_each(|it| it.retain(|r| search_kind == ReferenceKind::Other || search_kind == r.kind));
+    usages.references.retain(|_, it| !it.is_empty());
 
     let nav = def.try_to_nav(sema.db)?;
     let decl_range = nav.focus_or_full_range();
@@ -130,13 +130,16 @@ pub(crate) fn find_all_refs(
                 kind = ReferenceKind::FieldShorthandForLocal;
             }
         }
-    } else if matches!(def, Definition::LifetimeParam(_) | Definition::Label(_)) {
+    } else if matches!(
+        def,
+        Definition::GenericParam(hir::GenericParam::LifetimeParam(_)) | Definition::Label(_)
+    ) {
         kind = ReferenceKind::Lifetime;
     };
 
     let declaration = Declaration { nav, kind, access: decl_access(&def, &syntax, decl_range) };
 
-    Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references }))
+    Some(RangeInfo::new(range, ReferenceSearchResult { declaration, references: usages }))
 }
 
 fn find_name(
@@ -200,7 +203,7 @@ fn get_struct_def_name_for_struct_literal_search(
     position: FilePosition,
 ) -> Option<ast::Name> {
     if let TokenAtOffset::Between(ref left, ref right) = syntax.token_at_offset(position.offset) {
-        if right.kind() != SyntaxKind::L_CURLY && right.kind() != SyntaxKind::L_PAREN {
+        if right.kind() != T!['{'] && right.kind() != T!['('] {
             return None;
         }
         if let Some(name) =
@@ -227,7 +230,7 @@ fn get_enum_def_name_for_struct_literal_search(
     position: FilePosition,
 ) -> Option<ast::Name> {
     if let TokenAtOffset::Between(ref left, ref right) = syntax.token_at_offset(position.offset) {
-        if right.kind() != SyntaxKind::L_CURLY && right.kind() != SyntaxKind::L_PAREN {
+        if right.kind() != T!['{'] && right.kind() != T!['('] {
             return None;
         }
         if let Some(name) =
@@ -252,8 +255,8 @@ fn try_find_self_references(
     syntax: &SyntaxNode,
     position: FilePosition,
 ) -> Option<RangeInfo<ReferenceSearchResult>> {
-    let self_token =
-        syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)?;
+    let FilePosition { file_id, offset } = position;
+    let self_token = syntax.token_at_offset(offset).find(|t| t.kind() == T![self])?;
     let parent = self_token.parent();
     match_ast! {
         match parent {
@@ -274,7 +277,7 @@ fn try_find_self_references(
 
     let declaration = Declaration {
         nav: NavigationTarget {
-            file_id: position.file_id,
+            file_id,
             full_range: self_param.syntax().text_range(),
             focus_range: Some(param_self_token.text_range()),
             name: param_self_token.text().clone(),
@@ -290,7 +293,7 @@ fn try_find_self_references(
             ReferenceAccess::Read
         }),
     };
-    let references = function
+    let refs = function
         .body()
         .map(|body| {
             body.syntax()
@@ -304,14 +307,16 @@ fn try_find_self_references(
                         None
                     }
                 })
-                .map(|token| Reference {
-                    file_range: FileRange { file_id: position.file_id, range: token.text_range() },
+                .map(|token| FileReference {
+                    range: token.text_range(),
                     kind: ReferenceKind::SelfKw,
                     access: declaration.access, // FIXME: properly check access kind here instead of copying it from the declaration
                 })
                 .collect()
         })
         .unwrap_or_default();
+    let mut references = UsageSearchResult::default();
+    references.references.insert(file_id, refs);
 
     Some(RangeInfo::new(
         param_self_token.text_range(),
@@ -331,7 +336,7 @@ mod tests {
     fn test_struct_literal_after_space() {
         check(
             r#"
-struct Foo <|>{
+struct Foo $0{
     a: i32,
 }
 impl Foo {
@@ -354,7 +359,7 @@ fn main() {
     fn test_struct_literal_before_space() {
         check(
             r#"
-struct Foo<|> {}
+struct Foo$0 {}
     fn main() {
     let f: Foo;
     f = Foo {};
@@ -373,7 +378,7 @@ struct Foo<|> {}
     fn test_struct_literal_with_generic_type() {
         check(
             r#"
-struct Foo<T> <|>{}
+struct Foo<T> $0{}
     fn main() {
     let f: Foo::<i32>;
     f = Foo {};
@@ -391,7 +396,7 @@ struct Foo<T> <|>{}
     fn test_struct_literal_for_tuple() {
         check(
             r#"
-struct Foo<|>(i32);
+struct Foo$0(i32);
 
 fn main() {
     let f: Foo;
@@ -410,7 +415,7 @@ fn main() {
     fn test_enum_after_space() {
         check(
             r#"
-enum Foo <|>{
+enum Foo $0{
     A,
     B,
 }
@@ -431,7 +436,7 @@ fn main() {
     fn test_enum_before_space() {
         check(
             r#"
-enum Foo<|> {
+enum Foo$0 {
     A,
     B,
 }
@@ -453,7 +458,7 @@ fn main() {
     fn test_enum_with_generic_type() {
         check(
             r#"
-enum Foo<T> <|>{
+enum Foo<T> $0{
     A(T),
     B,
 }
@@ -474,7 +479,7 @@ fn main() {
     fn test_enum_for_tuple() {
         check(
             r#"
-enum Foo<|>{
+enum Foo$0{
     A(i8),
     B(i8),
 }
@@ -498,7 +503,7 @@ fn main() {
 fn main() {
     let mut i = 1;
     let j = 1;
-    i = i<|> + j;
+    i = i$0 + j;
 
     {
         i = 0;
@@ -522,7 +527,7 @@ fn main() {
         check(
             r#"
 fn foo() {
-    let spam<|> = 92;
+    let spam$0 = 92;
     spam + spam
 }
 fn bar() {
@@ -543,7 +548,7 @@ fn bar() {
     fn test_find_all_refs_for_param_inside() {
         check(
             r#"
-fn foo(i : u32) -> u32 { i<|> }
+fn foo(i : u32) -> u32 { i$0 }
 "#,
             expect![[r#"
                 i ValueParam FileId(0) 7..8 Other
@@ -557,7 +562,7 @@ fn foo(i : u32) -> u32 { i<|> }
     fn test_find_all_refs_for_fn_param() {
         check(
             r#"
-fn foo(i<|> : u32) -> u32 { i }
+fn foo(i$0 : u32) -> u32 { i }
 "#,
             expect![[r#"
                 i ValueParam FileId(0) 7..8 Other
@@ -573,7 +578,7 @@ fn foo(i<|> : u32) -> u32 { i }
             r#"
 //- /lib.rs
 struct Foo {
-    pub spam<|>: u32,
+    pub spam$0: u32,
 }
 
 fn main(s: Foo) {
@@ -594,7 +599,7 @@ fn main(s: Foo) {
             r#"
 struct Foo;
 impl Foo {
-    fn f<|>(&self) {  }
+    fn f$0(&self) {  }
 }
 "#,
             expect![[r#"
@@ -610,7 +615,7 @@ impl Foo {
             r#"
 enum Foo {
     A,
-    B<|>,
+    B$0,
     C,
 }
 "#,
@@ -627,7 +632,7 @@ enum Foo {
             r#"
 enum Foo {
     A,
-    B { field<|>: u8 },
+    B { field$0: u8 },
     C,
 }
 "#,
@@ -669,7 +674,7 @@ pub struct Bar {
 }
 
 fn f() {
-    let i = foo::Foo<|> { n: 5 };
+    let i = foo::Foo$0 { n: 5 };
 }
 "#,
             expect![[r#"
@@ -689,7 +694,7 @@ fn f() {
         check(
             r#"
 //- /lib.rs
-mod foo<|>;
+mod foo$0;
 
 use foo::Foo;
 
@@ -726,7 +731,7 @@ fn f() {
 }
 
 //- /foo/some.rs
-pub(super) struct Foo<|> {
+pub(super) struct Foo$0 {
     pub n: u32,
 }
 "#,
@@ -746,7 +751,7 @@ pub(super) struct Foo<|> {
             mod foo;
             mod bar;
 
-            pub fn quux<|>() {}
+            pub fn quux$0() {}
 
             //- /foo.rs
             fn f() { super::quux(); }
@@ -782,7 +787,7 @@ pub(super) struct Foo<|> {
         check(
             r#"
 #[macro_export]
-macro_rules! m1<|> { () => (()) }
+macro_rules! m1$0 { () => (()) }
 
 fn foo() {
     m1();
@@ -803,7 +808,7 @@ fn foo() {
         check(
             r#"
 fn foo() {
-    let mut i<|> = 0;
+    let mut i$0 = 0;
     i = i + 1;
 }
 "#,
@@ -826,7 +831,7 @@ struct S {
 
 fn foo() {
     let mut s = S{f: 0};
-    s.f<|> = 0;
+    s.f$0 = 0;
 }
 "#,
             expect![[r#"
@@ -843,7 +848,7 @@ fn foo() {
         check(
             r#"
 fn foo() {
-    let i<|>;
+    let i$0;
     i = 1;
 }
 "#,
@@ -863,7 +868,7 @@ mod foo {
     pub struct Foo;
 
     impl Foo {
-        pub fn new<|>() -> Foo { Foo }
+        pub fn new$0() -> Foo { Foo }
     }
 }
 
@@ -886,7 +891,7 @@ fn main() {
 //- /lib.rs
 mod foo { mod bar; }
 
-fn f<|>() {}
+fn f$0() {}
 
 //- /foo/bar.rs
 use crate::f;
@@ -907,7 +912,7 @@ fn g() { f(); }
         check(
             r#"
 struct S {
-    field<|>: u8,
+    field$0: u8,
 }
 
 fn f(s: S) {
@@ -930,7 +935,7 @@ fn f(s: S) {
             r#"
 enum En {
     Variant {
-        field<|>: u8,
+        field$0: u8,
     }
 }
 
@@ -955,7 +960,7 @@ fn f(e: En) {
 mod m {
     pub enum En {
         Variant {
-            field<|>: u8,
+            field$0: u8,
         }
     }
 }
@@ -980,7 +985,7 @@ struct Foo { bar: i32 }
 
 impl Foo {
     fn foo(self) {
-        let x = self<|>.bar;
+        let x = self$0.bar;
         if true {
             let _ = match () {
                 () => self,
@@ -1016,12 +1021,14 @@ impl Foo {
             actual += "\n\n";
         }
 
-        for r in &refs.references {
-            format_to!(actual, "{:?} {:?} {:?}", r.file_range.file_id, r.file_range.range, r.kind);
-            if let Some(access) = r.access {
-                format_to!(actual, " {:?}", access);
+        for (file_id, references) in refs.references {
+            for r in references {
+                format_to!(actual, "{:?} {:?} {:?}", file_id, r.range, r.kind);
+                if let Some(access) = r.access {
+                    format_to!(actual, " {:?}", access);
+                }
+                actual += "\n";
             }
-            actual += "\n";
         }
         expect.assert_eq(&actual)
     }
@@ -1032,7 +1039,7 @@ impl Foo {
             r#"
 trait Foo<'a> {}
 impl<'a> Foo<'a> for &'a () {}
-fn foo<'a, 'b: 'a>(x: &'a<|> ()) -> &'a () where &'a (): Foo<'a> {
+fn foo<'a, 'b: 'a>(x: &'a$0 ()) -> &'a () where &'a (): Foo<'a> {
     fn bar<'a>(_: &'a ()) {}
     x
 }
@@ -1053,7 +1060,7 @@ fn foo<'a, 'b: 'a>(x: &'a<|> ()) -> &'a () where &'a (): Foo<'a> {
     fn test_find_lifetimes_type_alias() {
         check(
             r#"
-type Foo<'a, T> where T: 'a<|> = &'a T;
+type Foo<'a, T> where T: 'a$0 = &'a T;
 "#,
             expect![[r#"
                 'a LifetimeParam FileId(0) 9..11 9..11 Lifetime
@@ -1072,7 +1079,7 @@ trait Foo<'a> {
     fn foo() -> &'a ();
 }
 impl<'a> Foo<'a> for &'a () {
-    fn foo() -> &'a<|> () {
+    fn foo() -> &'a$0 () {
         unimplemented!()
     }
 }
@@ -1093,7 +1100,7 @@ impl<'a> Foo<'a> for &'a () {
             r#"
 macro_rules! foo {($i:ident) => {$i} }
 fn main() {
-    let a<|> = "test";
+    let a$0 = "test";
     foo!(a);
 }
 "#,
@@ -1112,7 +1119,7 @@ fn main() {
 macro_rules! foo {($i:ident) => {$i} }
 fn main() {
     let a = "test";
-    foo!(a<|>);
+    foo!(a$0);
 }
 "#,
             expect![[r#"
@@ -1130,7 +1137,7 @@ fn main() {
 fn foo<'a>() -> &'a () {
     'a: loop {
         'b: loop {
-            continue 'a<|>;
+            continue 'a$0;
         }
         break 'a;
     }
@@ -1149,7 +1156,7 @@ fn foo<'a>() -> &'a () {
     fn test_find_const_param() {
         check(
             r#"
-fn foo<const FOO<|>: usize>() -> usize {
+fn foo<const FOO$0: usize>() -> usize {
     FOO
 }
 "#,
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 854bf194e..c3ae568c2 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -1,29 +1,30 @@
 //! FIXME: write short doc here
 use std::{
     convert::TryInto,
-    error::Error,
     fmt::{self, Display},
 };
 
 use hir::{Module, ModuleDef, ModuleSource, Semantics};
-use ide_db::base_db::{AnchoredPathBuf, FileId, FileRange, SourceDatabaseExt};
 use ide_db::{
+    base_db::{AnchoredPathBuf, FileId, FileRange, SourceDatabaseExt},
     defs::{Definition, NameClass, NameRefClass},
+    search::FileReference,
     RootDatabase,
 };
 use syntax::{
     algo::find_node_at_offset,
     ast::{self, NameOwner},
-    lex_single_syntax_kind, match_ast, AstNode, SyntaxKind, SyntaxNode, SyntaxToken,
+    lex_single_syntax_kind, match_ast, AstNode, SyntaxKind, SyntaxNode, SyntaxToken, T,
 };
 use test_utils::mark;
 use text_edit::TextEdit;
 
 use crate::{
-    references::find_all_refs, FilePosition, FileSystemEdit, RangeInfo, Reference, ReferenceKind,
-    SourceChange, SourceFileEdit, TextRange, TextSize,
+    FilePosition, FileSystemEdit, RangeInfo, ReferenceKind, ReferenceSearchResult, SourceChange,
+    SourceFileEdit, TextRange, TextSize,
 };
 
+type RenameResult<T> = Result<T, RenameError>;
 #[derive(Debug)]
 pub struct RenameError(pub(crate) String);
 
@@ -33,26 +34,30 @@ impl fmt::Display for RenameError {
     }
 }
 
-impl Error for RenameError {}
+macro_rules! format_err {
+    ($fmt:expr) => {RenameError(format!($fmt))};
+    ($fmt:expr, $($arg:tt)+) => {RenameError(format!($fmt, $($arg)+))}
+}
+
+macro_rules! bail {
+    ($($tokens:tt)*) => {return Err(format_err!($($tokens)*))}
+}
 
 pub(crate) fn prepare_rename(
     db: &RootDatabase,
     position: FilePosition,
-) -> Result<RangeInfo<()>, RenameError> {
+) -> RenameResult<RangeInfo<()>> {
     let sema = Semantics::new(db);
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax();
     if let Some(module) = find_module_at_offset(&sema, position, syntax) {
         rename_mod(&sema, position, module, "dummy")
     } else if let Some(self_token) =
-        syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
+        syntax.token_at_offset(position.offset).find(|t| t.kind() == T![self])
     {
         rename_self_to_param(&sema, position, self_token, "dummy")
     } else {
-        let range = match find_all_refs(&sema, position, None) {
-            Some(RangeInfo { range, .. }) => range,
-            None => return Err(RenameError("No references found at position".to_string())),
-        };
+        let RangeInfo { range, .. } = find_all_refs(&sema, position)?;
         Ok(RangeInfo::new(range, SourceChange::from(vec![])))
     }
     .map(|info| RangeInfo::new(info.range, ()))
@@ -62,7 +67,7 @@ pub(crate) fn rename(
     db: &RootDatabase,
     position: FilePosition,
     new_name: &str,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
+) -> RenameResult<RangeInfo<SourceChange>> {
     let sema = Semantics::new(db);
     rename_with_semantics(&sema, position, new_name)
 }
@@ -71,42 +76,18 @@ pub(crate) fn rename_with_semantics(
     sema: &Semantics<RootDatabase>,
     position: FilePosition,
     new_name: &str,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
-    let is_lifetime_name = match lex_single_syntax_kind(new_name) {
-        Some(res) => match res {
-            (SyntaxKind::IDENT, _) => false,
-            (SyntaxKind::UNDERSCORE, _) => false,
-            (SyntaxKind::SELF_KW, _) => return rename_to_self(&sema, position),
-            (SyntaxKind::LIFETIME_IDENT, _) if new_name != "'static" && new_name != "'_" => true,
-            (SyntaxKind::LIFETIME_IDENT, _) => {
-                return Err(RenameError(format!(
-                    "Invalid name `{0}`: Cannot rename lifetime to {0}",
-                    new_name
-                )))
-            }
-            (_, 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))),
-    };
-
+) -> RenameResult<RangeInfo<SourceChange>> {
     let source_file = sema.parse(position.file_id);
     let syntax = source_file.syntax();
-    // this is here to prevent lifetime renames from happening on modules and self
-    if is_lifetime_name {
-        rename_reference(&sema, position, new_name, is_lifetime_name)
-    } else if let Some(module) = find_module_at_offset(&sema, position, syntax) {
+
+    if let Some(module) = find_module_at_offset(&sema, position, syntax) {
         rename_mod(&sema, position, module, new_name)
     } else if let Some(self_token) =
-        syntax.token_at_offset(position.offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
+        syntax.token_at_offset(position.offset).find(|t| t.kind() == T![self])
     {
         rename_self_to_param(&sema, position, self_token, new_name)
     } else {
-        rename_reference(&sema, position, new_name, is_lifetime_name)
+        rename_reference(&sema, position, new_name)
     }
 }
 
@@ -127,6 +108,33 @@ pub(crate) fn will_rename_file(
     Some(change)
 }
 
+#[derive(Debug, PartialEq)]
+enum IdentifierKind {
+    Ident,
+    Lifetime,
+    ToSelf,
+    Underscore,
+}
+
+fn check_identifier(new_name: &str) -> RenameResult<IdentifierKind> {
+    match lex_single_syntax_kind(new_name) {
+        Some(res) => match res {
+            (SyntaxKind::IDENT, _) => Ok(IdentifierKind::Ident),
+            (T![_], _) => Ok(IdentifierKind::Underscore),
+            (T![self], _) => Ok(IdentifierKind::ToSelf),
+            (SyntaxKind::LIFETIME_IDENT, _) if new_name != "'static" && new_name != "'_" => {
+                Ok(IdentifierKind::Lifetime)
+            }
+            (SyntaxKind::LIFETIME_IDENT, _) => {
+                bail!("Invalid name `{0}`: Cannot rename lifetime to {0}", new_name)
+            }
+            (_, Some(syntax_error)) => bail!("Invalid name `{}`: {}", new_name, syntax_error),
+            (_, None) => bail!("Invalid name `{}`: not an identifier", new_name),
+        },
+        None => bail!("Invalid name `{}`: not an identifier", new_name),
+    }
+}
+
 fn find_module_at_offset(
     sema: &Semantics<RootDatabase>,
     position: FilePosition,
@@ -155,39 +163,54 @@ fn find_module_at_offset(
     Some(module)
 }
 
-fn source_edit_from_reference(
+fn find_all_refs(
+    sema: &Semantics<RootDatabase>,
+    position: FilePosition,
+) -> RenameResult<RangeInfo<ReferenceSearchResult>> {
+    crate::references::find_all_refs(sema, position, None)
+        .ok_or_else(|| format_err!("No references found at position"))
+}
+
+fn source_edit_from_references(
     sema: &Semantics<RootDatabase>,
-    reference: Reference,
+    file_id: FileId,
+    references: &[FileReference],
     new_name: &str,
 ) -> SourceFileEdit {
-    let mut replacement_text = String::new();
-    let range = match reference.kind {
-        ReferenceKind::FieldShorthandForField => {
-            mark::hit!(test_rename_struct_field_for_shorthand);
-            replacement_text.push_str(new_name);
-            replacement_text.push_str(": ");
-            TextRange::new(reference.file_range.range.start(), reference.file_range.range.start())
-        }
-        ReferenceKind::FieldShorthandForLocal => {
-            mark::hit!(test_rename_local_for_field_shorthand);
-            replacement_text.push_str(": ");
-            replacement_text.push_str(new_name);
-            TextRange::new(reference.file_range.range.end(), reference.file_range.range.end())
-        }
-        ReferenceKind::RecordFieldExprOrPat => {
-            mark::hit!(test_rename_field_expr_pat);
-            replacement_text.push_str(new_name);
-            edit_text_range_for_record_field_expr_or_pat(sema, reference.file_range, new_name)
-        }
-        _ => {
-            replacement_text.push_str(new_name);
-            reference.file_range.range
-        }
-    };
-    SourceFileEdit {
-        file_id: reference.file_range.file_id,
-        edit: TextEdit::replace(range, replacement_text),
+    let mut edit = TextEdit::builder();
+    for reference in references {
+        let mut replacement_text = String::new();
+        let range = match reference.kind {
+            ReferenceKind::FieldShorthandForField => {
+                mark::hit!(test_rename_struct_field_for_shorthand);
+                replacement_text.push_str(new_name);
+                replacement_text.push_str(": ");
+                TextRange::new(reference.range.start(), reference.range.start())
+            }
+            ReferenceKind::FieldShorthandForLocal => {
+                mark::hit!(test_rename_local_for_field_shorthand);
+                replacement_text.push_str(": ");
+                replacement_text.push_str(new_name);
+                TextRange::new(reference.range.end(), reference.range.end())
+            }
+            ReferenceKind::RecordFieldExprOrPat => {
+                mark::hit!(test_rename_field_expr_pat);
+                replacement_text.push_str(new_name);
+                edit_text_range_for_record_field_expr_or_pat(
+                    sema,
+                    FileRange { file_id, range: reference.range },
+                    new_name,
+                )
+            }
+            _ => {
+                replacement_text.push_str(new_name);
+                reference.range
+            }
+        };
+        edit.replace(range, replacement_text);
     }
+
+    SourceFileEdit { file_id, edit: edit.finish() }
 }
 
 fn edit_text_range_for_record_field_expr_or_pat(
@@ -223,7 +246,10 @@ fn rename_mod(
     position: FilePosition,
     module: Module,
     new_name: &str,
-) -> Result<RangeInfo<SourceChange>, RenameError> {
+) -> RenameResult<RangeInfo<SourceChange>> {
+    if IdentifierKind::Ident != check_identifier(new_name)? {
+        bail!("Invalid name `{0}`: cannot rename module to {0}", new_name);
+    }
     let mut source_file_edits = Vec::new();
     let mut file_system_edits = Vec::new();
 
@@ -254,12 +280,10 @@ fn rename_mod(
         source_file_edits.push(edit);
     }
 
-    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(sema, reference, new_name));
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
+    let ref_edits = refs.references().iter().map(|(&file_id, references)| {
+        source_edit_from_references(sema, file_id, references, new_name)
+    });
     source_file_edits.extend(ref_edits);
 
     Ok(RangeInfo::new(range, SourceChange::from_edits(source_file_edits, file_system_edits)))
@@ -274,27 +298,26 @@ fn rename_to_self(
 
     let (fn_def, fn_ast) = find_node_at_offset::<ast::Fn>(syn, position.offset)
         .and_then(|fn_ast| sema.to_def(&fn_ast).zip(Some(fn_ast)))
-        .ok_or_else(|| RenameError("No surrounding method declaration found".to_string()))?;
+        .ok_or_else(|| format_err!("No surrounding method declaration found"))?;
     let param_range = fn_ast
         .param_list()
         .and_then(|p| p.params().next())
-        .ok_or_else(|| RenameError("Method has no parameters".to_string()))?
+        .ok_or_else(|| format_err!("Method has no parameters"))?
         .syntax()
         .text_range();
     if !param_range.contains(position.offset) {
-        return Err(RenameError("Only the first parameter can be self".to_string()));
+        bail!("Only the first parameter can be self");
     }
 
     let impl_block = find_node_at_offset::<ast::Impl>(syn, position.offset)
         .and_then(|def| sema.to_def(&def))
-        .ok_or_else(|| RenameError("No impl block found for function".to_string()))?;
+        .ok_or_else(|| format_err!("No impl block found for function"))?;
     if fn_def.self_param(sema.db).is_some() {
-        return Err(RenameError("Method already has a self parameter".to_string()));
+        bail!("Method already has a self parameter");
     }
 
     let params = fn_def.assoc_fn_params(sema.db);
-    let first_param =
-        params.first().ok_or_else(|| RenameError("Method has no parameters".into()))?;
+    let first_param = params.first().ok_or_else(|| format_err!("Method has no parameters"))?;
     let first_param_ty = first_param.ty();
     let impl_ty = impl_block.target_ty(sema.db);
     let (ty, self_param) = if impl_ty.remove_ref().is_some() {
@@ -307,23 +330,17 @@ fn rename_to_self(
     };
 
     if ty != impl_ty {
-        return Err(RenameError("Parameter type differs from impl block type".to_string()));
+        bail!("Parameter type differs from impl block type");
     }
 
-    let RangeInfo { range, info: refs } = find_all_refs(sema, position, None)
-        .ok_or_else(|| RenameError("No reference found at position".to_string()))?;
-
-    let (param_ref, usages): (Vec<Reference>, Vec<Reference>) = refs
-        .into_iter()
-        .partition(|reference| param_range.intersect(reference.file_range.range).is_some());
-
-    if param_ref.is_empty() {
-        return Err(RenameError("Parameter to rename not found".to_string()));
-    }
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
 
-    let mut edits = usages
-        .into_iter()
-        .map(|reference| source_edit_from_reference(sema, reference, "self"))
+    let mut edits = refs
+        .references()
+        .iter()
+        .map(|(&file_id, references)| {
+            source_edit_from_references(sema, file_id, references, "self")
+        })
         .collect::<Vec<_>>();
 
     edits.push(SourceFileEdit {
@@ -367,12 +384,22 @@ fn rename_self_to_param(
     self_token: SyntaxToken,
     new_name: &str,
 ) -> Result<RangeInfo<SourceChange>, RenameError> {
+    let ident_kind = check_identifier(new_name)?;
+    match ident_kind {
+        IdentifierKind::Lifetime => bail!("Invalid name `{}`: not an identifier", new_name),
+        IdentifierKind::ToSelf => {
+            // no-op
+            mark::hit!(rename_self_to_self);
+            return Ok(RangeInfo::new(self_token.text_range(), SourceChange::default()));
+        }
+        _ => (),
+    }
     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)
-        .ok_or_else(|| RenameError("No surrounding method declaration found".to_string()))?;
+        .ok_or_else(|| format_err!("No surrounding method declaration found"))?;
     let search_range = fn_def.syntax().text_range();
 
     let mut edits: Vec<SourceFileEdit> = vec![];
@@ -382,12 +409,10 @@ fn rename_self_to_param(
         if !search_range.contains_inclusive(offset) {
             continue;
         }
-        if let Some(ref usage) =
-            syn.token_at_offset(offset).find(|t| t.kind() == SyntaxKind::SELF_KW)
-        {
+        if let Some(ref usage) = syn.token_at_offset(offset).find(|t| t.kind() == T![self]) {
             let edit = if let Some(ref self_param) = ast::SelfParam::cast(usage.parent()) {
                 text_edit_from_self_param(syn, self_param, new_name)
-                    .ok_or_else(|| RenameError("No target type found".to_string()))?
+                    .ok_or_else(|| format_err!("No target type found"))?
             } else {
                 TextEdit::replace(usage.text_range(), String::from(new_name))
             };
@@ -395,6 +420,10 @@ fn rename_self_to_param(
         }
     }
 
+    if edits.len() > 1 && ident_kind == IdentifierKind::Underscore {
+        bail!("Cannot rename reference to `_` as it is being referenced multiple times");
+    }
+
     let range = ast::SelfParam::cast(self_token.parent())
         .map_or(self_token.text_range(), |p| p.syntax().text_range());
 
@@ -405,35 +434,43 @@ fn rename_reference(
     sema: &Semantics<RootDatabase>,
     position: FilePosition,
     new_name: &str,
-    is_lifetime_name: bool,
 ) -> 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())),
-    };
-
-    match (refs.declaration.kind == ReferenceKind::Lifetime, is_lifetime_name) {
-        (true, false) => {
-            return Err(RenameError(format!(
-                "Invalid name `{}`: not a lifetime identifier",
-                new_name
-            )))
+    let ident_kind = check_identifier(new_name)?;
+    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
+
+    match (ident_kind, &refs.declaration.kind) {
+        (IdentifierKind::ToSelf, ReferenceKind::Lifetime)
+        | (IdentifierKind::Underscore, ReferenceKind::Lifetime)
+        | (IdentifierKind::Ident, ReferenceKind::Lifetime) => {
+            mark::hit!(rename_not_a_lifetime_ident_ref);
+            bail!("Invalid name `{}`: not a lifetime identifier", new_name)
         }
-        (false, true) => {
-            return Err(RenameError(format!("Invalid name `{}`: not an identifier", new_name)))
+        (IdentifierKind::Lifetime, ReferenceKind::Lifetime) => mark::hit!(rename_lifetime),
+        (IdentifierKind::Lifetime, _) => {
+            mark::hit!(rename_not_an_ident_ref);
+            bail!("Invalid name `{}`: not an identifier", new_name)
         }
-        _ => (),
+        (IdentifierKind::ToSelf, ReferenceKind::SelfKw) => {
+            unreachable!("rename_self_to_param should've been called instead")
+        }
+        (IdentifierKind::ToSelf, _) => {
+            mark::hit!(rename_to_self);
+            return rename_to_self(sema, position);
+        }
+        (IdentifierKind::Underscore, _) if !refs.references.is_empty() => {
+            mark::hit!(rename_underscore_multiple);
+            bail!("Cannot rename reference to `_` as it is being referenced multiple times")
+        }
+        (IdentifierKind::Ident, _) | (IdentifierKind::Underscore, _) => mark::hit!(rename_ident),
     }
 
     let edit = refs
         .into_iter()
-        .map(|reference| source_edit_from_reference(sema, reference, new_name))
+        .map(|(file_id, references)| {
+            source_edit_from_references(sema, file_id, &references, new_name)
+        })
         .collect::<Vec<_>>();
 
-    if edit.is_empty() {
-        return Err(RenameError("No references found at position".to_string()));
-    }
-
     Ok(RangeInfo::new(range, SourceChange::from(edit)))
 }
 
@@ -462,9 +499,11 @@ mod tests {
                         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);
+                if let Some(file_id) = file_id {
+                    let mut result = analysis.file_text(file_id).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:") {
@@ -493,19 +532,19 @@ mod tests {
 
     #[test]
     fn test_rename_to_underscore() {
-        check("_", r#"fn main() { let i<|> = 1; }"#, r#"fn main() { let _ = 1; }"#);
+        check("_", r#"fn main() { let i$0 = 1; }"#, r#"fn main() { let _ = 1; }"#);
     }
 
     #[test]
     fn test_rename_to_raw_identifier() {
-        check("r#fn", r#"fn main() { let i<|> = 1; }"#, r#"fn main() { let r#fn = 1; }"#);
+        check("r#fn", r#"fn main() { let i$0 = 1; }"#, r#"fn main() { let r#fn = 1; }"#);
     }
 
     #[test]
     fn test_rename_to_invalid_identifier1() {
         check(
             "invalid!",
-            r#"fn main() { let i<|> = 1; }"#,
+            r#"fn main() { let i$0 = 1; }"#,
             "error: Invalid name `invalid!`: not an identifier",
         );
     }
@@ -514,7 +553,7 @@ mod tests {
     fn test_rename_to_invalid_identifier2() {
         check(
             "multiple tokens",
-            r#"fn main() { let i<|> = 1; }"#,
+            r#"fn main() { let i$0 = 1; }"#,
             "error: Invalid name `multiple tokens`: not an identifier",
         );
     }
@@ -523,38 +562,60 @@ mod tests {
     fn test_rename_to_invalid_identifier3() {
         check(
             "let",
-            r#"fn main() { let i<|> = 1; }"#,
+            r#"fn main() { let i$0 = 1; }"#,
             "error: Invalid name `let`: not an identifier",
         );
     }
 
     #[test]
     fn test_rename_to_invalid_identifier_lifetime() {
+        mark::check!(rename_not_an_ident_ref);
         check(
             "'foo",
-            r#"fn main() { let i<|> = 1; }"#,
+            r#"fn main() { let i$0 = 1; }"#,
             "error: Invalid name `'foo`: not an identifier",
         );
     }
 
     #[test]
     fn test_rename_to_invalid_identifier_lifetime2() {
+        mark::check!(rename_not_a_lifetime_ident_ref);
         check(
             "foo",
-            r#"fn main<'a>(_: &'a<|> ()) {}"#,
+            r#"fn main<'a>(_: &'a$0 ()) {}"#,
             "error: Invalid name `foo`: not a lifetime identifier",
         );
     }
 
     #[test]
+    fn test_rename_to_underscore_invalid() {
+        mark::check!(rename_underscore_multiple);
+        check(
+            "_",
+            r#"fn main(foo$0: ()) {foo;}"#,
+            "error: Cannot rename reference to `_` as it is being referenced multiple times",
+        );
+    }
+
+    #[test]
+    fn test_rename_mod_invalid() {
+        check(
+            "'foo",
+            r#"mod foo$0 {}"#,
+            "error: Invalid name `'foo`: cannot rename module to 'foo",
+        );
+    }
+
+    #[test]
     fn test_rename_for_local() {
+        mark::check!(rename_ident);
         check(
             "k",
             r#"
 fn main() {
     let mut i = 1;
     let j = 1;
-    i = i<|> + j;
+    i = i$0 + j;
 
     { i = 0; }
 
@@ -579,7 +640,7 @@ fn main() {
     fn test_rename_unresolved_reference() {
         check(
             "new_name",
-            r#"fn main() { let _ = unresolved_ref<|>; }"#,
+            r#"fn main() { let _ = unresolved_ref$0; }"#,
             "error: No references found at position",
         );
     }
@@ -591,7 +652,7 @@ fn main() {
             r#"
 macro_rules! foo {($i:ident) => {$i} }
 fn main() {
-    let a<|> = "test";
+    let a$0 = "test";
     foo!(a);
 }
 "#,
@@ -613,7 +674,7 @@ fn main() {
 macro_rules! foo {($i:ident) => {$i} }
 fn main() {
     let a = "test";
-    foo!(a<|>);
+    foo!(a$0);
 }
 "#,
             r#"
@@ -634,7 +695,7 @@ fn main() {
 macro_rules! define_fn {($id:ident) => { fn $id{} }}
 define_fn!(foo);
 fn main() {
-    fo<|>o();
+    fo$0o();
 }
 "#,
             r#"
@@ -653,7 +714,7 @@ fn main() {
             "bar",
             r#"
 macro_rules! define_fn {($id:ident) => { fn $id{} }}
-define_fn!(fo<|>o);
+define_fn!(fo$0o);
 fn main() {
     foo();
 }
@@ -670,17 +731,17 @@ fn main() {
 
     #[test]
     fn test_rename_for_param_inside() {
-        check("j", r#"fn foo(i : u32) -> u32 { i<|> }"#, r#"fn foo(j : u32) -> u32 { j }"#);
+        check("j", r#"fn foo(i : u32) -> u32 { i$0 }"#, r#"fn foo(j : u32) -> u32 { j }"#);
     }
 
     #[test]
     fn test_rename_refs_for_fn_param() {
-        check("j", r#"fn foo(i<|> : u32) -> u32 { i }"#, r#"fn foo(j : u32) -> u32 { j }"#);
+        check("j", r#"fn foo(i$0 : u32) -> u32 { i }"#, r#"fn foo(j : u32) -> u32 { j }"#);
     }
 
     #[test]
     fn test_rename_for_mut_param() {
-        check("j", r#"fn foo(mut i<|> : u32) -> u32 { i }"#, r#"fn foo(mut j : u32) -> u32 { j }"#);
+        check("j", r#"fn foo(mut i$0 : u32) -> u32 { i }"#, r#"fn foo(mut j : u32) -> u32 { j }"#);
     }
 
     #[test]
@@ -688,7 +749,7 @@ fn main() {
         check(
             "j",
             r#"
-struct Foo { i<|>: i32 }
+struct Foo { i$0: i32 }
 
 impl Foo {
     fn new(i: i32) -> Self {
@@ -714,7 +775,7 @@ impl Foo {
         check(
             "j",
             r#"
-struct Foo { i<|>: i32 }
+struct Foo { i$0: i32 }
 
 impl Foo {
     fn new(i: i32) -> Self {
@@ -743,7 +804,7 @@ impl Foo {
 struct Foo { i: i32 }
 
 impl Foo {
-    fn new(i<|>: i32) -> Self {
+    fn new(i$0: i32) -> Self {
         Self { i }
     }
 }
@@ -765,7 +826,7 @@ impl Foo {
         check(
             "j",
             r#"
-struct Foo { i<|>: i32 }
+struct Foo { i$0: i32 }
 struct Bar { i: i32 }
 
 impl Bar {
@@ -794,7 +855,7 @@ impl Bar {
             r#"
 struct Foo { i: i32 }
 
-fn baz(i<|>: i32) -> Self {
+fn baz(i$0: i32) -> Self {
      let x = Foo { i };
      {
          let i = 0;
@@ -825,7 +886,7 @@ fn baz(j: i32) -> Self {
 mod bar;
 
 //- /bar.rs
-mod foo<|>;
+mod foo$0;
 
 //- /bar/foo.rs
 // empty
@@ -883,7 +944,7 @@ fn main() {}
 pub struct FooContent;
 
 //- /bar.rs
-use crate::foo<|>::FooContent;
+use crate::foo$0::FooContent;
 "#,
             expect![[r#"
                 RangeInfo {
@@ -943,9 +1004,9 @@ use crate::foo<|>::FooContent;
             "foo2",
             r#"
 //- /lib.rs
-mod fo<|>o;
+mod fo$0o;
 //- /foo/mod.rs
-// emtpy
+// empty
 "#,
             expect![[r#"
                 RangeInfo {
@@ -992,10 +1053,10 @@ mod fo<|>o;
             "bar",
             r#"
 //- /lib.rs
-mod outer { mod fo<|>o; }
+mod outer { mod fo$0o; }
 
 //- /outer/foo.rs
-// emtpy
+// empty
 "#,
             expect![[r#"
                 RangeInfo {
@@ -1041,7 +1102,7 @@ mod outer { mod fo<|>o; }
         check(
             "baz",
             r#"
-mod <|>foo { pub fn bar() {} }
+mod $0foo { pub fn bar() {} }
 
 fn main() { foo::bar(); }
 "#,
@@ -1065,7 +1126,7 @@ fn f() {
 }
 
 //- /bar.rs
-pub mod foo<|>;
+pub mod foo$0;
 
 //- /bar/foo.rs
 // pub fn fun() {}
@@ -1128,7 +1189,7 @@ pub mod foo<|>;
             "Baz",
             r#"
 mod foo {
-    pub enum Foo { Bar<|> }
+    pub enum Foo { Bar$0 }
 }
 
 fn func(f: foo::Foo) {
@@ -1157,7 +1218,7 @@ fn func(f: foo::Foo) {
             "baz",
             r#"
 mod foo {
-    pub struct Foo { pub bar<|>: uint }
+    pub struct Foo { pub bar$0: uint }
 }
 
 fn foo(f: foo::Foo) {
@@ -1178,13 +1239,14 @@ fn foo(f: foo::Foo) {
 
     #[test]
     fn test_parameter_to_self() {
+        mark::check!(rename_to_self);
         check(
             "self",
             r#"
 struct Foo { i: i32 }
 
 impl Foo {
-    fn f(foo<|>: &mut Foo) -> i32 {
+    fn f(foo$0: &mut Foo) -> i32 {
         foo.i
     }
 }
@@ -1205,7 +1267,7 @@ impl Foo {
 struct Foo { i: i32 }
 
 impl Foo {
-    fn f(foo<|>: Foo) -> i32 {
+    fn f(foo$0: Foo) -> i32 {
         foo.i
     }
 }
@@ -1229,7 +1291,7 @@ impl Foo {
             r#"
 struct Foo { i: i32 }
 
-fn f(foo<|>: &mut Foo) -> i32 {
+fn f(foo$0: &mut Foo) -> i32 {
     foo.i
 }
 "#,
@@ -1242,7 +1304,7 @@ struct Foo { i: i32 }
 struct Bar;
 
 impl Bar {
-    fn f(foo<|>: &mut Foo) -> i32 {
+    fn f(foo$0: &mut Foo) -> i32 {
         foo.i
     }
 }
@@ -1258,7 +1320,7 @@ impl Bar {
             r#"
 struct Foo { i: i32 }
 impl Foo {
-    fn f(x: (), foo<|>: &mut Foo) -> i32 {
+    fn f(x: (), foo$0: &mut Foo) -> i32 {
         foo.i
     }
 }
@@ -1274,7 +1336,7 @@ impl Foo {
             r#"
 struct Foo { i: i32 }
 impl &Foo {
-    fn f(foo<|>: &Foo) -> i32 {
+    fn f(foo$0: &Foo) -> i32 {
         foo.i
     }
 }
@@ -1298,7 +1360,7 @@ impl &Foo {
 struct Foo { i: i32 }
 
 impl Foo {
-    fn f(&mut <|>self) -> i32 {
+    fn f(&mut $0self) -> i32 {
         self.i
     }
 }
@@ -1323,7 +1385,7 @@ impl Foo {
 struct Foo { i: i32 }
 
 impl Foo {
-    fn f(<|>self) -> i32 {
+    fn f($0self) -> i32 {
         self.i
     }
 }
@@ -1350,7 +1412,7 @@ struct Foo { i: i32 }
 impl Foo {
     fn f(&self) -> i32 {
         let self_var = 1;
-        self<|>.i
+        self$0.i
     }
 }
 "#,
@@ -1373,7 +1435,7 @@ impl Foo {
         check(
             "bar",
             r#"
-struct Foo { i<|>: i32 }
+struct Foo { i$0: i32 }
 
 fn foo(bar: i32) -> Foo {
     Foo { i: bar }
@@ -1394,7 +1456,7 @@ fn foo(bar: i32) -> Foo {
         check(
             "baz",
             r#"
-struct Foo { i<|>: i32 }
+struct Foo { i$0: i32 }
 
 fn foo(foo: Foo) {
     let Foo { i: baz } = foo;
@@ -1433,7 +1495,7 @@ struct Foo {
 
 fn foo(foo: Foo) {
     let Foo { i: b } = foo;
-    let _ = b<|>;
+    let _ = b$0;
 }
 "#,
             expected_fixture,
@@ -1447,7 +1509,7 @@ struct Foo {
 
 fn foo(foo: Foo) {
     let Foo { i } = foo;
-    let _ = i<|>;
+    let _ = i$0;
 }
 "#,
             expected_fixture,
@@ -1464,7 +1526,7 @@ struct Foo {
 }
 
 fn foo(Foo { i }: foo) -> i32 {
-    i<|>
+    i$0
 }
 "#,
             r#"
@@ -1481,6 +1543,7 @@ fn foo(Foo { i: bar }: foo) -> i32 {
 
     #[test]
     fn test_rename_lifetimes() {
+        mark::check!(rename_lifetime);
         check(
             "'yeeee",
             r#"
@@ -1488,7 +1551,7 @@ trait Foo<'a> {
     fn foo() -> &'a ();
 }
 impl<'a> Foo<'a> for &'a () {
-    fn foo() -> &'a<|> () {
+    fn foo() -> &'a$0 () {
         unimplemented!()
     }
 }
@@ -1520,7 +1583,7 @@ fn main() {
     let test_variable = CustomOption::Some(22);
 
     match test_variable {
-        CustomOption::Some(foo<|>) if foo == 11 => {}
+        CustomOption::Some(foo$0) if foo == 11 => {}
         _ => (),
     }
 }"#,
@@ -1549,7 +1612,7 @@ fn main() {
 fn foo<'a>() -> &'a () {
     'a: {
         'b: loop {
-            break 'a<|>;
+            break 'a$0;
         }
     }
 }
@@ -1565,4 +1628,24 @@ fn foo<'a>() -> &'a () {
 "#,
         )
     }
+
+    #[test]
+    fn test_self_to_self() {
+        mark::check!(rename_self_to_self);
+        check(
+            "self",
+            r#"
+struct Foo;
+impl Foo {
+    fn foo(self$0) {}
+}
+"#,
+            r#"
+struct Foo;
+impl Foo {
+    fn foo(self) {}
+}
+"#,
+        )
+    }
 }
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index c893afc7c..f5ee7de86 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -2,11 +2,11 @@ use std::fmt;
 
 use assists::utils::test_related_attribute;
 use cfg::CfgExpr;
-use hir::{AsAssocItem, HasAttrs, InFile, Semantics};
-use ide_db::RootDatabase;
+use hir::{AsAssocItem, HasAttrs, HasSource, Semantics};
+use ide_db::{defs::Definition, RootDatabase};
 use itertools::Itertools;
 use syntax::{
-    ast::{self, AstNode, AttrsOwner, ModuleItemOwner, NameOwner},
+    ast::{self, AstNode, AttrsOwner, ModuleItemOwner},
     match_ast, SyntaxNode,
 };
 
@@ -96,41 +96,45 @@ impl Runnable {
 pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Vec<Runnable> {
     let sema = Semantics::new(db);
     let source_file = sema.parse(file_id);
-    source_file.syntax().descendants().filter_map(|i| runnable(&sema, i, file_id)).collect()
-}
-
-pub(crate) fn runnable(
-    sema: &Semantics<RootDatabase>,
-    item: SyntaxNode,
-    file_id: FileId,
-) -> Option<Runnable> {
-    let runnable_item = match_ast! {
-        match (item.clone()) {
-            ast::Fn(it) => runnable_fn(sema, it, file_id),
-            ast::Module(it) => runnable_mod(sema, it),
-            _ => None,
-        }
-    };
-    runnable_item.or_else(|| runnable_doctest(sema, item))
+    source_file
+        .syntax()
+        .descendants()
+        .filter_map(|item| {
+            let runnable = match_ast! {
+                match item {
+                    ast::Fn(func) => {
+                        let def = sema.to_def(&func)?;
+                        runnable_fn(&sema, def)
+                    },
+                    ast::Module(it) => runnable_mod(&sema, it),
+                    _ => None,
+                }
+            };
+            runnable.or_else(|| match doc_owner_to_def(&sema, item)? {
+                Definition::ModuleDef(def) => module_def_doctest(&sema, def),
+                _ => None,
+            })
+        })
+        .collect()
 }
 
-fn runnable_fn(sema: &Semantics<RootDatabase>, func: ast::Fn, file_id: FileId) -> Option<Runnable> {
-    let def = sema.to_def(&func)?;
-    let name_string = func.name()?.text().to_string();
+pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) -> Option<Runnable> {
+    let func = def.source(sema.db)?;
+    let name_string = def.name(sema.db).to_string();
 
     let kind = if name_string == "main" {
         RunnableKind::Bin
     } else {
-        let canonical_path = sema.to_def(&func).and_then(|def| {
+        let canonical_path = {
             let def: hir::ModuleDef = def.into();
             def.canonical_path(sema.db)
-        });
+        };
         let test_id = canonical_path.map(TestId::Path).unwrap_or(TestId::Name(name_string));
 
-        if test_related_attribute(&func).is_some() {
-            let attr = TestAttr::from_fn(&func);
+        if test_related_attribute(&func.value).is_some() {
+            let attr = TestAttr::from_fn(&func.value);
             RunnableKind::Test { test_id, attr }
-        } else if func.has_atom_attr("bench") {
+        } else if func.value.has_atom_attr("bench") {
             RunnableKind::Bench { test_id }
         } else {
             return None;
@@ -139,27 +143,56 @@ fn runnable_fn(sema: &Semantics<RootDatabase>, func: ast::Fn, file_id: FileId) -
 
     let nav = NavigationTarget::from_named(
         sema.db,
-        InFile::new(file_id.into(), &func),
+        func.as_ref().map(|it| it as &dyn ast::NameOwner),
         SymbolKind::Function,
     );
     let cfg = def.attrs(sema.db).cfg();
     Some(Runnable { nav, kind, cfg })
 }
 
-fn runnable_doctest(sema: &Semantics<RootDatabase>, item: SyntaxNode) -> Option<Runnable> {
-    match_ast! {
+pub(crate) fn runnable_mod(
+    sema: &Semantics<RootDatabase>,
+    module: ast::Module,
+) -> Option<Runnable> {
+    if !has_test_function_or_multiple_test_submodules(&module) {
+        return None;
+    }
+    let module_def = sema.to_def(&module)?;
+
+    let path = module_def
+        .path_to_root(sema.db)
+        .into_iter()
+        .rev()
+        .filter_map(|it| it.name(sema.db))
+        .join("::");
+
+    let def = sema.to_def(&module)?;
+    let attrs = def.attrs(sema.db);
+    let cfg = attrs.cfg();
+    let nav = module_def.to_nav(sema.db);
+    Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg })
+}
+
+// FIXME: figure out a proper API here.
+pub(crate) fn doc_owner_to_def(
+    sema: &Semantics<RootDatabase>,
+    item: SyntaxNode,
+) -> Option<Definition> {
+    let res: hir::ModuleDef = match_ast! {
         match item {
-            ast::Fn(it) => module_def_doctest(sema, sema.to_def(&it)?.into()),
-            ast::Struct(it) => module_def_doctest(sema, sema.to_def(&it)?.into()),
-            ast::Enum(it) => module_def_doctest(sema, sema.to_def(&it)?.into()),
-            ast::Union(it) => module_def_doctest(sema, sema.to_def(&it)?.into()),
-            ast::Trait(it) => module_def_doctest(sema, sema.to_def(&it)?.into()),
-            ast::Const(it) => module_def_doctest(sema, sema.to_def(&it)?.into()),
-            ast::Static(it) => module_def_doctest(sema, sema.to_def(&it)?.into()),
-            ast::TypeAlias(it) => module_def_doctest(sema, sema.to_def(&it)?.into()),
-            _ => None,
+            ast::SourceFile(it) => sema.scope(&item).module()?.into(),
+            ast::Fn(it) => sema.to_def(&it)?.into(),
+            ast::Struct(it) => sema.to_def(&it)?.into(),
+            ast::Enum(it) => sema.to_def(&it)?.into(),
+            ast::Union(it) => sema.to_def(&it)?.into(),
+            ast::Trait(it) => sema.to_def(&it)?.into(),
+            ast::Const(it) => sema.to_def(&it)?.into(),
+            ast::Static(it) => sema.to_def(&it)?.into(),
+            ast::TypeAlias(it) => sema.to_def(&it)?.into(),
+            _ => return None,
         }
-    }
+    };
+    Some(Definition::ModuleDef(res))
 }
 
 fn module_def_doctest(sema: &Semantics<RootDatabase>, def: hir::ModuleDef) -> Option<Runnable> {
@@ -254,26 +287,6 @@ fn has_runnable_doc_test(attrs: &hir::Attrs) -> bool {
     })
 }
 
-fn runnable_mod(sema: &Semantics<RootDatabase>, module: ast::Module) -> Option<Runnable> {
-    if !has_test_function_or_multiple_test_submodules(&module) {
-        return None;
-    }
-    let module_def = sema.to_def(&module)?;
-
-    let path = module_def
-        .path_to_root(sema.db)
-        .into_iter()
-        .rev()
-        .filter_map(|it| it.name(sema.db))
-        .join("::");
-
-    let def = sema.to_def(&module)?;
-    let attrs = def.attrs(sema.db);
-    let cfg = attrs.cfg();
-    let nav = module_def.to_nav(sema.db);
-    Some(Runnable { nav, kind: RunnableKind::TestMod { path }, cfg })
-}
-
 // We could create runnables for modules with number_of_test_submodules > 0,
 // but that bloats the runnables for no real benefit, since all tests can be run by the submodule already
 fn has_test_function_or_multiple_test_submodules(module: &ast::Module) -> bool {
@@ -330,7 +343,7 @@ mod tests {
         check(
             r#"
 //- /lib.rs
-<|>
+$0
 fn main() {}
 
 #[test]
@@ -426,7 +439,7 @@ fn bench() {}
         check(
             r#"
 //- /lib.rs
-<|>
+$0
 fn main() {}
 
 /// ```
@@ -574,7 +587,7 @@ struct StructWithRunnable(String);
         check(
             r#"
 //- /lib.rs
-<|>
+$0
 fn main() {}
 
 struct Data;
@@ -626,7 +639,7 @@ impl Data {
         check(
             r#"
 //- /lib.rs
-<|>
+$0
 mod test_mod {
     #[test]
     fn test_foo1() {}
@@ -680,7 +693,7 @@ mod test_mod {
         check(
             r#"
 //- /lib.rs
-<|>
+$0
 mod root_tests {
     mod nested_tests_0 {
         mod nested_tests_1 {
@@ -820,7 +833,7 @@ mod root_tests {
         check(
             r#"
 //- /lib.rs crate:foo cfg:feature=foo
-<|>
+$0
 #[test]
 #[cfg(feature = "foo")]
 fn test_foo1() {}
@@ -865,7 +878,7 @@ fn test_foo1() {}
         check(
             r#"
 //- /lib.rs crate:foo cfg:feature=foo,feature=bar
-<|>
+$0
 #[test]
 #[cfg(all(feature = "foo", feature = "bar"))]
 fn test_foo1() {}
@@ -920,7 +933,7 @@ fn test_foo1() {}
         check(
             r#"
 //- /lib.rs
-<|>
+$0
 mod test_mod {
     fn foo1() {}
 }
@@ -939,7 +952,7 @@ mod test_mod {
 //- /lib.rs
 mod foo;
 //- /foo.rs
-struct Foo;<|>
+struct Foo;$0
 impl Foo {
     /// ```
     /// let x = 5;
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index ba0085244..f2d4da78d 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -1,35 +1,39 @@
+pub(crate) mod tags;
+
+mod highlights;
+mod injector;
+
+mod highlight;
 mod format;
-mod html;
-mod injection;
 mod macro_rules;
-pub(crate) mod tags;
+mod inject;
+
+mod html;
 #[cfg(test)]
 mod tests;
 
-use hir::{AsAssocItem, Local, Name, Semantics, VariantDef};
-use ide_db::{
-    defs::{Definition, NameClass, NameRefClass},
-    RootDatabase,
-};
+use hir::{Name, Semantics};
+use ide_db::RootDatabase;
 use rustc_hash::FxHashMap;
 use syntax::{
     ast::{self, HasFormatSpecifier},
-    AstNode, AstToken, Direction, NodeOrToken, SyntaxElement,
-    SyntaxKind::{self, *},
-    SyntaxNode, SyntaxToken, TextRange, WalkEvent, T,
+    AstNode, AstToken, Direction, NodeOrToken,
+    SyntaxKind::*,
+    SyntaxNode, TextRange, WalkEvent, T,
 };
 
 use crate::{
     syntax_highlighting::{
-        format::FormatStringHighlighter, macro_rules::MacroRulesHighlighter, tags::Highlight,
+        format::highlight_format_string, highlights::Highlights,
+        macro_rules::MacroRulesHighlighter, tags::Highlight,
     },
-    FileId, HighlightModifier, HighlightTag, SymbolKind,
+    FileId, HlMod, HlTag, SymbolKind,
 };
 
 pub(crate) use html::highlight_as_html;
 
-#[derive(Debug, Clone)]
-pub struct HighlightedRange {
+#[derive(Debug, Clone, Copy)]
+pub struct HlRange {
     pub range: TextRange,
     pub highlight: Highlight,
     pub binding_hash: Option<u64>,
@@ -49,7 +53,7 @@ pub(crate) fn highlight(
     file_id: FileId,
     range_to_highlight: Option<TextRange>,
     syntactic_name_ref_highlighting: bool,
-) -> Vec<HighlightedRange> {
+) -> Vec<HlRange> {
     let _p = profile::span("highlight");
     let sema = Semantics::new(db);
 
@@ -68,28 +72,30 @@ pub(crate) fn highlight(
         }
     };
 
+    let mut hl = highlights::Highlights::new(range_to_highlight);
+    traverse(&mut hl, &sema, &root, range_to_highlight, syntactic_name_ref_highlighting);
+    hl.to_vec()
+}
+
+fn traverse(
+    hl: &mut Highlights,
+    sema: &Semantics<RootDatabase>,
+    root: &SyntaxNode,
+    range_to_highlight: TextRange,
+    syntactic_name_ref_highlighting: bool,
+) {
     let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default();
-    // We use a stack for the DFS traversal below.
-    // 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_rules: Option<ast::MacroRules> = None;
-    let mut format_string_highlighter = FormatStringHighlighter::default();
     let mut macro_rules_highlighter = MacroRulesHighlighter::default();
     let mut inside_attribute = false;
 
     // 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.
     for event in root.preorder_with_tokens() {
-        match &event {
-            WalkEvent::Enter(_) => stack.push(),
-            WalkEvent::Leave(_) => stack.pop(),
-        };
-
         let event_range = match &event {
-            WalkEvent::Enter(it) => it.text_range(),
-            WalkEvent::Leave(it) => it.text_range(),
+            WalkEvent::Enter(it) | WalkEvent::Leave(it) => it.text_range(),
         };
 
         // Element outside of the viewport, no need to highlight
@@ -101,9 +107,9 @@ pub(crate) fn highlight(
         match event.clone().map(|it| it.into_node().and_then(ast::MacroCall::cast)) {
             WalkEvent::Enter(Some(mc)) => {
                 if let Some(range) = macro_call_range(&mc) {
-                    stack.add(HighlightedRange {
+                    hl.add(HlRange {
                         range,
-                        highlight: HighlightTag::Symbol(SymbolKind::Macro).into(),
+                        highlight: HlTag::Symbol(SymbolKind::Macro).into(),
                         binding_hash: None,
                     });
                 }
@@ -113,7 +119,6 @@ pub(crate) fn highlight(
             WalkEvent::Leave(Some(mc)) => {
                 assert_eq!(current_macro_call, Some(mc));
                 current_macro_call = None;
-                format_string_highlighter = FormatStringHighlighter::default();
             }
             _ => (),
         }
@@ -131,33 +136,24 @@ pub(crate) fn highlight(
             }
             _ => (),
         }
-
         match &event {
-            // Check for Rust code in documentation
-            WalkEvent::Leave(NodeOrToken::Node(node)) => {
-                if ast::Attr::can_cast(node.kind()) {
-                    inside_attribute = false
-                }
-                if let Some((doctest, range_mapping, new_comments)) =
-                    injection::extract_doc_comments(node)
-                {
-                    injection::highlight_doc_comment(
-                        doctest,
-                        range_mapping,
-                        new_comments,
-                        &mut stack,
-                    );
-                }
-            }
             WalkEvent::Enter(NodeOrToken::Node(node)) if ast::Attr::can_cast(node.kind()) => {
                 inside_attribute = true
             }
+            WalkEvent::Leave(NodeOrToken::Node(node)) if ast::Attr::can_cast(node.kind()) => {
+                inside_attribute = false
+            }
             _ => (),
         }
 
         let element = match event {
             WalkEvent::Enter(it) => it,
-            WalkEvent::Leave(_) => continue,
+            WalkEvent::Leave(it) => {
+                if let Some(node) = it.as_node() {
+                    inject::doc_comment(hl, node);
+                }
+                continue;
+            }
         };
 
         let range = element.text_range();
@@ -177,8 +173,6 @@ pub(crate) fn highlight(
             let token = sema.descend_into_macros(token.clone());
             let parent = token.parent();
 
-            format_string_highlighter.check_for_format_string(&parent);
-
             // We only care Name and Name_ref
             match (token.kind(), parent.kind()) {
                 (IDENT, NAME) | (IDENT, NAME_REF) => parent.into(),
@@ -191,213 +185,45 @@ pub(crate) fn highlight(
         if let Some(token) = element.as_token().cloned().and_then(ast::String::cast) {
             if token.is_raw() {
                 let expanded = element_to_highlight.as_token().unwrap().clone();
-                if injection::highlight_injection(&mut stack, &sema, token, expanded).is_some() {
+                if inject::ra_fixture(hl, &sema, token, expanded).is_some() {
                     continue;
                 }
             }
         }
 
-        if let Some((mut highlight, binding_hash)) = highlight_element(
+        if let Some(_) = macro_rules_highlighter.highlight(element_to_highlight.clone()) {
+            continue;
+        }
+
+        if let Some((mut highlight, binding_hash)) = highlight::element(
             &sema,
             &mut bindings_shadow_count,
             syntactic_name_ref_highlighting,
             element_to_highlight.clone(),
         ) {
             if inside_attribute {
-                highlight = highlight | HighlightModifier::Attribute;
-            }
-
-            if macro_rules_highlighter.highlight(element_to_highlight.clone()).is_none() {
-                stack.add(HighlightedRange { range, highlight, binding_hash });
+                highlight = highlight | HlMod::Attribute;
             }
 
-            if let Some(string) =
-                element_to_highlight.as_token().cloned().and_then(ast::String::cast)
-            {
-                format_string_highlighter.highlight_format_string(&mut stack, &string, range);
-                // Highlight escape sequences
-                if let Some(char_ranges) = string.char_ranges() {
-                    stack.push();
-                    for (piece_range, _) in char_ranges.iter().filter(|(_, char)| char.is_ok()) {
-                        if string.text()[piece_range.start().into()..].starts_with('\\') {
-                            stack.add(HighlightedRange {
-                                range: piece_range + range.start(),
-                                highlight: HighlightTag::EscapeSequence.into(),
-                                binding_hash: None,
-                            });
-                        }
-                    }
-                    stack.pop_and_inject(None);
-                }
-            }
+            hl.add(HlRange { range, highlight, binding_hash });
         }
-    }
-
-    stack.flattened()
-}
-
-#[derive(Debug)]
-struct HighlightedRangeStack {
-    stack: Vec<Vec<HighlightedRange>>,
-}
-
-/// We use a stack to implement the flattening logic for the highlighted
-/// syntax ranges.
-impl HighlightedRangeStack {
-    fn new() -> Self {
-        Self { stack: vec![Vec::new()] }
-    }
-
-    fn push(&mut self) {
-        self.stack.push(Vec::new());
-    }
-
-    /// Flattens the highlighted ranges.
-    ///
-    /// For example `#[cfg(feature = "foo")]` contains the nested ranges:
-    /// 1) parent-range: Attribute [0, 23)
-    /// 2) child-range: String [16, 21)
-    ///
-    /// The following code implements the flattening, for our example this results to:
-    /// `[Attribute [0, 16), String [16, 21), Attribute [21, 23)]`
-    fn pop(&mut self) {
-        let children = self.stack.pop().unwrap();
-        let prev = self.stack.last_mut().unwrap();
-        let needs_flattening = !children.is_empty()
-            && !prev.is_empty()
-            && prev.last().unwrap().range.contains_range(children.first().unwrap().range);
-        if !needs_flattening {
-            prev.extend(children);
-        } else {
-            let mut parent = prev.pop().unwrap();
-            for ele in children {
-                assert!(parent.range.contains_range(ele.range));
-
-                let cloned = Self::intersect(&mut parent, &ele);
-                if !parent.range.is_empty() {
-                    prev.push(parent);
-                }
-                prev.push(ele);
-                parent = cloned;
-            }
-            if !parent.range.is_empty() {
-                prev.push(parent);
-            }
-        }
-    }
-
-    /// Intersects the `HighlightedRange` `parent` with `child`.
-    /// `parent` is mutated in place, becoming the range before `child`.
-    /// Returns the range (of the same type as `parent`) *after* `child`.
-    fn intersect(parent: &mut HighlightedRange, child: &HighlightedRange) -> HighlightedRange {
-        assert!(parent.range.contains_range(child.range));
-
-        let mut cloned = parent.clone();
-        parent.range = TextRange::new(parent.range.start(), child.range.start());
-        cloned.range = TextRange::new(child.range.end(), cloned.range.end());
 
-        cloned
-    }
-
-    /// Remove the `HighlightRange` of `parent` that's currently covered by `child`.
-    fn intersect_partial(parent: &mut HighlightedRange, child: &HighlightedRange) {
-        assert!(
-            parent.range.start() <= child.range.start()
-                && parent.range.end() >= child.range.start()
-                && child.range.end() > parent.range.end()
-        );
-
-        parent.range = TextRange::new(parent.range.start(), child.range.start());
-    }
-
-    /// Similar to `pop`, but can modify arbitrary prior ranges (where `pop`)
-    /// can only modify the last range currently on the stack.
-    /// Can be used to do injections that span multiple ranges, like the
-    /// doctest injection below.
-    /// If `overwrite_parent` is non-optional, the highlighting of the parent range
-    /// is overwritten with the argument.
-    ///
-    /// Note that `pop` can be simulated by `pop_and_inject(false)` but the
-    /// latter is computationally more expensive.
-    fn pop_and_inject(&mut self, overwrite_parent: Option<Highlight>) {
-        let mut children = self.stack.pop().unwrap();
-        let prev = self.stack.last_mut().unwrap();
-        children.sort_by_key(|range| range.range.start());
-        prev.sort_by_key(|range| range.range.start());
-
-        for child in children {
-            if let Some(idx) =
-                prev.iter().position(|parent| parent.range.contains_range(child.range))
-            {
-                if let Some(tag) = overwrite_parent {
-                    prev[idx].highlight = tag;
-                }
-
-                let cloned = Self::intersect(&mut prev[idx], &child);
-                let insert_idx = if prev[idx].range.is_empty() {
-                    prev.remove(idx);
-                    idx
-                } else {
-                    idx + 1
-                };
-                prev.insert(insert_idx, child);
-                if !cloned.range.is_empty() {
-                    prev.insert(insert_idx + 1, cloned);
-                }
-            } else {
-                let maybe_idx =
-                    prev.iter().position(|parent| parent.range.contains(child.range.start()));
-                match (overwrite_parent, maybe_idx) {
-                    (Some(_), Some(idx)) => {
-                        Self::intersect_partial(&mut prev[idx], &child);
-                        let insert_idx = if prev[idx].range.is_empty() {
-                            prev.remove(idx);
-                            idx
-                        } else {
-                            idx + 1
-                        };
-                        prev.insert(insert_idx, child);
-                    }
-                    (_, None) => {
-                        let idx = prev
-                            .binary_search_by_key(&child.range.start(), |range| range.range.start())
-                            .unwrap_or_else(|x| x);
-                        prev.insert(idx, child);
-                    }
-                    _ => {
-                        unreachable!("child range should be completely contained in parent range");
+        if let Some(string) = element_to_highlight.as_token().cloned().and_then(ast::String::cast) {
+            highlight_format_string(hl, &string, range);
+            // Highlight escape sequences
+            if let Some(char_ranges) = string.char_ranges() {
+                for (piece_range, _) in char_ranges.iter().filter(|(_, char)| char.is_ok()) {
+                    if string.text()[piece_range.start().into()..].starts_with('\\') {
+                        hl.add(HlRange {
+                            range: piece_range + range.start(),
+                            highlight: HlTag::EscapeSequence.into(),
+                            binding_hash: None,
+                        });
                     }
                 }
             }
         }
     }
-
-    fn add(&mut self, range: HighlightedRange) {
-        self.stack
-            .last_mut()
-            .expect("during DFS traversal, the stack must not be empty")
-            .push(range)
-    }
-
-    fn flattened(mut self) -> Vec<HighlightedRange> {
-        assert_eq!(
-            self.stack.len(),
-            1,
-            "after DFS traversal, the stack should only contain a single element"
-        );
-        let mut res = self.stack.pop().unwrap();
-        res.sort_by_key(|range| range.range.start());
-        // Check that ranges are sorted and disjoint
-        for (left, right) in res.iter().zip(res.iter().skip(1)) {
-            assert!(
-                left.range.end() <= right.range.start(),
-                "left: {:#?}, right: {:#?}",
-                left,
-                right
-            );
-        }
-        res
-    }
 }
 
 fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
@@ -415,524 +241,3 @@ fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
 
     Some(TextRange::new(range_start, range_end))
 }
-
-/// Returns true if the parent nodes of `node` all match the `SyntaxKind`s in `kinds` exactly.
-fn parents_match(mut node: NodeOrToken<SyntaxNode, SyntaxToken>, mut kinds: &[SyntaxKind]) -> bool {
-    while let (Some(parent), [kind, rest @ ..]) = (&node.parent(), kinds) {
-        if parent.kind() != *kind {
-            return false;
-        }
-
-        // FIXME: Would be nice to get parent out of the match, but binding by-move and by-value
-        // in the same pattern is unstable: rust-lang/rust#68354.
-        node = node.parent().unwrap().into();
-        kinds = rest;
-    }
-
-    // Only true if we matched all expected kinds
-    kinds.len() == 0
-}
-
-fn is_consumed_lvalue(
-    node: NodeOrToken<SyntaxNode, SyntaxToken>,
-    local: &Local,
-    db: &RootDatabase,
-) -> bool {
-    // When lvalues are passed as arguments and they're not Copy, then mark them as Consuming.
-    parents_match(node, &[PATH_SEGMENT, PATH, PATH_EXPR, ARG_LIST]) && !local.ty(db).is_copy(db)
-}
-
-fn highlight_element(
-    sema: &Semantics<RootDatabase>,
-    bindings_shadow_count: &mut FxHashMap<Name, u32>,
-    syntactic_name_ref_highlighting: bool,
-    element: SyntaxElement,
-) -> Option<(Highlight, Option<u64>)> {
-    let db = sema.db;
-    let mut binding_hash = None;
-    let highlight: Highlight = match element.kind() {
-        FN => {
-            bindings_shadow_count.clear();
-            return None;
-        }
-
-        // Highlight definitions depending on the "type" of the definition.
-        NAME => {
-            let name = element.into_node().and_then(ast::Name::cast).unwrap();
-            let name_kind = NameClass::classify(sema, &name);
-
-            if let Some(NameClass::Definition(Definition::Local(local))) = &name_kind {
-                if let Some(name) = local.name(db) {
-                    let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
-                    *shadow_count += 1;
-                    binding_hash = Some(calc_binding_hash(&name, *shadow_count))
-                }
-            };
-
-            match name_kind {
-                Some(NameClass::ExternCrate(_)) => HighlightTag::Symbol(SymbolKind::Module).into(),
-                Some(NameClass::Definition(def)) => {
-                    highlight_def(db, def) | HighlightModifier::Definition
-                }
-                Some(NameClass::ConstReference(def)) => highlight_def(db, def),
-                Some(NameClass::PatFieldShorthand { field_ref, .. }) => {
-                    let mut h = HighlightTag::Symbol(SymbolKind::Field).into();
-                    if let Definition::Field(field) = field_ref {
-                        if let VariantDef::Union(_) = field.parent_def(db) {
-                            h |= HighlightModifier::Unsafe;
-                        }
-                    }
-
-                    h
-                }
-                None => highlight_name_by_syntax(name) | HighlightModifier::Definition,
-            }
-        }
-
-        // Highlight references like the definitions they resolve to
-        NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => {
-            // even though we track whether we are in an attribute or not we still need this special case
-            // as otherwise we would emit unresolved references for name refs inside attributes
-            Highlight::from(HighlightTag::Symbol(SymbolKind::Function))
-        }
-        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 NameRefClass::classify(sema, &name_ref) {
-                    Some(name_kind) => match name_kind {
-                        NameRefClass::ExternCrate(_) => {
-                            HighlightTag::Symbol(SymbolKind::Module).into()
-                        }
-                        NameRefClass::Definition(def) => {
-                            if let Definition::Local(local) = &def {
-                                if let Some(name) = local.name(db) {
-                                    let shadow_count =
-                                        bindings_shadow_count.entry(name.clone()).or_default();
-                                    binding_hash = Some(calc_binding_hash(&name, *shadow_count))
-                                }
-                            };
-
-                            let mut h = highlight_def(db, def);
-
-                            if let Definition::Local(local) = &def {
-                                if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) {
-                                    h |= HighlightModifier::Consuming;
-                                }
-                            }
-
-                            if let Some(parent) = name_ref.syntax().parent() {
-                                if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) {
-                                    if let Definition::Field(field) = def {
-                                        if let VariantDef::Union(_) = field.parent_def(db) {
-                                            h |= HighlightModifier::Unsafe;
-                                        }
-                                    }
-                                }
-                            }
-
-                            h
-                        }
-                        NameRefClass::FieldShorthand { .. } => {
-                            HighlightTag::Symbol(SymbolKind::Field).into()
-                        }
-                    },
-                    None if syntactic_name_ref_highlighting => {
-                        highlight_name_ref_by_syntax(name_ref, sema)
-                    }
-                    None => HighlightTag::UnresolvedReference.into(),
-                }
-            })
-        }
-
-        // Simple token-based highlighting
-        COMMENT => {
-            let comment = element.into_token().and_then(ast::Comment::cast)?;
-            let h = HighlightTag::Comment;
-            match comment.kind().doc {
-                Some(_) => h | HighlightModifier::Documentation,
-                None => h.into(),
-            }
-        }
-        STRING | BYTE_STRING => HighlightTag::StringLiteral.into(),
-        ATTR => HighlightTag::Attribute.into(),
-        INT_NUMBER | FLOAT_NUMBER => HighlightTag::NumericLiteral.into(),
-        BYTE => HighlightTag::ByteLiteral.into(),
-        CHAR => HighlightTag::CharLiteral.into(),
-        QUESTION => Highlight::new(HighlightTag::Operator) | HighlightModifier::ControlFlow,
-        LIFETIME => {
-            let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap();
-
-            match NameClass::classify_lifetime(sema, &lifetime) {
-                Some(NameClass::Definition(def)) => {
-                    highlight_def(db, def) | HighlightModifier::Definition
-                }
-                None => match NameRefClass::classify_lifetime(sema, &lifetime) {
-                    Some(NameRefClass::Definition(def)) => highlight_def(db, def),
-                    _ => Highlight::new(HighlightTag::Symbol(SymbolKind::LifetimeParam)),
-                },
-                _ => {
-                    Highlight::new(HighlightTag::Symbol(SymbolKind::LifetimeParam))
-                        | HighlightModifier::Definition
-                }
-            }
-        }
-        p if p.is_punct() => match p {
-            T![&] => {
-                let h = HighlightTag::Operator.into();
-                let is_unsafe = element
-                    .parent()
-                    .and_then(ast::RefExpr::cast)
-                    .map(|ref_expr| sema.is_unsafe_ref_expr(&ref_expr))
-                    .unwrap_or(false);
-                if is_unsafe {
-                    h | HighlightModifier::Unsafe
-                } else {
-                    h
-                }
-            }
-            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => {
-                HighlightTag::Operator.into()
-            }
-            T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
-                HighlightTag::Symbol(SymbolKind::Macro).into()
-            }
-            T![!] if element.parent().and_then(ast::NeverType::cast).is_some() => {
-                HighlightTag::BuiltinType.into()
-            }
-            T![*] if element.parent().and_then(ast::PtrType::cast).is_some() => {
-                HighlightTag::Keyword.into()
-            }
-            T![*] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
-                let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
-
-                let expr = prefix_expr.expr()?;
-                let ty = sema.type_of_expr(&expr)?;
-                if ty.is_raw_ptr() {
-                    HighlightTag::Operator | HighlightModifier::Unsafe
-                } else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() {
-                    HighlightTag::Operator.into()
-                } else {
-                    HighlightTag::Punctuation.into()
-                }
-            }
-            T![-] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
-                let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
-
-                let expr = prefix_expr.expr()?;
-                match expr {
-                    ast::Expr::Literal(_) => HighlightTag::NumericLiteral,
-                    _ => HighlightTag::Operator,
-                }
-                .into()
-            }
-            _ if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
-                HighlightTag::Operator.into()
-            }
-            _ if element.parent().and_then(ast::BinExpr::cast).is_some() => {
-                HighlightTag::Operator.into()
-            }
-            _ if element.parent().and_then(ast::RangeExpr::cast).is_some() => {
-                HighlightTag::Operator.into()
-            }
-            _ if element.parent().and_then(ast::RangePat::cast).is_some() => {
-                HighlightTag::Operator.into()
-            }
-            _ if element.parent().and_then(ast::RestPat::cast).is_some() => {
-                HighlightTag::Operator.into()
-            }
-            _ if element.parent().and_then(ast::Attr::cast).is_some() => {
-                HighlightTag::Attribute.into()
-            }
-            _ => HighlightTag::Punctuation.into(),
-        },
-
-        k if k.is_keyword() => {
-            let h = Highlight::new(HighlightTag::Keyword);
-            match k {
-                T![break]
-                | T![continue]
-                | T![else]
-                | T![if]
-                | T![loop]
-                | T![match]
-                | T![return]
-                | T![while]
-                | T![in] => h | HighlightModifier::ControlFlow,
-                T![for] if !is_child_of_impl(&element) => h | HighlightModifier::ControlFlow,
-                T![unsafe] => h | HighlightModifier::Unsafe,
-                T![true] | T![false] => HighlightTag::BoolLiteral.into(),
-                T![self] => {
-                    let self_param_is_mut = element
-                        .parent()
-                        .and_then(ast::SelfParam::cast)
-                        .and_then(|p| p.mut_token())
-                        .is_some();
-                    let self_path = &element
-                        .parent()
-                        .as_ref()
-                        .and_then(SyntaxNode::parent)
-                        .and_then(ast::Path::cast)
-                        .and_then(|p| sema.resolve_path(&p));
-                    let mut h = HighlightTag::Symbol(SymbolKind::SelfParam).into();
-                    if self_param_is_mut
-                        || matches!(self_path,
-                            Some(hir::PathResolution::Local(local))
-                                if local.is_self(db)
-                                    && (local.is_mut(db) || local.ty(db).is_mutable_reference())
-                        )
-                    {
-                        h |= HighlightModifier::Mutable
-                    }
-
-                    if let Some(hir::PathResolution::Local(local)) = self_path {
-                        if is_consumed_lvalue(element, &local, db) {
-                            h |= HighlightModifier::Consuming;
-                        }
-                    }
-
-                    h
-                }
-                T![ref] => element
-                    .parent()
-                    .and_then(ast::IdentPat::cast)
-                    .and_then(|ident_pat| {
-                        if sema.is_unsafe_ident_pat(&ident_pat) {
-                            Some(HighlightModifier::Unsafe)
-                        } else {
-                            None
-                        }
-                    })
-                    .map(|modifier| h | modifier)
-                    .unwrap_or(h),
-                _ => h,
-            }
-        }
-
-        _ => return None,
-    };
-
-    return Some((highlight, binding_hash));
-
-    fn calc_binding_hash(name: &Name, shadow_count: u32) -> u64 {
-        fn hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
-            use std::{collections::hash_map::DefaultHasher, hash::Hasher};
-
-            let mut hasher = DefaultHasher::new();
-            x.hash(&mut hasher);
-            hasher.finish()
-        }
-
-        hash((name, shadow_count))
-    }
-}
-
-fn is_child_of_impl(element: &SyntaxElement) -> bool {
-    match element.parent() {
-        Some(e) => e.kind() == IMPL,
-        _ => false,
-    }
-}
-
-fn highlight_func_by_name_ref(
-    sema: &Semantics<RootDatabase>,
-    name_ref: &ast::NameRef,
-) -> Option<Highlight> {
-    let method_call = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast)?;
-    highlight_method_call(sema, &method_call)
-}
-
-fn highlight_method_call(
-    sema: &Semantics<RootDatabase>,
-    method_call: &ast::MethodCallExpr,
-) -> Option<Highlight> {
-    let func = sema.resolve_method_call(&method_call)?;
-    let mut h = HighlightTag::Symbol(SymbolKind::Function).into();
-    h |= HighlightModifier::Associated;
-    if func.is_unsafe(sema.db) || sema.is_unsafe_method_call(&method_call) {
-        h |= HighlightModifier::Unsafe;
-    }
-    if let Some(self_param) = func.self_param(sema.db) {
-        match self_param.access(sema.db) {
-            hir::Access::Shared => (),
-            hir::Access::Exclusive => h |= HighlightModifier::Mutable,
-            hir::Access::Owned => {
-                if let Some(receiver_ty) =
-                    method_call.receiver().and_then(|it| sema.type_of_expr(&it))
-                {
-                    if !receiver_ty.is_copy(sema.db) {
-                        h |= HighlightModifier::Consuming
-                    }
-                }
-            }
-        }
-    }
-    Some(h)
-}
-
-fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
-    match def {
-        Definition::Macro(_) => HighlightTag::Symbol(SymbolKind::Macro),
-        Definition::Field(_) => HighlightTag::Symbol(SymbolKind::Field),
-        Definition::ModuleDef(def) => match def {
-            hir::ModuleDef::Module(_) => HighlightTag::Symbol(SymbolKind::Module),
-            hir::ModuleDef::Function(func) => {
-                let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::Function));
-                if func.as_assoc_item(db).is_some() {
-                    h |= HighlightModifier::Associated;
-                    if func.self_param(db).is_none() {
-                        h |= HighlightModifier::Static
-                    }
-                }
-                if func.is_unsafe(db) {
-                    h |= HighlightModifier::Unsafe;
-                }
-                return h;
-            }
-            hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HighlightTag::Symbol(SymbolKind::Struct),
-            hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HighlightTag::Symbol(SymbolKind::Enum),
-            hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Symbol(SymbolKind::Union),
-            hir::ModuleDef::Variant(_) => HighlightTag::Symbol(SymbolKind::Variant),
-            hir::ModuleDef::Const(konst) => {
-                let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::Const));
-                if konst.as_assoc_item(db).is_some() {
-                    h |= HighlightModifier::Associated
-                }
-                return h;
-            }
-            hir::ModuleDef::Trait(_) => HighlightTag::Symbol(SymbolKind::Trait),
-            hir::ModuleDef::TypeAlias(type_) => {
-                let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::TypeAlias));
-                if type_.as_assoc_item(db).is_some() {
-                    h |= HighlightModifier::Associated
-                }
-                return h;
-            }
-            hir::ModuleDef::BuiltinType(_) => HighlightTag::BuiltinType,
-            hir::ModuleDef::Static(s) => {
-                let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::Static));
-                if s.is_mut(db) {
-                    h |= HighlightModifier::Mutable;
-                    h |= HighlightModifier::Unsafe;
-                }
-                return h;
-            }
-        },
-        Definition::SelfType(_) => HighlightTag::Symbol(SymbolKind::Impl),
-        Definition::TypeParam(_) => HighlightTag::Symbol(SymbolKind::TypeParam),
-        Definition::ConstParam(_) => HighlightTag::Symbol(SymbolKind::ConstParam),
-        Definition::Local(local) => {
-            let tag = if local.is_param(db) {
-                HighlightTag::Symbol(SymbolKind::ValueParam)
-            } else {
-                HighlightTag::Symbol(SymbolKind::Local)
-            };
-            let mut h = Highlight::new(tag);
-            if local.is_mut(db) || local.ty(db).is_mutable_reference() {
-                h |= HighlightModifier::Mutable;
-            }
-            if local.ty(db).as_callable(db).is_some() || local.ty(db).impls_fnonce(db) {
-                h |= HighlightModifier::Callable;
-            }
-            return h;
-        }
-        Definition::LifetimeParam(_) => HighlightTag::Symbol(SymbolKind::LifetimeParam),
-        Definition::Label(_) => HighlightTag::Symbol(SymbolKind::Label),
-    }
-    .into()
-}
-
-fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
-    let default = HighlightTag::UnresolvedReference;
-
-    let parent = match name.syntax().parent() {
-        Some(it) => it,
-        _ => return default.into(),
-    };
-
-    let tag = match parent.kind() {
-        STRUCT => HighlightTag::Symbol(SymbolKind::Struct),
-        ENUM => HighlightTag::Symbol(SymbolKind::Enum),
-        VARIANT => HighlightTag::Symbol(SymbolKind::Variant),
-        UNION => HighlightTag::Symbol(SymbolKind::Union),
-        TRAIT => HighlightTag::Symbol(SymbolKind::Trait),
-        TYPE_ALIAS => HighlightTag::Symbol(SymbolKind::TypeAlias),
-        TYPE_PARAM => HighlightTag::Symbol(SymbolKind::TypeParam),
-        RECORD_FIELD => HighlightTag::Symbol(SymbolKind::Field),
-        MODULE => HighlightTag::Symbol(SymbolKind::Module),
-        FN => HighlightTag::Symbol(SymbolKind::Function),
-        CONST => HighlightTag::Symbol(SymbolKind::Const),
-        STATIC => HighlightTag::Symbol(SymbolKind::Static),
-        IDENT_PAT => HighlightTag::Symbol(SymbolKind::Local),
-        _ => default,
-    };
-
-    tag.into()
-}
-
-fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabase>) -> Highlight {
-    let default = HighlightTag::UnresolvedReference;
-
-    let parent = match name.syntax().parent() {
-        Some(it) => it,
-        _ => return default.into(),
-    };
-
-    match parent.kind() {
-        METHOD_CALL_EXPR => {
-            return ast::MethodCallExpr::cast(parent)
-                .and_then(|method_call| highlight_method_call(sema, &method_call))
-                .unwrap_or_else(|| HighlightTag::Symbol(SymbolKind::Function).into());
-        }
-        FIELD_EXPR => {
-            let h = HighlightTag::Symbol(SymbolKind::Field);
-            let is_union = ast::FieldExpr::cast(parent)
-                .and_then(|field_expr| {
-                    let field = sema.resolve_field(&field_expr)?;
-                    Some(if let VariantDef::Union(_) = field.parent_def(sema.db) {
-                        true
-                    } else {
-                        false
-                    })
-                })
-                .unwrap_or(false);
-            if is_union {
-                h | HighlightModifier::Unsafe
-            } else {
-                h.into()
-            }
-        }
-        PATH_SEGMENT => {
-            let path = match parent.parent().and_then(ast::Path::cast) {
-                Some(it) => it,
-                _ => return default.into(),
-            };
-            let expr = match path.syntax().parent().and_then(ast::PathExpr::cast) {
-                Some(it) => it,
-                _ => {
-                    // within path, decide whether it is module or adt by checking for uppercase name
-                    return if name.text().chars().next().unwrap_or_default().is_uppercase() {
-                        HighlightTag::Symbol(SymbolKind::Struct)
-                    } else {
-                        HighlightTag::Symbol(SymbolKind::Module)
-                    }
-                    .into();
-                }
-            };
-            let parent = match expr.syntax().parent() {
-                Some(it) => it,
-                None => return default.into(),
-            };
-
-            match parent.kind() {
-                CALL_EXPR => HighlightTag::Symbol(SymbolKind::Function).into(),
-                _ => if name.text().chars().next().unwrap_or_default().is_uppercase() {
-                    HighlightTag::Symbol(SymbolKind::Struct)
-                } else {
-                    HighlightTag::Symbol(SymbolKind::Const)
-                }
-                .into(),
-            }
-        }
-        _ => default.into(),
-    }
-}
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs
index 26416022b..a74ca844b 100644
--- a/crates/ide/src/syntax_highlighting/format.rs
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -1,65 +1,51 @@
 //! Syntax highlighting for format macro strings.
 use syntax::{
     ast::{self, FormatSpecifier, HasFormatSpecifier},
-    AstNode, AstToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange,
+    AstNode, AstToken, TextRange,
 };
 
-use crate::{
-    syntax_highlighting::HighlightedRangeStack, HighlightTag, HighlightedRange, SymbolKind,
-};
-
-#[derive(Default)]
-pub(super) struct FormatStringHighlighter {
-    format_string: Option<SyntaxElement>,
-}
+use crate::{syntax_highlighting::highlights::Highlights, HlRange, HlTag, SymbolKind};
 
-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()))
-                }
-                _ => {}
-            }
-        }
+pub(super) fn highlight_format_string(
+    stack: &mut Highlights,
+    string: &ast::String,
+    range: TextRange,
+) {
+    if is_format_string(string).is_none() {
+        return;
     }
-    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,
-                    });
-                }
+
+    string.lex_format_specifier(|piece_range, kind| {
+        if let Some(highlight) = highlight_format_specifier(kind) {
+            stack.add(HlRange {
+                range: piece_range + range.start(),
+                highlight: highlight.into(),
+                binding_hash: None,
             });
-            range_stack.pop();
         }
+    });
+}
+
+fn is_format_string(string: &ast::String) -> Option<()> {
+    let parent = string.syntax().parent();
+
+    let name = parent.parent().and_then(ast::MacroCall::cast)?.path()?.segment()?.name_ref()?;
+    if !matches!(name.text().as_str(), "format_args" | "format_args_nl") {
+        return None;
+    }
+
+    let first_literal = parent
+        .children_with_tokens()
+        .filter_map(|it| it.as_token().cloned().and_then(ast::String::cast))
+        .next()?;
+    if &first_literal != string {
+        return None;
     }
+
+    Some(())
 }
 
-fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HighlightTag> {
+fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HlTag> {
     Some(match kind {
         FormatSpecifier::Open
         | FormatSpecifier::Close
@@ -71,8 +57,10 @@ fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HighlightTag> {
         | FormatSpecifier::DollarSign
         | FormatSpecifier::Dot
         | FormatSpecifier::Asterisk
-        | FormatSpecifier::QuestionMark => HighlightTag::FormatSpecifier,
-        FormatSpecifier::Integer | FormatSpecifier::Zero => HighlightTag::NumericLiteral,
-        FormatSpecifier::Identifier => HighlightTag::Symbol(SymbolKind::Local),
+        | FormatSpecifier::QuestionMark => HlTag::FormatSpecifier,
+
+        FormatSpecifier::Integer | FormatSpecifier::Zero => HlTag::NumericLiteral,
+
+        FormatSpecifier::Identifier => HlTag::Symbol(SymbolKind::Local),
     })
 }
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
new file mode 100644
index 000000000..34bae49a8
--- /dev/null
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -0,0 +1,530 @@
+//! Computes color for a single element.
+
+use hir::{AsAssocItem, Semantics, VariantDef};
+use ide_db::{
+    defs::{Definition, NameClass, NameRefClass},
+    RootDatabase,
+};
+use rustc_hash::FxHashMap;
+use syntax::{
+    ast, AstNode, AstToken, NodeOrToken, SyntaxElement,
+    SyntaxKind::{self, *},
+    SyntaxNode, SyntaxToken, T,
+};
+
+use crate::{syntax_highlighting::tags::HlPunct, Highlight, HlMod, HlTag, SymbolKind};
+
+pub(super) fn element(
+    sema: &Semantics<RootDatabase>,
+    bindings_shadow_count: &mut FxHashMap<hir::Name, u32>,
+    syntactic_name_ref_highlighting: bool,
+    element: SyntaxElement,
+) -> Option<(Highlight, Option<u64>)> {
+    let db = sema.db;
+    let mut binding_hash = None;
+    let highlight: Highlight = match element.kind() {
+        FN => {
+            bindings_shadow_count.clear();
+            return None;
+        }
+
+        // Highlight definitions depending on the "type" of the definition.
+        NAME => {
+            let name = element.into_node().and_then(ast::Name::cast).unwrap();
+            let name_kind = NameClass::classify(sema, &name);
+
+            if let Some(NameClass::Definition(Definition::Local(local))) = &name_kind {
+                if let Some(name) = local.name(db) {
+                    let shadow_count = bindings_shadow_count.entry(name.clone()).or_default();
+                    *shadow_count += 1;
+                    binding_hash = Some(calc_binding_hash(&name, *shadow_count))
+                }
+            };
+
+            match name_kind {
+                Some(NameClass::ExternCrate(_)) => HlTag::Symbol(SymbolKind::Module).into(),
+                Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
+                Some(NameClass::ConstReference(def)) => highlight_def(db, def),
+                Some(NameClass::PatFieldShorthand { field_ref, .. }) => {
+                    let mut h = HlTag::Symbol(SymbolKind::Field).into();
+                    if let Definition::Field(field) = field_ref {
+                        if let VariantDef::Union(_) = field.parent_def(db) {
+                            h |= HlMod::Unsafe;
+                        }
+                    }
+
+                    h
+                }
+                None => highlight_name_by_syntax(name) | HlMod::Definition,
+            }
+        }
+
+        // Highlight references like the definitions they resolve to
+        NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => {
+            // even though we track whether we are in an attribute or not we still need this special case
+            // as otherwise we would emit unresolved references for name refs inside attributes
+            Highlight::from(HlTag::Symbol(SymbolKind::Function))
+        }
+        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 NameRefClass::classify(sema, &name_ref) {
+                    Some(name_kind) => match name_kind {
+                        NameRefClass::ExternCrate(_) => HlTag::Symbol(SymbolKind::Module).into(),
+                        NameRefClass::Definition(def) => {
+                            if let Definition::Local(local) = &def {
+                                if let Some(name) = local.name(db) {
+                                    let shadow_count =
+                                        bindings_shadow_count.entry(name.clone()).or_default();
+                                    binding_hash = Some(calc_binding_hash(&name, *shadow_count))
+                                }
+                            };
+
+                            let mut h = highlight_def(db, def);
+
+                            if let Definition::Local(local) = &def {
+                                if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) {
+                                    h |= HlMod::Consuming;
+                                }
+                            }
+
+                            if let Some(parent) = name_ref.syntax().parent() {
+                                if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) {
+                                    if let Definition::Field(field) = def {
+                                        if let VariantDef::Union(_) = field.parent_def(db) {
+                                            h |= HlMod::Unsafe;
+                                        }
+                                    }
+                                }
+                            }
+
+                            h
+                        }
+                        NameRefClass::FieldShorthand { .. } => {
+                            HlTag::Symbol(SymbolKind::Field).into()
+                        }
+                    },
+                    None if syntactic_name_ref_highlighting => {
+                        highlight_name_ref_by_syntax(name_ref, sema)
+                    }
+                    None => HlTag::UnresolvedReference.into(),
+                }
+            })
+        }
+
+        // Simple token-based highlighting
+        COMMENT => {
+            let comment = element.into_token().and_then(ast::Comment::cast)?;
+            let h = HlTag::Comment;
+            match comment.kind().doc {
+                Some(_) => h | HlMod::Documentation,
+                None => h.into(),
+            }
+        }
+        STRING | BYTE_STRING => HlTag::StringLiteral.into(),
+        ATTR => HlTag::Attribute.into(),
+        INT_NUMBER | FLOAT_NUMBER => HlTag::NumericLiteral.into(),
+        BYTE => HlTag::ByteLiteral.into(),
+        CHAR => HlTag::CharLiteral.into(),
+        QUESTION => Highlight::new(HlTag::Operator) | HlMod::ControlFlow,
+        LIFETIME => {
+            let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap();
+
+            match NameClass::classify_lifetime(sema, &lifetime) {
+                Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
+                None => match NameRefClass::classify_lifetime(sema, &lifetime) {
+                    Some(NameRefClass::Definition(def)) => highlight_def(db, def),
+                    _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)),
+                },
+                _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)) | HlMod::Definition,
+            }
+        }
+        p if p.is_punct() => match p {
+            T![&] => {
+                let h = HlTag::Operator.into();
+                let is_unsafe = element
+                    .parent()
+                    .and_then(ast::RefExpr::cast)
+                    .map(|ref_expr| sema.is_unsafe_ref_expr(&ref_expr))
+                    .unwrap_or(false);
+                if is_unsafe {
+                    h | HlMod::Unsafe
+                } else {
+                    h
+                }
+            }
+            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => HlTag::Operator.into(),
+            T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
+                HlTag::Symbol(SymbolKind::Macro).into()
+            }
+            T![!] if element.parent().and_then(ast::NeverType::cast).is_some() => {
+                HlTag::BuiltinType.into()
+            }
+            T![*] if element.parent().and_then(ast::PtrType::cast).is_some() => {
+                HlTag::Keyword.into()
+            }
+            T![*] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
+                let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
+
+                let expr = prefix_expr.expr()?;
+                let ty = sema.type_of_expr(&expr)?;
+                if ty.is_raw_ptr() {
+                    HlTag::Operator | HlMod::Unsafe
+                } else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() {
+                    HlTag::Operator.into()
+                } else {
+                    HlTag::Punctuation(HlPunct::Other).into()
+                }
+            }
+            T![-] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
+                let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
+
+                let expr = prefix_expr.expr()?;
+                match expr {
+                    ast::Expr::Literal(_) => HlTag::NumericLiteral,
+                    _ => HlTag::Operator,
+                }
+                .into()
+            }
+            _ if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
+                HlTag::Operator.into()
+            }
+            _ if element.parent().and_then(ast::BinExpr::cast).is_some() => HlTag::Operator.into(),
+            _ if element.parent().and_then(ast::RangeExpr::cast).is_some() => {
+                HlTag::Operator.into()
+            }
+            _ if element.parent().and_then(ast::RangePat::cast).is_some() => HlTag::Operator.into(),
+            _ if element.parent().and_then(ast::RestPat::cast).is_some() => HlTag::Operator.into(),
+            _ if element.parent().and_then(ast::Attr::cast).is_some() => HlTag::Attribute.into(),
+            kind => HlTag::Punctuation(match kind {
+                T!['['] | T![']'] => HlPunct::Bracket,
+                T!['{'] | T!['}'] => HlPunct::Brace,
+                T!['('] | T![')'] => HlPunct::Parenthesis,
+                T![<] | T![>] => HlPunct::Angle,
+                T![,] => HlPunct::Comma,
+                T![:] => HlPunct::Colon,
+                T![;] => HlPunct::Semi,
+                T![.] => HlPunct::Dot,
+                _ => HlPunct::Other,
+            })
+            .into(),
+        },
+
+        k if k.is_keyword() => {
+            let h = Highlight::new(HlTag::Keyword);
+            match k {
+                T![break]
+                | T![continue]
+                | T![else]
+                | T![if]
+                | T![loop]
+                | T![match]
+                | T![return]
+                | T![while]
+                | T![in] => h | HlMod::ControlFlow,
+                T![for] if !is_child_of_impl(&element) => h | HlMod::ControlFlow,
+                T![unsafe] => h | HlMod::Unsafe,
+                T![true] | T![false] => HlTag::BoolLiteral.into(),
+                T![self] => {
+                    let self_param_is_mut = element
+                        .parent()
+                        .and_then(ast::SelfParam::cast)
+                        .and_then(|p| p.mut_token())
+                        .is_some();
+                    let self_path = &element
+                        .parent()
+                        .as_ref()
+                        .and_then(SyntaxNode::parent)
+                        .and_then(ast::Path::cast)
+                        .and_then(|p| sema.resolve_path(&p));
+                    let mut h = HlTag::Symbol(SymbolKind::SelfParam).into();
+                    if self_param_is_mut
+                        || matches!(self_path,
+                            Some(hir::PathResolution::Local(local))
+                                if local.is_self(db)
+                                    && (local.is_mut(db) || local.ty(db).is_mutable_reference())
+                        )
+                    {
+                        h |= HlMod::Mutable
+                    }
+
+                    if let Some(hir::PathResolution::Local(local)) = self_path {
+                        if is_consumed_lvalue(element, &local, db) {
+                            h |= HlMod::Consuming;
+                        }
+                    }
+
+                    h
+                }
+                T![ref] => element
+                    .parent()
+                    .and_then(ast::IdentPat::cast)
+                    .and_then(|ident_pat| {
+                        if sema.is_unsafe_ident_pat(&ident_pat) {
+                            Some(HlMod::Unsafe)
+                        } else {
+                            None
+                        }
+                    })
+                    .map(|modifier| h | modifier)
+                    .unwrap_or(h),
+                _ => h,
+            }
+        }
+
+        _ => return None,
+    };
+
+    return Some((highlight, binding_hash));
+
+    fn calc_binding_hash(name: &hir::Name, shadow_count: u32) -> u64 {
+        fn hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
+            use std::{collections::hash_map::DefaultHasher, hash::Hasher};
+
+            let mut hasher = DefaultHasher::new();
+            x.hash(&mut hasher);
+            hasher.finish()
+        }
+
+        hash((name, shadow_count))
+    }
+}
+
+fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
+    match def {
+        Definition::Macro(_) => HlTag::Symbol(SymbolKind::Macro),
+        Definition::Field(_) => HlTag::Symbol(SymbolKind::Field),
+        Definition::ModuleDef(def) => match def {
+            hir::ModuleDef::Module(_) => HlTag::Symbol(SymbolKind::Module),
+            hir::ModuleDef::Function(func) => {
+                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Function));
+                if func.as_assoc_item(db).is_some() {
+                    h |= HlMod::Associated;
+                    if func.self_param(db).is_none() {
+                        h |= HlMod::Static
+                    }
+                }
+                if func.is_unsafe(db) {
+                    h |= HlMod::Unsafe;
+                }
+                return h;
+            }
+            hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HlTag::Symbol(SymbolKind::Struct),
+            hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HlTag::Symbol(SymbolKind::Enum),
+            hir::ModuleDef::Adt(hir::Adt::Union(_)) => HlTag::Symbol(SymbolKind::Union),
+            hir::ModuleDef::Variant(_) => HlTag::Symbol(SymbolKind::Variant),
+            hir::ModuleDef::Const(konst) => {
+                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Const));
+                if konst.as_assoc_item(db).is_some() {
+                    h |= HlMod::Associated
+                }
+                return h;
+            }
+            hir::ModuleDef::Trait(_) => HlTag::Symbol(SymbolKind::Trait),
+            hir::ModuleDef::TypeAlias(type_) => {
+                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::TypeAlias));
+                if type_.as_assoc_item(db).is_some() {
+                    h |= HlMod::Associated
+                }
+                return h;
+            }
+            hir::ModuleDef::BuiltinType(_) => HlTag::BuiltinType,
+            hir::ModuleDef::Static(s) => {
+                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Static));
+                if s.is_mut(db) {
+                    h |= HlMod::Mutable;
+                    h |= HlMod::Unsafe;
+                }
+                return h;
+            }
+        },
+        Definition::SelfType(_) => HlTag::Symbol(SymbolKind::Impl),
+        Definition::GenericParam(it) => match it {
+            hir::GenericParam::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),
+            hir::GenericParam::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),
+            hir::GenericParam::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),
+        },
+        Definition::Local(local) => {
+            let tag = if local.is_param(db) {
+                HlTag::Symbol(SymbolKind::ValueParam)
+            } else {
+                HlTag::Symbol(SymbolKind::Local)
+            };
+            let mut h = Highlight::new(tag);
+            if local.is_mut(db) || local.ty(db).is_mutable_reference() {
+                h |= HlMod::Mutable;
+            }
+            if local.ty(db).as_callable(db).is_some() || local.ty(db).impls_fnonce(db) {
+                h |= HlMod::Callable;
+            }
+            return h;
+        }
+        Definition::Label(_) => HlTag::Symbol(SymbolKind::Label),
+    }
+    .into()
+}
+
+fn highlight_func_by_name_ref(
+    sema: &Semantics<RootDatabase>,
+    name_ref: &ast::NameRef,
+) -> Option<Highlight> {
+    let mc = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast)?;
+    highlight_method_call(sema, &mc)
+}
+
+fn highlight_method_call(
+    sema: &Semantics<RootDatabase>,
+    method_call: &ast::MethodCallExpr,
+) -> Option<Highlight> {
+    let func = sema.resolve_method_call(&method_call)?;
+    let mut h = HlTag::Symbol(SymbolKind::Function).into();
+    h |= HlMod::Associated;
+    if func.is_unsafe(sema.db) || sema.is_unsafe_method_call(&method_call) {
+        h |= HlMod::Unsafe;
+    }
+    if let Some(self_param) = func.self_param(sema.db) {
+        match self_param.access(sema.db) {
+            hir::Access::Shared => (),
+            hir::Access::Exclusive => h |= HlMod::Mutable,
+            hir::Access::Owned => {
+                if let Some(receiver_ty) =
+                    method_call.receiver().and_then(|it| sema.type_of_expr(&it))
+                {
+                    if !receiver_ty.is_copy(sema.db) {
+                        h |= HlMod::Consuming
+                    }
+                }
+            }
+        }
+    }
+    Some(h)
+}
+
+fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
+    let default = HlTag::UnresolvedReference;
+
+    let parent = match name.syntax().parent() {
+        Some(it) => it,
+        _ => return default.into(),
+    };
+
+    let tag = match parent.kind() {
+        STRUCT => HlTag::Symbol(SymbolKind::Struct),
+        ENUM => HlTag::Symbol(SymbolKind::Enum),
+        VARIANT => HlTag::Symbol(SymbolKind::Variant),
+        UNION => HlTag::Symbol(SymbolKind::Union),
+        TRAIT => HlTag::Symbol(SymbolKind::Trait),
+        TYPE_ALIAS => HlTag::Symbol(SymbolKind::TypeAlias),
+        TYPE_PARAM => HlTag::Symbol(SymbolKind::TypeParam),
+        RECORD_FIELD => HlTag::Symbol(SymbolKind::Field),
+        MODULE => HlTag::Symbol(SymbolKind::Module),
+        FN => HlTag::Symbol(SymbolKind::Function),
+        CONST => HlTag::Symbol(SymbolKind::Const),
+        STATIC => HlTag::Symbol(SymbolKind::Static),
+        IDENT_PAT => HlTag::Symbol(SymbolKind::Local),
+        _ => default,
+    };
+
+    tag.into()
+}
+
+fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabase>) -> Highlight {
+    let default = HlTag::UnresolvedReference;
+
+    let parent = match name.syntax().parent() {
+        Some(it) => it,
+        _ => return default.into(),
+    };
+
+    match parent.kind() {
+        METHOD_CALL_EXPR => {
+            return ast::MethodCallExpr::cast(parent)
+                .and_then(|it| highlight_method_call(sema, &it))
+                .unwrap_or_else(|| HlTag::Symbol(SymbolKind::Function).into());
+        }
+        FIELD_EXPR => {
+            let h = HlTag::Symbol(SymbolKind::Field);
+            let is_union = ast::FieldExpr::cast(parent)
+                .and_then(|field_expr| {
+                    let field = sema.resolve_field(&field_expr)?;
+                    Some(if let VariantDef::Union(_) = field.parent_def(sema.db) {
+                        true
+                    } else {
+                        false
+                    })
+                })
+                .unwrap_or(false);
+            if is_union {
+                h | HlMod::Unsafe
+            } else {
+                h.into()
+            }
+        }
+        PATH_SEGMENT => {
+            let path = match parent.parent().and_then(ast::Path::cast) {
+                Some(it) => it,
+                _ => return default.into(),
+            };
+            let expr = match path.syntax().parent().and_then(ast::PathExpr::cast) {
+                Some(it) => it,
+                _ => {
+                    // within path, decide whether it is module or adt by checking for uppercase name
+                    return if name.text().chars().next().unwrap_or_default().is_uppercase() {
+                        HlTag::Symbol(SymbolKind::Struct)
+                    } else {
+                        HlTag::Symbol(SymbolKind::Module)
+                    }
+                    .into();
+                }
+            };
+            let parent = match expr.syntax().parent() {
+                Some(it) => it,
+                None => return default.into(),
+            };
+
+            match parent.kind() {
+                CALL_EXPR => HlTag::Symbol(SymbolKind::Function).into(),
+                _ => if name.text().chars().next().unwrap_or_default().is_uppercase() {
+                    HlTag::Symbol(SymbolKind::Struct)
+                } else {
+                    HlTag::Symbol(SymbolKind::Const)
+                }
+                .into(),
+            }
+        }
+        _ => default.into(),
+    }
+}
+
+fn is_consumed_lvalue(
+    node: NodeOrToken<SyntaxNode, SyntaxToken>,
+    local: &hir::Local,
+    db: &RootDatabase,
+) -> bool {
+    // When lvalues are passed as arguments and they're not Copy, then mark them as Consuming.
+    parents_match(node, &[PATH_SEGMENT, PATH, PATH_EXPR, ARG_LIST]) && !local.ty(db).is_copy(db)
+}
+
+/// Returns true if the parent nodes of `node` all match the `SyntaxKind`s in `kinds` exactly.
+fn parents_match(mut node: NodeOrToken<SyntaxNode, SyntaxToken>, mut kinds: &[SyntaxKind]) -> bool {
+    while let (Some(parent), [kind, rest @ ..]) = (&node.parent(), kinds) {
+        if parent.kind() != *kind {
+            return false;
+        }
+
+        // FIXME: Would be nice to get parent out of the match, but binding by-move and by-value
+        // in the same pattern is unstable: rust-lang/rust#68354.
+        node = node.parent().unwrap().into();
+        kinds = rest;
+    }
+
+    // Only true if we matched all expected kinds
+    kinds.len() == 0
+}
+
+fn is_child_of_impl(element: &SyntaxElement) -> bool {
+    match element.parent() {
+        Some(e) => e.kind() == IMPL,
+        _ => false,
+    }
+}
diff --git a/crates/ide/src/syntax_highlighting/highlights.rs b/crates/ide/src/syntax_highlighting/highlights.rs
new file mode 100644
index 000000000..c6f0417ec
--- /dev/null
+++ b/crates/ide/src/syntax_highlighting/highlights.rs
@@ -0,0 +1,102 @@
+//! Collects a tree of highlighted ranges and flattens it.
+use std::{cmp::Ordering, iter};
+
+use stdx::equal_range_by;
+use syntax::TextRange;
+
+use crate::{HlRange, HlTag};
+
+pub(super) struct Highlights {
+    root: Node,
+}
+
+struct Node {
+    hl_range: HlRange,
+    nested: Vec<Node>,
+}
+
+impl Highlights {
+    pub(super) fn new(range: TextRange) -> Highlights {
+        Highlights {
+            root: Node::new(HlRange { range, highlight: HlTag::None.into(), binding_hash: None }),
+        }
+    }
+
+    pub(super) fn add(&mut self, hl_range: HlRange) {
+        self.root.add(hl_range);
+    }
+
+    pub(super) fn to_vec(self) -> Vec<HlRange> {
+        let mut res = Vec::new();
+        self.root.flatten(&mut res);
+        res
+    }
+}
+
+impl Node {
+    fn new(hl_range: HlRange) -> Node {
+        Node { hl_range, nested: Vec::new() }
+    }
+
+    fn add(&mut self, hl_range: HlRange) {
+        assert!(self.hl_range.range.contains_range(hl_range.range));
+
+        // Fast path
+        if let Some(last) = self.nested.last_mut() {
+            if last.hl_range.range.contains_range(hl_range.range) {
+                return last.add(hl_range);
+            }
+            if last.hl_range.range.end() <= hl_range.range.start() {
+                return self.nested.push(Node::new(hl_range));
+            }
+        }
+
+        let overlapping =
+            equal_range_by(&self.nested, |n| ordering(n.hl_range.range, hl_range.range));
+
+        if overlapping.len() == 1
+            && self.nested[overlapping.start].hl_range.range.contains_range(hl_range.range)
+        {
+            return self.nested[overlapping.start].add(hl_range);
+        }
+
+        let nested = self
+            .nested
+            .splice(overlapping.clone(), iter::once(Node::new(hl_range)))
+            .collect::<Vec<_>>();
+        self.nested[overlapping.start].nested = nested;
+    }
+
+    fn flatten(&self, acc: &mut Vec<HlRange>) {
+        let mut start = self.hl_range.range.start();
+        let mut nested = self.nested.iter();
+        loop {
+            let next = nested.next();
+            let end = next.map_or(self.hl_range.range.end(), |it| it.hl_range.range.start());
+            if start < end {
+                acc.push(HlRange {
+                    range: TextRange::new(start, end),
+                    highlight: self.hl_range.highlight,
+                    binding_hash: self.hl_range.binding_hash,
+                });
+            }
+            start = match next {
+                Some(child) => {
+                    child.flatten(acc);
+                    child.hl_range.range.end()
+                }
+                None => break,
+            }
+        }
+    }
+}
+
+pub(super) fn ordering(r1: TextRange, r2: TextRange) -> Ordering {
+    if r1.end() <= r2.start() {
+        Ordering::Less
+    } else if r2.end() <= r1.start() {
+        Ordering::Greater
+    } else {
+        Ordering::Equal
+    }
+}
diff --git a/crates/ide/src/syntax_highlighting/html.rs b/crates/ide/src/syntax_highlighting/html.rs
index 99ba3a59d..0ee7bc96e 100644
--- a/crates/ide/src/syntax_highlighting/html.rs
+++ b/crates/ide/src/syntax_highlighting/html.rs
@@ -3,7 +3,7 @@
 use ide_db::base_db::SourceDatabase;
 use oorandom::Rand32;
 use stdx::format_to;
-use syntax::{AstNode, TextRange, TextSize};
+use syntax::AstNode;
 
 use crate::{syntax_highlighting::highlight, FileId, RootDatabase};
 
@@ -20,35 +20,27 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
         )
     }
 
-    let ranges = highlight(db, file_id, None, false);
+    let hl_ranges = highlight(db, file_id, None, false);
     let text = parse.tree().syntax().to_string();
-    let mut prev_pos = TextSize::from(0);
     let mut buf = String::new();
     buf.push_str(&STYLE);
     buf.push_str("<pre><code>");
-    for range in &ranges {
-        if range.range.start() > prev_pos {
-            let curr = &text[TextRange::new(prev_pos, range.range.start())];
-            let text = html_escape(curr);
-            buf.push_str(&text);
+    for r in &hl_ranges {
+        let chunk = html_escape(&text[r.range]);
+        if r.highlight.is_empty() {
+            format_to!(buf, "{}", chunk);
+            continue;
         }
-        let curr = &text[TextRange::new(range.range.start(), range.range.end())];
 
-        let class = range.highlight.to_string().replace('.', " ");
-        let color = match (rainbow, range.binding_hash) {
+        let class = r.highlight.to_string().replace('.', " ");
+        let color = match (rainbow, r.binding_hash) {
             (true, Some(hash)) => {
                 format!(" data-binding-hash=\"{}\" style=\"color: {};\"", hash, rainbowify(hash))
             }
             _ => "".into(),
         };
-        format_to!(buf, "<span class=\"{}\"{}>{}</span>", class, color, html_escape(curr));
-
-        prev_pos = range.range.end();
+        format_to!(buf, "<span class=\"{}\"{}>{}</span>", class, color, chunk);
     }
-    // Add the remaining (non-highlighted) text
-    let curr = &text[TextRange::new(prev_pos, TextSize::of(&text))];
-    let text = html_escape(curr);
-    buf.push_str(&text);
     buf.push_str("</code></pre>");
     buf
 }
diff --git a/crates/ide/src/syntax_highlighting/inject.rs b/crates/ide/src/syntax_highlighting/inject.rs
new file mode 100644
index 000000000..281461493
--- /dev/null
+++ b/crates/ide/src/syntax_highlighting/inject.rs
@@ -0,0 +1,158 @@
+//! "Recursive" Syntax highlighting for code in doctests and fixtures.
+
+use hir::Semantics;
+use ide_db::call_info::ActiveParameter;
+use syntax::{ast, AstToken, SyntaxNode, SyntaxToken, TextRange, TextSize};
+
+use crate::{Analysis, HlMod, HlRange, HlTag, RootDatabase};
+
+use super::{highlights::Highlights, injector::Injector};
+
+pub(super) fn ra_fixture(
+    hl: &mut Highlights,
+    sema: &Semantics<RootDatabase>,
+    literal: ast::String,
+    expanded: SyntaxToken,
+) -> Option<()> {
+    let active_parameter = ActiveParameter::at_token(&sema, expanded)?;
+    if !active_parameter.name.starts_with("ra_fixture") {
+        return None;
+    }
+    let value = literal.value()?;
+
+    if let Some(range) = literal.open_quote_text_range() {
+        hl.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
+    }
+
+    let mut inj = Injector::default();
+
+    let mut text = &*value;
+    let mut offset: TextSize = 0.into();
+
+    while !text.is_empty() {
+        let marker = "$0";
+        let idx = text.find(marker).unwrap_or(text.len());
+        let (chunk, next) = text.split_at(idx);
+        inj.add(chunk, TextRange::at(offset, TextSize::of(chunk)));
+
+        text = next;
+        offset += TextSize::of(chunk);
+
+        if let Some(next) = text.strip_prefix(marker) {
+            if let Some(range) = literal.map_range_up(TextRange::at(offset, TextSize::of(marker))) {
+                hl.add(HlRange { range, highlight: HlTag::Keyword.into(), binding_hash: None });
+            }
+
+            text = next;
+
+            let marker_len = TextSize::of(marker);
+            offset += marker_len;
+        }
+    }
+
+    let (analysis, tmp_file_id) = Analysis::from_single_file(inj.text().to_string());
+
+    for mut hl_range in analysis.highlight(tmp_file_id).unwrap() {
+        for range in inj.map_range_up(hl_range.range) {
+            if let Some(range) = literal.map_range_up(range) {
+                hl_range.range = range;
+                hl.add(hl_range.clone());
+            }
+        }
+    }
+
+    if let Some(range) = literal.close_quote_text_range() {
+        hl.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
+    }
+
+    Some(())
+}
+
+const RUSTDOC_FENCE: &'static str = "```";
+const RUSTDOC_FENCE_TOKENS: &[&'static str] = &[
+    "",
+    "rust",
+    "should_panic",
+    "ignore",
+    "no_run",
+    "compile_fail",
+    "edition2015",
+    "edition2018",
+    "edition2021",
+];
+
+/// Injection of syntax highlighting of doctests.
+pub(super) fn doc_comment(hl: &mut Highlights, node: &SyntaxNode) {
+    let doc_comments = node
+        .children_with_tokens()
+        .filter_map(|it| it.into_token().and_then(ast::Comment::cast))
+        .filter(|it| it.kind().doc.is_some());
+
+    if !doc_comments.clone().any(|it| it.text().contains(RUSTDOC_FENCE)) {
+        return;
+    }
+
+    let mut inj = Injector::default();
+    inj.add_unmapped("fn doctest() {\n");
+
+    let mut is_codeblock = false;
+    let mut is_doctest = false;
+
+    // Replace the original, line-spanning comment ranges by new, only comment-prefix
+    // spanning comment ranges.
+    let mut new_comments = Vec::new();
+    for comment in doc_comments {
+        match comment.text().find(RUSTDOC_FENCE) {
+            Some(idx) => {
+                is_codeblock = !is_codeblock;
+                // Check whether code is rust by inspecting fence guards
+                let guards = &comment.text()[idx + RUSTDOC_FENCE.len()..];
+                let is_rust =
+                    guards.split(',').all(|sub| RUSTDOC_FENCE_TOKENS.contains(&sub.trim()));
+                is_doctest = is_codeblock && is_rust;
+                continue;
+            }
+            None if !is_doctest => continue,
+            None => (),
+        }
+
+        let line: &str = comment.text().as_str();
+        let range = comment.syntax().text_range();
+
+        let mut pos = TextSize::of(comment.prefix());
+        // whitespace after comment is ignored
+        if let Some(ws) = line[pos.into()..].chars().next().filter(|c| c.is_whitespace()) {
+            pos += TextSize::of(ws);
+        }
+        // lines marked with `#` should be ignored in output, we skip the `#` char
+        if let Some(ws) = line[pos.into()..].chars().next().filter(|&c| c == '#') {
+            pos += TextSize::of(ws);
+        }
+
+        new_comments.push(TextRange::at(range.start(), pos));
+
+        inj.add(&line[pos.into()..], TextRange::new(range.start() + pos, range.end()));
+        inj.add_unmapped("\n");
+    }
+    inj.add_unmapped("\n}");
+
+    let (analysis, tmp_file_id) = Analysis::from_single_file(inj.text().to_string());
+
+    for h in analysis.with_db(|db| super::highlight(db, tmp_file_id, None, true)).unwrap() {
+        for r in inj.map_range_up(h.range) {
+            hl.add(HlRange {
+                range: r,
+                highlight: h.highlight | HlMod::Injected,
+                binding_hash: h.binding_hash,
+            });
+        }
+    }
+
+    for range in new_comments {
+        hl.add(HlRange {
+            range,
+            highlight: HlTag::Comment | HlMod::Documentation,
+            binding_hash: None,
+        });
+    }
+}
diff --git a/crates/ide/src/syntax_highlighting/injection.rs b/crates/ide/src/syntax_highlighting/injection.rs
deleted file mode 100644
index 6cbd683c6..000000000
--- a/crates/ide/src/syntax_highlighting/injection.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-//! Syntax highlighting injections such as highlighting of documentation tests.
-
-use std::{collections::BTreeMap, convert::TryFrom};
-
-use hir::Semantics;
-use ide_db::call_info::ActiveParameter;
-use itertools::Itertools;
-use syntax::{ast, AstToken, SyntaxNode, SyntaxToken, TextRange, TextSize};
-
-use crate::{Analysis, Highlight, HighlightModifier, HighlightTag, HighlightedRange, RootDatabase};
-
-use super::HighlightedRangeStack;
-
-pub(super) fn highlight_injection(
-    acc: &mut HighlightedRangeStack,
-    sema: &Semantics<RootDatabase>,
-    literal: ast::String,
-    expanded: SyntaxToken,
-) -> Option<()> {
-    let active_parameter = ActiveParameter::at_token(&sema, expanded)?;
-    if !active_parameter.name.starts_with("ra_fixture") {
-        return None;
-    }
-    let value = literal.value()?;
-    let (analysis, tmp_file_id) = Analysis::from_single_file(value.into_owned());
-
-    if let Some(range) = literal.open_quote_text_range() {
-        acc.add(HighlightedRange {
-            range,
-            highlight: HighlightTag::StringLiteral.into(),
-            binding_hash: None,
-        })
-    }
-
-    for mut h in analysis.highlight(tmp_file_id).unwrap() {
-        if let Some(r) = literal.map_range_up(h.range) {
-            h.range = r;
-            acc.add(h)
-        }
-    }
-
-    if let Some(range) = literal.close_quote_text_range() {
-        acc.add(HighlightedRange {
-            range,
-            highlight: HighlightTag::StringLiteral.into(),
-            binding_hash: None,
-        })
-    }
-
-    Some(())
-}
-
-/// Mapping from extracted documentation code to original code
-type RangesMap = BTreeMap<TextSize, TextSize>;
-
-const RUSTDOC_FENCE: &'static str = "```";
-const RUSTDOC_FENCE_TOKENS: &[&'static str] = &[
-    "",
-    "rust",
-    "should_panic",
-    "ignore",
-    "no_run",
-    "compile_fail",
-    "edition2015",
-    "edition2018",
-    "edition2021",
-];
-
-/// Extracts Rust code from documentation comments as well as a mapping from
-/// the extracted source code back to the original source ranges.
-/// Lastly, a vector of new comment highlight ranges (spanning only the
-/// comment prefix) is returned which is used in the syntax highlighting
-/// injection to replace the previous (line-spanning) comment ranges.
-pub(super) fn extract_doc_comments(
-    node: &SyntaxNode,
-) -> Option<(String, RangesMap, Vec<HighlightedRange>)> {
-    // wrap the doctest into function body to get correct syntax highlighting
-    let prefix = "fn doctest() {\n";
-    let suffix = "}\n";
-    // Mapping from extracted documentation code to original code
-    let mut range_mapping: RangesMap = BTreeMap::new();
-    let mut line_start = TextSize::try_from(prefix.len()).unwrap();
-    let mut is_codeblock = false;
-    let mut is_doctest = false;
-    // Replace the original, line-spanning comment ranges by new, only comment-prefix
-    // spanning comment ranges.
-    let mut new_comments = Vec::new();
-    let doctest = node
-        .children_with_tokens()
-        .filter_map(|el| el.into_token().and_then(ast::Comment::cast))
-        .filter(|comment| comment.kind().doc.is_some())
-        .filter(|comment| {
-            if let Some(idx) = comment.text().find(RUSTDOC_FENCE) {
-                is_codeblock = !is_codeblock;
-                // Check whether code is rust by inspecting fence guards
-                let guards = &comment.text()[idx + RUSTDOC_FENCE.len()..];
-                let is_rust =
-                    guards.split(',').all(|sub| RUSTDOC_FENCE_TOKENS.contains(&sub.trim()));
-                is_doctest = is_codeblock && is_rust;
-                false
-            } else {
-                is_doctest
-            }
-        })
-        .map(|comment| {
-            let prefix_len = comment.prefix().len();
-            let line: &str = comment.text().as_str();
-            let range = comment.syntax().text_range();
-
-            // whitespace after comment is ignored
-            let pos = if let Some(ws) = line.chars().nth(prefix_len).filter(|c| c.is_whitespace()) {
-                prefix_len + ws.len_utf8()
-            } else {
-                prefix_len
-            };
-
-            // lines marked with `#` should be ignored in output, we skip the `#` char
-            let pos = if let Some(ws) = line.chars().nth(pos).filter(|&c| c == '#') {
-                pos + ws.len_utf8()
-            } else {
-                pos
-            };
-
-            range_mapping.insert(line_start, range.start() + TextSize::try_from(pos).unwrap());
-            new_comments.push(HighlightedRange {
-                range: TextRange::new(
-                    range.start(),
-                    range.start() + TextSize::try_from(pos).unwrap(),
-                ),
-                highlight: HighlightTag::Comment | HighlightModifier::Documentation,
-                binding_hash: None,
-            });
-            line_start += range.len() - TextSize::try_from(pos).unwrap();
-            line_start += TextSize::try_from('\n'.len_utf8()).unwrap();
-
-            line[pos..].to_owned()
-        })
-        .join("\n");
-
-    if doctest.is_empty() {
-        return None;
-    }
-
-    let doctest = format!("{}{}{}", prefix, doctest, suffix);
-    Some((doctest, range_mapping, new_comments))
-}
-
-/// Injection of syntax highlighting of doctests.
-pub(super) fn highlight_doc_comment(
-    text: String,
-    range_mapping: RangesMap,
-    new_comments: Vec<HighlightedRange>,
-    stack: &mut HighlightedRangeStack,
-) {
-    let (analysis, tmp_file_id) = Analysis::from_single_file(text);
-
-    stack.push();
-    for mut h in analysis.with_db(|db| super::highlight(db, tmp_file_id, None, true)).unwrap() {
-        // Determine start offset and end offset in case of multi-line ranges
-        let mut start_offset = None;
-        let mut end_offset = None;
-        for (line_start, orig_line_start) in range_mapping.range(..h.range.end()).rev() {
-            // It's possible for orig_line_start - line_start to be negative. Add h.range.start()
-            // here and remove it from the end range after the loop below so that the values are
-            // always non-negative.
-            let offset = h.range.start() + orig_line_start - line_start;
-            if line_start <= &h.range.start() {
-                start_offset.get_or_insert(offset);
-                break;
-            } else {
-                end_offset.get_or_insert(offset);
-            }
-        }
-        if let Some(start_offset) = start_offset {
-            h.range = TextRange::new(
-                start_offset,
-                h.range.end() + end_offset.unwrap_or(start_offset) - h.range.start(),
-            );
-
-            h.highlight |= HighlightModifier::Injected;
-            stack.add(h);
-        }
-    }
-
-    // Inject the comment prefix highlight ranges
-    stack.push();
-    for comment in new_comments {
-        stack.add(comment);
-    }
-    stack.pop_and_inject(None);
-    stack.pop_and_inject(Some(Highlight::from(HighlightTag::Dummy) | HighlightModifier::Injected));
-}
diff --git a/crates/ide/src/syntax_highlighting/injector.rs b/crates/ide/src/syntax_highlighting/injector.rs
new file mode 100644
index 000000000..fd4025694
--- /dev/null
+++ b/crates/ide/src/syntax_highlighting/injector.rs
@@ -0,0 +1,80 @@
+//! Extracts a subsequence of a text document, remembering the mapping of ranges
+//! between original and extracted texts.
+use std::ops::{self, Sub};
+
+use stdx::equal_range_by;
+use syntax::{TextRange, TextSize};
+
+use super::highlights::ordering;
+
+#[derive(Default)]
+pub(super) struct Injector {
+    buf: String,
+    ranges: Vec<(TextRange, Option<Delta<TextSize>>)>,
+}
+
+impl Injector {
+    pub(super) fn add(&mut self, text: &str, source_range: TextRange) {
+        let len = TextSize::of(text);
+        assert_eq!(len, source_range.len());
+        self.add_impl(text, Some(source_range.start()));
+    }
+    pub(super) fn add_unmapped(&mut self, text: &str) {
+        self.add_impl(text, None);
+    }
+    fn add_impl(&mut self, text: &str, source: Option<TextSize>) {
+        let len = TextSize::of(text);
+        let target_range = TextRange::at(TextSize::of(&self.buf), len);
+        self.ranges.push((target_range, source.map(|it| Delta::new(target_range.start(), it))));
+        self.buf.push_str(text);
+    }
+
+    pub(super) fn text(&self) -> &str {
+        &self.buf
+    }
+    pub(super) fn map_range_up(&self, range: TextRange) -> impl Iterator<Item = TextRange> + '_ {
+        equal_range_by(&self.ranges, |&(r, _)| ordering(r, range)).filter_map(move |i| {
+            let (target_range, delta) = self.ranges[i];
+            let intersection = target_range.intersect(range).unwrap();
+            Some(intersection + delta?)
+        })
+    }
+}
+
+#[derive(Clone, Copy)]
+enum Delta<T> {
+    Add(T),
+    Sub(T),
+}
+
+impl<T> Delta<T> {
+    fn new(from: T, to: T) -> Delta<T>
+    where
+        T: Ord + Sub<Output = T>,
+    {
+        if to >= from {
+            Delta::Add(to - from)
+        } else {
+            Delta::Sub(from - to)
+        }
+    }
+}
+
+impl ops::Add<Delta<TextSize>> for TextSize {
+    type Output = TextSize;
+
+    fn add(self, rhs: Delta<TextSize>) -> TextSize {
+        match rhs {
+            Delta::Add(it) => self + it,
+            Delta::Sub(it) => self - it,
+        }
+    }
+}
+
+impl ops::Add<Delta<TextSize>> for TextRange {
+    type Output = TextRange;
+
+    fn add(self, rhs: Delta<TextSize>) -> TextRange {
+        TextRange::at(self.start() + rhs, self.len())
+    }
+}
diff --git a/crates/ide/src/syntax_highlighting/macro_rules.rs b/crates/ide/src/syntax_highlighting/macro_rules.rs
index 4462af47e..44620e912 100644
--- a/crates/ide/src/syntax_highlighting/macro_rules.rs
+++ b/crates/ide/src/syntax_highlighting/macro_rules.rs
@@ -1,7 +1,7 @@
 //! Syntax highlighting for macro_rules!.
 use syntax::{SyntaxElement, SyntaxKind, SyntaxToken, TextRange, T};
 
-use crate::{HighlightTag, HighlightedRange};
+use crate::{HlRange, HlTag};
 
 #[derive(Default)]
 pub(super) struct MacroRulesHighlighter {
@@ -19,13 +19,13 @@ impl MacroRulesHighlighter {
         }
     }
 
-    pub(super) fn highlight(&self, element: SyntaxElement) -> Option<HighlightedRange> {
+    pub(super) fn highlight(&self, element: SyntaxElement) -> Option<HlRange> {
         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 {
+                    return Some(HlRange {
                         range,
-                        highlight: HighlightTag::UnresolvedReference.into(),
+                        highlight: HlTag::UnresolvedReference.into(),
                         binding_hash: None,
                     });
                 }
@@ -119,7 +119,7 @@ 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) {
+            if let Some(_dollar) = tok.prev_token().filter(|t| t.kind() == T![$]) {
                 return Some(tok.text_range());
             }
         }
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index 8b8867079..8dd05ac52 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -7,15 +7,15 @@ use crate::SymbolKind;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Highlight {
-    pub tag: HighlightTag,
-    pub modifiers: HighlightModifiers,
+    pub tag: HlTag,
+    pub mods: HlMods,
 }
 
 #[derive(Default, Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct HighlightModifiers(u32);
+pub struct HlMods(u32);
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum HighlightTag {
+pub enum HlTag {
     Symbol(SymbolKind),
 
     BoolLiteral,
@@ -29,17 +29,17 @@ pub enum HighlightTag {
     EscapeSequence,
     FormatSpecifier,
     Keyword,
-    Punctuation,
+    Punctuation(HlPunct),
     Operator,
     UnresolvedReference,
 
-    // For things which don't have proper Tag, but want to use modifiers.
-    Dummy,
+    // For things which don't have a specific highlight.
+    None,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[repr(u8)]
-pub enum HighlightModifier {
+pub enum HlMod {
     /// Used to differentiate individual elements within attributes.
     Attribute = 0,
     /// Used with keywords like `if` and `break`.
@@ -61,10 +61,32 @@ pub enum HighlightModifier {
     Unsafe,
 }
 
-impl HighlightTag {
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum HlPunct {
+    /// []
+    Bracket,
+    /// {}
+    Brace,
+    /// ()
+    Parenthesis,
+    /// <>
+    Angle,
+    /// ,
+    Comma,
+    /// .
+    Dot,
+    /// :
+    Colon,
+    /// ;
+    Semi,
+    ///
+    Other,
+}
+
+impl HlTag {
     fn as_str(self) -> &'static str {
         match self {
-            HighlightTag::Symbol(symbol) => match symbol {
+            HlTag::Symbol(symbol) => match symbol {
                 SymbolKind::Const => "constant",
                 SymbolKind::Static => "static",
                 SymbolKind::Enum => "enum",
@@ -86,59 +108,69 @@ impl HighlightTag {
                 SymbolKind::SelfParam => "self_keyword",
                 SymbolKind::Impl => "self_type",
             },
-            HighlightTag::Attribute => "attribute",
-            HighlightTag::BoolLiteral => "bool_literal",
-            HighlightTag::BuiltinType => "builtin_type",
-            HighlightTag::ByteLiteral => "byte_literal",
-            HighlightTag::CharLiteral => "char_literal",
-            HighlightTag::Comment => "comment",
-            HighlightTag::EscapeSequence => "escape_sequence",
-            HighlightTag::FormatSpecifier => "format_specifier",
-            HighlightTag::Dummy => "dummy",
-            HighlightTag::Keyword => "keyword",
-            HighlightTag::Punctuation => "punctuation",
-            HighlightTag::NumericLiteral => "numeric_literal",
-            HighlightTag::Operator => "operator",
-            HighlightTag::StringLiteral => "string_literal",
-            HighlightTag::UnresolvedReference => "unresolved_reference",
+            HlTag::Attribute => "attribute",
+            HlTag::BoolLiteral => "bool_literal",
+            HlTag::BuiltinType => "builtin_type",
+            HlTag::ByteLiteral => "byte_literal",
+            HlTag::CharLiteral => "char_literal",
+            HlTag::Comment => "comment",
+            HlTag::EscapeSequence => "escape_sequence",
+            HlTag::FormatSpecifier => "format_specifier",
+            HlTag::Keyword => "keyword",
+            HlTag::Punctuation(punct) => match punct {
+                HlPunct::Bracket => "bracket",
+                HlPunct::Brace => "brace",
+                HlPunct::Parenthesis => "parenthesis",
+                HlPunct::Angle => "angle",
+                HlPunct::Comma => "comma",
+                HlPunct::Dot => "dot",
+                HlPunct::Colon => "colon",
+                HlPunct::Semi => "semicolon",
+                HlPunct::Other => "punctuation",
+            },
+            HlTag::NumericLiteral => "numeric_literal",
+            HlTag::Operator => "operator",
+            HlTag::StringLiteral => "string_literal",
+            HlTag::UnresolvedReference => "unresolved_reference",
+            HlTag::None => "none",
         }
     }
 }
 
-impl fmt::Display for HighlightTag {
+impl fmt::Display for HlTag {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(self.as_str(), f)
     }
 }
 
-impl HighlightModifier {
-    const ALL: &'static [HighlightModifier; HighlightModifier::Unsafe as u8 as usize + 1] = &[
-        HighlightModifier::Attribute,
-        HighlightModifier::ControlFlow,
-        HighlightModifier::Definition,
-        HighlightModifier::Documentation,
-        HighlightModifier::Injected,
-        HighlightModifier::Mutable,
-        HighlightModifier::Consuming,
-        HighlightModifier::Callable,
-        HighlightModifier::Static,
-        HighlightModifier::Associated,
-        HighlightModifier::Unsafe,
+impl HlMod {
+    const ALL: &'static [HlMod; HlMod::Unsafe as u8 as usize + 1] = &[
+        HlMod::Attribute,
+        HlMod::ControlFlow,
+        HlMod::Definition,
+        HlMod::Documentation,
+        HlMod::Injected,
+        HlMod::Mutable,
+        HlMod::Consuming,
+        HlMod::Callable,
+        HlMod::Static,
+        HlMod::Associated,
+        HlMod::Unsafe,
     ];
 
     fn as_str(self) -> &'static str {
         match self {
-            HighlightModifier::Attribute => "attribute",
-            HighlightModifier::ControlFlow => "control",
-            HighlightModifier::Definition => "declaration",
-            HighlightModifier::Documentation => "documentation",
-            HighlightModifier::Injected => "injected",
-            HighlightModifier::Mutable => "mutable",
-            HighlightModifier::Consuming => "consuming",
-            HighlightModifier::Unsafe => "unsafe",
-            HighlightModifier::Callable => "callable",
-            HighlightModifier::Static => "static",
-            HighlightModifier::Associated => "associated",
+            HlMod::Attribute => "attribute",
+            HlMod::ControlFlow => "control",
+            HlMod::Definition => "declaration",
+            HlMod::Documentation => "documentation",
+            HlMod::Injected => "injected",
+            HlMod::Mutable => "mutable",
+            HlMod::Consuming => "consuming",
+            HlMod::Unsafe => "unsafe",
+            HlMod::Callable => "callable",
+            HlMod::Static => "static",
+            HlMod::Associated => "associated",
         }
     }
 
@@ -147,7 +179,7 @@ impl HighlightModifier {
     }
 }
 
-impl fmt::Display for HighlightModifier {
+impl fmt::Display for HlMod {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(self.as_str(), f)
     }
@@ -156,60 +188,63 @@ impl fmt::Display for HighlightModifier {
 impl fmt::Display for Highlight {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.tag)?;
-        for modifier in self.modifiers.iter() {
+        for modifier in self.mods.iter() {
             write!(f, ".{}", modifier)?
         }
         Ok(())
     }
 }
 
-impl From<HighlightTag> for Highlight {
-    fn from(tag: HighlightTag) -> Highlight {
+impl From<HlTag> for Highlight {
+    fn from(tag: HlTag) -> Highlight {
         Highlight::new(tag)
     }
 }
 
 impl Highlight {
-    pub(crate) fn new(tag: HighlightTag) -> Highlight {
-        Highlight { tag, modifiers: HighlightModifiers::default() }
+    pub(crate) fn new(tag: HlTag) -> Highlight {
+        Highlight { tag, mods: HlMods::default() }
+    }
+    pub fn is_empty(&self) -> bool {
+        self.tag == HlTag::None && self.mods == HlMods::default()
     }
 }
 
-impl ops::BitOr<HighlightModifier> for HighlightTag {
+impl ops::BitOr<HlMod> for HlTag {
     type Output = Highlight;
 
-    fn bitor(self, rhs: HighlightModifier) -> Highlight {
+    fn bitor(self, rhs: HlMod) -> Highlight {
         Highlight::new(self) | rhs
     }
 }
 
-impl ops::BitOrAssign<HighlightModifier> for HighlightModifiers {
-    fn bitor_assign(&mut self, rhs: HighlightModifier) {
+impl ops::BitOrAssign<HlMod> for HlMods {
+    fn bitor_assign(&mut self, rhs: HlMod) {
         self.0 |= rhs.mask();
     }
 }
 
-impl ops::BitOrAssign<HighlightModifier> for Highlight {
-    fn bitor_assign(&mut self, rhs: HighlightModifier) {
-        self.modifiers |= rhs;
+impl ops::BitOrAssign<HlMod> for Highlight {
+    fn bitor_assign(&mut self, rhs: HlMod) {
+        self.mods |= rhs;
     }
 }
 
-impl ops::BitOr<HighlightModifier> for Highlight {
+impl ops::BitOr<HlMod> for Highlight {
     type Output = Highlight;
 
-    fn bitor(mut self, rhs: HighlightModifier) -> Highlight {
+    fn bitor(mut self, rhs: HlMod) -> Highlight {
         self |= rhs;
         self
     }
 }
 
-impl HighlightModifiers {
-    pub fn contains(self, m: HighlightModifier) -> bool {
+impl HlMods {
+    pub fn contains(self, m: HlMod) -> bool {
         self.0 & m.mask() == m.mask()
     }
 
-    pub fn iter(self) -> impl Iterator<Item = HighlightModifier> {
-        HighlightModifier::ALL.iter().copied().filter(move |it| self.0 & it.mask() == it.mask())
+    pub fn iter(self) -> impl Iterator<Item = HlMod> {
+        HlMod::ALL.iter().copied().filter(move |it| self.0 & it.mask() == it.mask())
     }
 }
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
index 506ebe60e..e36e6fc3f 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_assoc_functions.html
@@ -36,22 +36,22 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">fn</span> <span class="function declaration">not_static</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+<pre><code><span class="keyword">fn</span> <span class="function declaration">not_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 
-<span class="keyword">struct</span> <span class="struct declaration">foo</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+<span class="keyword">struct</span> <span class="struct declaration">foo</span> <span class="brace">{</span><span class="brace">}</span>
 
-<span class="keyword">impl</span> <span class="struct">foo</span> <span class="punctuation">{</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration static associated">is_static</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">is_not_static</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-<span class="punctuation">}</span>
+<span class="keyword">impl</span> <span class="struct">foo</span> <span class="brace">{</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration static associated">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="keyword">trait</span> <span class="trait declaration">t</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration static associated">t_is_static</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">t_is_not_static</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-<span class="punctuation">}</span>
+<span class="keyword">trait</span> <span class="trait declaration">t</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function declaration static associated">t_is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">t_is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="keyword">impl</span> <span class="trait">t</span> <span class="keyword">for</span> <span class="struct">foo</span> <span class="punctuation">{</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration static associated">is_static</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">is_not_static</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-<span class="punctuation">}</span>
+<span class="keyword">impl</span> <span class="trait">t</span> <span class="keyword">for</span> <span class="struct">foo</span> <span class="brace">{</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration static associated">is_static</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">is_not_static</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="brace">}</span>
         </code></pre>
\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
index 4dd7413ba..6dadda1c1 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
@@ -37,67 +37,72 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
 <pre><code><span class="comment documentation">/// ```</span>
-<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="punctuation injected">_</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="string_literal injected">"early doctests should not go boom"</span><span class="punctuation injected">;</span><span class="punctuation injected">
-</span><span class="comment documentation">/// ```</span>
-<span class="keyword">struct</span> <span class="struct declaration">Foo</span> <span class="punctuation">{</span>
-    <span class="field declaration">bar</span><span class="punctuation">:</span> <span class="builtin_type">bool</span><span class="punctuation">,</span>
-<span class="punctuation">}</span>
+<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="punctuation injected">_</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="string_literal injected">"early doctests should not go boom"</span><span class="semicolon injected">;</span>
+<span class="comment documentation">/// ```</span>
+<span class="keyword">struct</span> <span class="struct declaration">Foo</span> <span class="brace">{</span>
+    <span class="field declaration">bar</span><span class="colon">:</span> <span class="builtin_type">bool</span><span class="comma">,</span>
+<span class="brace">}</span>
 
-<span class="keyword">impl</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration associated">bar</span><span class="punctuation">:</span> <span class="builtin_type">bool</span> <span class="operator">=</span> <span class="bool_literal">true</span><span class="punctuation">;</span>
+<span class="keyword">impl</span> <span class="struct">Foo</span> <span class="brace">{</span>
+    <span class="comment documentation">/// ```</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="punctuation injected">_</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="string_literal injected">"Call me</span>
+    <span class="comment">//    KILLER WHALE</span>
+    <span class="comment documentation">/// </span><span class="string_literal injected">    Ishmael."</span><span class="semicolon injected">;</span>
+    <span class="comment documentation">/// ```</span>
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="constant declaration associated">bar</span><span class="colon">:</span> <span class="builtin_type">bool</span> <span class="operator">=</span> <span class="bool_literal">true</span><span class="semicolon">;</span>
 
     <span class="comment documentation">/// Constructs a new `Foo`.</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// # Examples</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// ```</span>
-    <span class="comment documentation">/// #</span><span class="dummy injected"> </span><span class="attribute attribute injected">#</span><span class="attribute attribute injected">!</span><span class="attribute attribute injected">[</span><span class="function attribute injected">allow</span><span class="punctuation attribute injected">(</span><span class="attribute attribute injected">unused_mut</span><span class="punctuation attribute injected">)</span><span class="attribute attribute injected">]</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="keyword injected">mut</span><span class="dummy injected"> </span><span class="variable declaration injected mutable">foo</span><span class="punctuation injected">:</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
-</span>    <span class="comment documentation">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration static associated">new</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
-        <span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">bar</span><span class="punctuation">:</span> <span class="bool_literal">true</span> <span class="punctuation">}</span>
-    <span class="punctuation">}</span>
+    <span class="comment documentation">/// #</span><span class="none injected"> </span><span class="attribute attribute injected">#</span><span class="attribute attribute injected">!</span><span class="attribute attribute injected">[</span><span class="function attribute injected">allow</span><span class="parenthesis attribute injected">(</span><span class="attribute attribute injected">unused_mut</span><span class="parenthesis attribute injected">)</span><span class="attribute attribute injected">]</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="keyword injected">mut</span><span class="none injected"> </span><span class="variable declaration injected mutable">foo</span><span class="colon injected">:</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
+    <span class="comment documentation">/// ```</span>
+    <span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration static associated">new</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="struct">Foo</span> <span class="brace">{</span>
+        <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">bar</span><span class="colon">:</span> <span class="bool_literal">true</span> <span class="brace">}</span>
+    <span class="brace">}</span>
 
     <span class="comment documentation">/// `bar` method on `Foo`.</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// # Examples</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// ```</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">use</span><span class="dummy injected"> </span><span class="module injected">x</span><span class="operator injected">::</span><span class="module injected">y</span><span class="punctuation injected">;</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">use</span><span class="none injected"> </span><span class="module injected">x</span><span class="operator injected">::</span><span class="module injected">y</span><span class="semicolon injected">;</span>
     <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">foo</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">foo</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// </span><span class="comment injected">// calls bar on foo</span>
-    <span class="comment documentation">/// </span><span class="macro injected">assert!</span><span class="punctuation injected">(</span><span class="dummy injected">foo</span><span class="operator injected">.</span><span class="dummy injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
+    <span class="comment documentation">/// </span><span class="macro injected">assert!</span><span class="parenthesis injected">(</span><span class="none injected">foo</span><span class="operator injected">.</span><span class="none injected">bar</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
     <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">bar</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="variable injected">foo</span><span class="operator injected">.</span><span class="field injected">bar</span><span class="dummy injected"> </span><span class="operator injected">||</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="constant injected">bar</span><span class="punctuation injected">;</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">bar</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="variable injected">foo</span><span class="operator injected">.</span><span class="field injected">bar</span><span class="none injected"> </span><span class="operator injected">||</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="constant injected">bar</span><span class="semicolon injected">;</span>
     <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="comment injected">/* multi-line
-    </span><span class="comment documentation">/// </span><span class="comment injected">       comment */</span>
+    <span class="comment documentation">/// </span><span class="comment injected">/* multi-line</span>
+    <span class="comment documentation">/// </span><span class="comment injected">       comment */</span>
     <span class="comment documentation">///</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">multi_line_string</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="string_literal injected">"Foo
-    </span><span class="comment documentation">/// </span><span class="string_literal injected">  bar
-    </span><span class="comment documentation">/// </span><span class="string_literal injected">         "</span><span class="punctuation injected">;</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">multi_line_string</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="string_literal injected">"Foo</span>
+    <span class="comment documentation">/// </span><span class="string_literal injected">  bar</span>
+    <span class="comment documentation">/// </span><span class="string_literal injected">         "</span><span class="semicolon injected">;</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// ```</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// ```rust,no_run</span>
-    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">foobar</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="operator injected">.</span><span class="function injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
-</span>    <span class="comment documentation">/// ```</span>
+    <span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">foobar</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="operator injected">.</span><span class="function injected">bar</span><span class="parenthesis injected">(</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
+    <span class="comment documentation">/// ```</span>
     <span class="comment documentation">///</span>
     <span class="comment documentation">/// ```sh</span>
     <span class="comment documentation">/// echo 1</span>
     <span class="comment documentation">/// ```</span>
-    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">foo</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">bool</span> <span class="punctuation">{</span>
+    <span class="keyword">pub</span> <span class="keyword">fn</span> <span class="function declaration associated">foo</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">bool</span> <span class="brace">{</span>
         <span class="bool_literal">true</span>
-    <span class="punctuation">}</span>
-<span class="punctuation">}</span>
+    <span class="brace">}</span>
+<span class="brace">}</span>
 
 <span class="comment documentation">/// ```</span>
-<span class="comment documentation">/// </span><span class="macro injected">noop!</span><span class="punctuation injected">(</span><span class="numeric_literal injected">1</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span><span class="punctuation injected">
-</span><span class="comment documentation">/// ```</span>
-<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">noop</span> <span class="punctuation">{</span>
-    <span class="punctuation">(</span><span class="punctuation">$</span>expr<span class="punctuation">:</span>expr<span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
+<span class="comment documentation">/// </span><span class="macro injected">noop!</span><span class="parenthesis injected">(</span><span class="numeric_literal injected">1</span><span class="parenthesis injected">)</span><span class="semicolon injected">;</span>
+<span class="comment documentation">/// ```</span>
+<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">noop</span> <span class="brace">{</span>
+    <span class="parenthesis">(</span><span class="punctuation">$</span>expr<span class="colon">:</span>expr<span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="brace">{</span>
         <span class="punctuation">$</span>expr
-    <span class="punctuation">}</span>
-<span class="punctuation">}</span></code></pre>
\ No newline at end of file
+    <span class="brace">}</span>
+<span class="brace">}</span></code></pre>
\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html b/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
index ed452586a..6f7a7ffff 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_extern_crate.html
@@ -36,6 +36,6 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module">std</span><span class="punctuation">;</span>
-<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module">alloc</span> <span class="keyword">as</span> <span class="module">abc</span><span class="punctuation">;</span>
+<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module">std</span><span class="semicolon">;</span>
+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module">alloc</span> <span class="keyword">as</span> <span class="module">abc</span><span class="semicolon">;</span>
 </code></pre>
\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
index 92e7dc3e4..753b535b5 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_injection.html
@@ -36,14 +36,14 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">fn</span> <span class="function declaration">fixture</span><span class="punctuation">(</span><span class="value_param declaration">ra_fixture</span><span class="punctuation">:</span> <span class="operator">&</span><span class="builtin_type">str</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+<pre><code><span class="keyword">fn</span> <span class="function declaration">fixture</span><span class="parenthesis">(</span><span class="value_param declaration">ra_fixture</span><span class="colon">:</span> <span class="operator">&</span><span class="builtin_type">str</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</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="function">fixture</span><span class="punctuation">(</span><span class="string_literal">r#"</span>
-        <span class="keyword">trait</span> <span class="trait declaration">Foo</span> <span class="punctuation">{</span>
-            <span class="keyword">fn</span> <span class="function declaration static associated">foo</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">"2 + 2 = {}"</span><span class="punctuation">,</span> <span class="numeric_literal">4</span><span class="punctuation">)</span><span class="punctuation">;</span>
-            <span class="punctuation">}</span>
-        <span class="punctuation">}</span><span class="string_literal">"#</span>
-    <span class="punctuation">)</span><span class="punctuation">;</span>
-<span class="punctuation">}</span></code></pre>
\ No newline at end of file
+<span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="function">fixture</span><span class="parenthesis">(</span><span class="string_literal">r#"</span>
+        <span class="keyword">trait</span> <span class="trait declaration">Foo</span> <span class="brace">{</span>
+            <span class="keyword">fn</span> <span class="function declaration static associated">foo</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+                <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"2 + 2 = {}"</span><span class="comma">,</span> <span class="numeric_literal">4</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+            <span class="brace">}</span>
+        <span class="brace">}</span><span class="string_literal">"#</span>
+    <span class="parenthesis">)</span><span class="semicolon">;</span>
+<span class="brace">}</span></code></pre>
\ No newline at end of file
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 31dad5d42..66d80c4b6 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
@@ -36,64 +36,64 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">macro_rules</span><span class="punctuation">!</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>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>
+<pre><code><span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">println</span> <span class="brace">{</span>
+    <span class="parenthesis">(</span><span class="punctuation">$</span><span class="parenthesis">(</span><span class="punctuation">$</span>arg<span class="colon">:</span>tt<span class="parenthesis">)</span><span class="punctuation">*</span><span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="parenthesis">(</span><span class="brace">{</span>
+        <span class="punctuation">$</span>crate<span class="colon">:</span><span class="colon">:</span>io<span class="colon">:</span><span class="colon">:</span>_print<span class="parenthesis">(</span><span class="punctuation">$</span>crate<span class="colon">:</span><span class="colon">:</span>format_args_nl<span class="punctuation">!</span><span class="parenthesis">(</span><span class="punctuation">$</span><span class="parenthesis">(</span><span class="punctuation">$</span>arg<span class="parenthesis">)</span><span class="punctuation">*</span><span class="parenthesis">)</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="brace">}</span><span class="parenthesis">)</span>
+<span class="brace">}</span>
 <span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">rustc_builtin_macro</span><span class="attribute attribute">]</span>
-<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">format_args_nl</span> <span class="punctuation">{</span>
-    <span class="punctuation">(</span><span class="punctuation">$</span>fmt<span class="punctuation">:</span>expr<span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">{</span> <span class="comment">/* compiler built-in */</span> <span class="punctuation">}</span><span class="punctuation">}</span><span class="punctuation">;</span>
-    <span class="punctuation">(</span><span class="punctuation">$</span>fmt<span class="punctuation">:</span>expr<span class="punctuation">,</span> <span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>args<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="comment">/* compiler built-in */</span> <span class="punctuation">}</span><span class="punctuation">}</span><span class="punctuation">;</span>
-<span class="punctuation">}</span>
+<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">format_args_nl</span> <span class="brace">{</span>
+    <span class="parenthesis">(</span><span class="punctuation">$</span>fmt<span class="colon">:</span>expr<span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="brace">{</span><span class="brace">{</span> <span class="comment">/* compiler built-in */</span> <span class="brace">}</span><span class="brace">}</span><span class="semicolon">;</span>
+    <span class="parenthesis">(</span><span class="punctuation">$</span>fmt<span class="colon">:</span>expr<span class="comma">,</span> <span class="punctuation">$</span><span class="parenthesis">(</span><span class="punctuation">$</span>args<span class="colon">:</span>tt<span class="parenthesis">)</span><span class="punctuation">*</span><span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="brace">{</span><span class="brace">{</span> <span class="comment">/* compiler built-in */</span> <span class="brace">}</span><span class="brace">}</span><span class="semicolon">;</span>
+<span class="brace">}</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="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
     <span class="comment">// from https://doc.rust-lang.org/std/fmt/index.html</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello"</span><span class="punctuation">)</span><span class="punctuation">;</span>                 <span class="comment">// =&gt; "Hello"</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"world"</span><span class="punctuation">)</span><span class="punctuation">;</span>   <span class="comment">// =&gt; "Hello, world!"</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"The number is </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">1</span><span class="punctuation">)</span><span class="punctuation">;</span>   <span class="comment">// =&gt; "The number is 1"</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">?</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="punctuation">(</span><span class="numeric_literal">3</span><span class="punctuation">,</span> <span class="numeric_literal">4</span><span class="punctuation">)</span><span class="punctuation">)</span><span class="punctuation">;</span>          <span class="comment">// =&gt; "(3, 4)"</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">value</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> value<span class="operator">=</span><span class="numeric_literal">4</span><span class="punctuation">)</span><span class="punctuation">;</span>      <span class="comment">// =&gt; "4"</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">1</span><span class="punctuation">,</span> <span class="numeric_literal">2</span><span class="punctuation">)</span><span class="punctuation">;</span>           <span class="comment">// =&gt; "1 2"</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">4</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">42</span><span class="punctuation">)</span><span class="punctuation">;</span>             <span class="comment">// =&gt; "0042" with leading zerosV</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">1</span><span class="punctuation">,</span> <span class="numeric_literal">2</span><span class="punctuation">)</span><span class="punctuation">;</span>   <span class="comment">// =&gt; "2 1 1 2"</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">argument</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> argument <span class="operator">=</span> <span class="string_literal">"test"</span><span class="punctuation">)</span><span class="punctuation">;</span>   <span class="comment">// =&gt; "test"</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">1</span><span class="punctuation">,</span> name <span class="operator">=</span> <span class="numeric_literal">2</span><span class="punctuation">)</span><span class="punctuation">;</span>          <span class="comment">// =&gt; "2 1"</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">a</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="variable">c</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="variable">b</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> a<span class="operator">=</span><span class="string_literal">"a"</span><span class="punctuation">,</span> b<span class="operator">=</span><span class="char_literal">'b'</span><span class="punctuation">,</span> c<span class="operator">=</span><span class="numeric_literal">3</span><span class="punctuation">)</span><span class="punctuation">;</span>  <span class="comment">// =&gt; "a 3 b"</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"{{</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">}}"</span><span class="punctuation">,</span> <span class="numeric_literal">2</span><span class="punctuation">)</span><span class="punctuation">;</span>                       <span class="comment">// =&gt; "{2}"</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</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="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">1</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">5</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="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> <span class="string_literal">"x"</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="format_specifier">{</span><span class="format_specifier">:</span><span class="variable">width</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> width <span class="operator">=</span> <span class="numeric_literal">5</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="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">&lt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</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="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">-</span><span class="format_specifier">&lt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</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="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">^</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</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="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">&gt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"x"</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="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">+</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="numeric_literal">27</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="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="numeric_literal">5</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="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="punctuation">-</span><span class="numeric_literal">5</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="numeric_literal">0</span><span class="numeric_literal">10</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="numeric_literal">27</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="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">0.01</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="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">0</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">0.01</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="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">1</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> <span class="numeric_literal">0.01</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="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span>    <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> <span class="numeric_literal">0.01</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="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span>   <span class="string_literal">"x"</span><span class="punctuation">,</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> <span class="numeric_literal">0.01</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="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="variable">number</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="variable">prec</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> <span class="string_literal">"x"</span><span class="punctuation">,</span> prec <span class="operator">=</span> <span class="numeric_literal">5</span><span class="punctuation">,</span> number <span class="operator">=</span> <span class="numeric_literal">0.01</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 fractional digits"</span><span class="punctuation">,</span> <span class="string_literal">"Hello"</span><span class="punctuation">,</span> <span class="numeric_literal">3</span><span class="punctuation">,</span> name<span class="operator">=</span><span class="numeric_literal">1234.56</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 characters"</span><span class="punctuation">,</span> <span class="string_literal">"Hello"</span><span class="punctuation">,</span> <span class="numeric_literal">3</span><span class="punctuation">,</span> name<span class="operator">=</span><span class="string_literal">"1234.56"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">&gt;</span><span class="numeric_literal">8</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 right-aligned characters"</span><span class="punctuation">,</span> <span class="string_literal">"Hello"</span><span class="punctuation">,</span> <span class="numeric_literal">3</span><span class="punctuation">,</span> name<span class="operator">=</span><span class="string_literal">"1234.56"</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="punctuation">;</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"{{ Hello"</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello"</span><span class="parenthesis">)</span><span class="semicolon">;</span>                 <span class="comment">// =&gt; "Hello"</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="string_literal">"world"</span><span class="parenthesis">)</span><span class="semicolon">;</span>   <span class="comment">// =&gt; "Hello, world!"</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"The number is </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> <span class="numeric_literal">1</span><span class="parenthesis">)</span><span class="semicolon">;</span>   <span class="comment">// =&gt; "The number is 1"</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">?</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> <span class="parenthesis">(</span><span class="numeric_literal">3</span><span class="comma">,</span> <span class="numeric_literal">4</span><span class="parenthesis">)</span><span class="parenthesis">)</span><span class="semicolon">;</span>          <span class="comment">// =&gt; "(3, 4)"</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">value</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> value<span class="operator">=</span><span class="numeric_literal">4</span><span class="parenthesis">)</span><span class="semicolon">;</span>      <span class="comment">// =&gt; "4"</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> <span class="numeric_literal">1</span><span class="comma">,</span> <span class="numeric_literal">2</span><span class="parenthesis">)</span><span class="semicolon">;</span>           <span class="comment">// =&gt; "1 2"</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">4</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> <span class="numeric_literal">42</span><span class="parenthesis">)</span><span class="semicolon">;</span>             <span class="comment">// =&gt; "0042" with leading zerosV</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> <span class="numeric_literal">1</span><span class="comma">,</span> <span class="numeric_literal">2</span><span class="parenthesis">)</span><span class="semicolon">;</span>   <span class="comment">// =&gt; "2 1 1 2"</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">argument</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> argument <span class="operator">=</span> <span class="string_literal">"test"</span><span class="parenthesis">)</span><span class="semicolon">;</span>   <span class="comment">// =&gt; "test"</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> <span class="numeric_literal">1</span><span class="comma">,</span> name <span class="operator">=</span> <span class="numeric_literal">2</span><span class="parenthesis">)</span><span class="semicolon">;</span>          <span class="comment">// =&gt; "2 1"</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">a</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="variable">c</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="variable">b</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> a<span class="operator">=</span><span class="string_literal">"a"</span><span class="comma">,</span> b<span class="operator">=</span><span class="char_literal">'b'</span><span class="comma">,</span> c<span class="operator">=</span><span class="numeric_literal">3</span><span class="parenthesis">)</span><span class="semicolon">;</span>  <span class="comment">// =&gt; "a 3 b"</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"{{</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">}}"</span><span class="comma">,</span> <span class="numeric_literal">2</span><span class="parenthesis">)</span><span class="semicolon">;</span>                       <span class="comment">// =&gt; "{2}"</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">1</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="comma">,</span> <span class="numeric_literal">5</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="numeric_literal">5</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="variable">width</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="comma">,</span> width <span class="operator">=</span> <span class="numeric_literal">5</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">&lt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">-</span><span class="format_specifier">&lt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">^</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">&gt;</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">+</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="numeric_literal">5</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="numeric_literal">27</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="numeric_literal">5</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="numeric_literal">0</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="punctuation">-</span><span class="numeric_literal">5</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">#</span><span class="numeric_literal">0</span><span class="numeric_literal">10</span><span class="variable">x</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="numeric_literal">27</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">5</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="comma">,</span> <span class="numeric_literal">0.01</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">1</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">0</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> <span class="numeric_literal">5</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="comma">,</span> <span class="numeric_literal">0.01</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="numeric_literal">0</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="numeric_literal">1</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="comma">,</span> <span class="numeric_literal">5</span><span class="comma">,</span> <span class="numeric_literal">0.01</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span>    <span class="string_literal">"x"</span><span class="comma">,</span> <span class="numeric_literal">5</span><span class="comma">,</span> <span class="numeric_literal">0.01</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="numeric_literal">2</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span>   <span class="string_literal">"x"</span><span class="comma">,</span> <span class="numeric_literal">5</span><span class="comma">,</span> <span class="numeric_literal">0.01</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> is </span><span class="format_specifier">{</span><span class="variable">number</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="variable">prec</span><span class="format_specifier">$</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> <span class="string_literal">"x"</span><span class="comma">,</span> prec <span class="operator">=</span> <span class="numeric_literal">5</span><span class="comma">,</span> number <span class="operator">=</span> <span class="numeric_literal">0.01</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 fractional digits"</span><span class="comma">,</span> <span class="string_literal">"Hello"</span><span class="comma">,</span> <span class="numeric_literal">3</span><span class="comma">,</span> name<span class="operator">=</span><span class="numeric_literal">1234.56</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 characters"</span><span class="comma">,</span> <span class="string_literal">"Hello"</span><span class="comma">,</span> <span class="numeric_literal">3</span><span class="comma">,</span> name<span class="operator">=</span><span class="string_literal">"1234.56"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">, `</span><span class="format_specifier">{</span><span class="variable">name</span><span class="format_specifier">:</span><span class="format_specifier">&gt;</span><span class="numeric_literal">8</span><span class="format_specifier">.</span><span class="format_specifier">*</span><span class="format_specifier">}</span><span class="string_literal">` has 3 right-aligned characters"</span><span class="comma">,</span> <span class="string_literal">"Hello"</span><span class="comma">,</span> <span class="numeric_literal">3</span><span class="comma">,</span> name<span class="operator">=</span><span class="string_literal">"1234.56"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello {{}}"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"{{ Hello"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">r"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="punctuation">,</span> <span class="string_literal">"world"</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">r"Hello, </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal">!"</span><span class="comma">,</span> <span class="string_literal">"world"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
     <span class="comment">// escape sequences</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"Hello</span><span class="escape_sequence">\n</span><span class="string_literal">World"</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="escape_sequence">\u{48}</span><span class="escape_sequence">\x65</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6F</span><span class="string_literal"> World"</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello</span><span class="escape_sequence">\n</span><span class="string_literal">World"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="escape_sequence">\u{48}</span><span class="escape_sequence">\x65</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6C</span><span class="escape_sequence">\x6F</span><span class="string_literal"> World"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="escape_sequence">\x41</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> A <span class="operator">=</span> <span class="numeric_literal">92</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">ничоси</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="punctuation">,</span> ничоси <span class="operator">=</span> <span class="numeric_literal">92</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="escape_sequence">\x41</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> A <span class="operator">=</span> <span class="numeric_literal">92</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="variable">ничоси</span><span class="format_specifier">}</span><span class="string_literal">"</span><span class="comma">,</span> ничоси <span class="operator">=</span> <span class="numeric_literal">92</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
-    <span class="macro">println!</span><span class="punctuation">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="variable">x</span><span class="format_specifier">?</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> "</span><span class="punctuation">,</span> thingy<span class="punctuation">,</span> n2<span class="punctuation">)</span><span class="punctuation">;</span>
-<span class="punctuation">}</span></code></pre>
\ No newline at end of file
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"</span><span class="format_specifier">{</span><span class="format_specifier">:</span><span class="variable">x</span><span class="format_specifier">?</span><span class="format_specifier">}</span><span class="string_literal"> </span><span class="format_specifier">{</span><span class="format_specifier">}</span><span class="string_literal"> "</span><span class="comma">,</span> thingy<span class="comma">,</span> n2<span class="parenthesis">)</span><span class="semicolon">;</span>
+<span class="brace">}</span></code></pre>
\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
index e3a0aa317..9d4d6d4a0 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlight_unsafe.html
@@ -36,65 +36,65 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function declaration unsafe">unsafe_fn</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+<pre><code><span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function declaration unsafe">unsafe_fn</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
 
-<span class="keyword">union</span> <span class="union declaration">Union</span> <span class="punctuation">{</span>
-    <span class="field declaration">a</span><span class="punctuation">:</span> <span class="builtin_type">u32</span><span class="punctuation">,</span>
-    <span class="field declaration">b</span><span class="punctuation">:</span> <span class="builtin_type">f32</span><span class="punctuation">,</span>
-<span class="punctuation">}</span>
+<span class="keyword">union</span> <span class="union declaration">Union</span> <span class="brace">{</span>
+    <span class="field declaration">a</span><span class="colon">:</span> <span class="builtin_type">u32</span><span class="comma">,</span>
+    <span class="field declaration">b</span><span class="colon">:</span> <span class="builtin_type">f32</span><span class="comma">,</span>
+<span class="brace">}</span>
 
-<span class="keyword">struct</span> <span class="struct declaration">HasUnsafeFn</span><span class="punctuation">;</span>
+<span class="keyword">struct</span> <span class="struct declaration">HasUnsafeFn</span><span class="semicolon">;</span>
 
-<span class="keyword">impl</span> <span class="struct">HasUnsafeFn</span> <span class="punctuation">{</span>
-    <span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function declaration associated unsafe">unsafe_method</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-<span class="punctuation">}</span>
+<span class="keyword">impl</span> <span class="struct">HasUnsafeFn</span> <span class="brace">{</span>
+    <span class="keyword unsafe">unsafe</span> <span class="keyword">fn</span> <span class="function declaration associated unsafe">unsafe_method</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="keyword">struct</span> <span class="struct declaration">TypeForStaticMut</span> <span class="punctuation">{</span>
-    <span class="field declaration">a</span><span class="punctuation">:</span> <span class="builtin_type">u8</span>
-<span class="punctuation">}</span>
+<span class="keyword">struct</span> <span class="struct declaration">TypeForStaticMut</span> <span class="brace">{</span>
+    <span class="field declaration">a</span><span class="colon">:</span> <span class="builtin_type">u8</span>
+<span class="brace">}</span>
 
-<span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable unsafe">global_mut</span><span class="punctuation">:</span> <span class="struct">TypeForStaticMut</span> <span class="operator">=</span> <span class="struct">TypeForStaticMut</span> <span class="punctuation">{</span> <span class="field">a</span><span class="punctuation">:</span> <span class="numeric_literal">0</span> <span class="punctuation">}</span><span class="punctuation">;</span>
+<span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable unsafe">global_mut</span><span class="colon">:</span> <span class="struct">TypeForStaticMut</span> <span class="operator">=</span> <span class="struct">TypeForStaticMut</span> <span class="brace">{</span> <span class="field">a</span><span class="colon">:</span> <span class="numeric_literal">0</span> <span class="brace">}</span><span class="semicolon">;</span>
 
-<span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">repr</span><span class="punctuation attribute">(</span><span class="attribute attribute">packed</span><span class="punctuation attribute">)</span><span class="attribute attribute">]</span>
-<span class="keyword">struct</span> <span class="struct declaration">Packed</span> <span class="punctuation">{</span>
-    <span class="field declaration">a</span><span class="punctuation">:</span> <span class="builtin_type">u16</span><span class="punctuation">,</span>
-<span class="punctuation">}</span>
+<span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">repr</span><span class="parenthesis attribute">(</span><span class="attribute attribute">packed</span><span class="parenthesis attribute">)</span><span class="attribute attribute">]</span>
+<span class="keyword">struct</span> <span class="struct declaration">Packed</span> <span class="brace">{</span>
+    <span class="field declaration">a</span><span class="colon">:</span> <span class="builtin_type">u16</span><span class="comma">,</span>
+<span class="brace">}</span>
 
-<span class="keyword">trait</span> <span class="trait declaration">DoTheAutoref</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">calls_autoref</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span><span class="punctuation">;</span>
-<span class="punctuation">}</span>
+<span class="keyword">trait</span> <span class="trait declaration">DoTheAutoref</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">calls_autoref</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+<span class="brace">}</span>
 
-<span class="keyword">impl</span> <span class="trait">DoTheAutoref</span> <span class="keyword">for</span> <span class="builtin_type">u16</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">calls_autoref</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-<span class="punctuation">}</span>
+<span class="keyword">impl</span> <span class="trait">DoTheAutoref</span> <span class="keyword">for</span> <span class="builtin_type">u16</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">calls_autoref</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="brace">}</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="keyword">let</span> <span class="variable declaration">x</span> <span class="operator">=</span> <span class="operator">&</span><span class="numeric_literal">5</span> <span class="keyword">as</span> <span class="keyword">*</span><span class="keyword">const</span> <span class="punctuation">_</span> <span class="keyword">as</span> <span class="keyword">*</span><span class="keyword">const</span> <span class="builtin_type">usize</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration">u</span> <span class="operator">=</span> <span class="union">Union</span> <span class="punctuation">{</span> <span class="field">b</span><span class="punctuation">:</span> <span class="numeric_literal">0</span> <span class="punctuation">}</span><span class="punctuation">;</span>
-    <span class="keyword unsafe">unsafe</span> <span class="punctuation">{</span>
+<span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="keyword">let</span> <span class="variable declaration">x</span> <span class="operator">=</span> <span class="operator">&</span><span class="numeric_literal">5</span> <span class="keyword">as</span> <span class="keyword">*</span><span class="keyword">const</span> <span class="punctuation">_</span> <span class="keyword">as</span> <span class="keyword">*</span><span class="keyword">const</span> <span class="builtin_type">usize</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration">u</span> <span class="operator">=</span> <span class="union">Union</span> <span class="brace">{</span> <span class="field">b</span><span class="colon">:</span> <span class="numeric_literal">0</span> <span class="brace">}</span><span class="semicolon">;</span>
+    <span class="keyword unsafe">unsafe</span> <span class="brace">{</span>
         <span class="comment">// unsafe fn and method calls</span>
-        <span class="function unsafe">unsafe_fn</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-        <span class="keyword">let</span> <span class="variable declaration">b</span> <span class="operator">=</span> <span class="variable">u</span><span class="operator">.</span><span class="field unsafe">b</span><span class="punctuation">;</span>
-        <span class="keyword control">match</span> <span class="variable">u</span> <span class="punctuation">{</span>
-            <span class="union">Union</span> <span class="punctuation">{</span> <span class="field unsafe">b</span><span class="punctuation">:</span> <span class="numeric_literal">0</span> <span class="punctuation">}</span> <span class="operator">=&gt;</span> <span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">,</span>
-            <span class="union">Union</span> <span class="punctuation">{</span> <span class="field unsafe">a</span> <span class="punctuation">}</span> <span class="operator">=&gt;</span> <span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">,</span>
-        <span class="punctuation">}</span>
-        <span class="struct">HasUnsafeFn</span><span class="operator">.</span><span class="function associated unsafe">unsafe_method</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
+        <span class="function unsafe">unsafe_fn</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+        <span class="keyword">let</span> <span class="variable declaration">b</span> <span class="operator">=</span> <span class="variable">u</span><span class="operator">.</span><span class="field unsafe">b</span><span class="semicolon">;</span>
+        <span class="keyword control">match</span> <span class="variable">u</span> <span class="brace">{</span>
+            <span class="union">Union</span> <span class="brace">{</span> <span class="field unsafe">b</span><span class="colon">:</span> <span class="numeric_literal">0</span> <span class="brace">}</span> <span class="operator">=&gt;</span> <span class="parenthesis">(</span><span class="parenthesis">)</span><span class="comma">,</span>
+            <span class="union">Union</span> <span class="brace">{</span> <span class="field unsafe">a</span> <span class="brace">}</span> <span class="operator">=&gt;</span> <span class="parenthesis">(</span><span class="parenthesis">)</span><span class="comma">,</span>
+        <span class="brace">}</span>
+        <span class="struct">HasUnsafeFn</span><span class="operator">.</span><span class="function associated unsafe">unsafe_method</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
         <span class="comment">// unsafe deref</span>
-        <span class="keyword">let</span> <span class="variable declaration">y</span> <span class="operator">=</span> <span class="operator unsafe">*</span><span class="variable">x</span><span class="punctuation">;</span>
+        <span class="keyword">let</span> <span class="variable declaration">y</span> <span class="operator">=</span> <span class="operator unsafe">*</span><span class="variable">x</span><span class="semicolon">;</span>
 
         <span class="comment">// unsafe access to a static mut</span>
-        <span class="keyword">let</span> <span class="variable declaration">a</span> <span class="operator">=</span> <span class="static mutable unsafe">global_mut</span><span class="operator">.</span><span class="field">a</span><span class="punctuation">;</span>
+        <span class="keyword">let</span> <span class="variable declaration">a</span> <span class="operator">=</span> <span class="static mutable unsafe">global_mut</span><span class="operator">.</span><span class="field">a</span><span class="semicolon">;</span>
 
         <span class="comment">// unsafe ref of packed fields</span>
-        <span class="keyword">let</span> <span class="variable declaration">packed</span> <span class="operator">=</span> <span class="struct">Packed</span> <span class="punctuation">{</span> <span class="field">a</span><span class="punctuation">:</span> <span class="numeric_literal">0</span> <span class="punctuation">}</span><span class="punctuation">;</span>
-        <span class="keyword">let</span> <span class="variable declaration">a</span> <span class="operator">=</span> <span class="operator unsafe">&</span><span class="variable">packed</span><span class="operator">.</span><span class="field">a</span><span class="punctuation">;</span>
-        <span class="keyword">let</span> <span class="keyword unsafe">ref</span> <span class="variable declaration">a</span> <span class="operator">=</span> <span class="variable">packed</span><span class="operator">.</span><span class="field">a</span><span class="punctuation">;</span>
-        <span class="keyword">let</span> <span class="struct">Packed</span> <span class="punctuation">{</span> <span class="keyword unsafe">ref</span> <span class="field">a</span> <span class="punctuation">}</span> <span class="operator">=</span> <span class="variable">packed</span><span class="punctuation">;</span>
-        <span class="keyword">let</span> <span class="struct">Packed</span> <span class="punctuation">{</span> <span class="field">a</span><span class="punctuation">:</span> <span class="keyword unsafe">ref</span> <span class="variable declaration">_a</span> <span class="punctuation">}</span> <span class="operator">=</span> <span class="variable">packed</span><span class="punctuation">;</span>
+        <span class="keyword">let</span> <span class="variable declaration">packed</span> <span class="operator">=</span> <span class="struct">Packed</span> <span class="brace">{</span> <span class="field">a</span><span class="colon">:</span> <span class="numeric_literal">0</span> <span class="brace">}</span><span class="semicolon">;</span>
+        <span class="keyword">let</span> <span class="variable declaration">a</span> <span class="operator">=</span> <span class="operator unsafe">&</span><span class="variable">packed</span><span class="operator">.</span><span class="field">a</span><span class="semicolon">;</span>
+        <span class="keyword">let</span> <span class="keyword unsafe">ref</span> <span class="variable declaration">a</span> <span class="operator">=</span> <span class="variable">packed</span><span class="operator">.</span><span class="field">a</span><span class="semicolon">;</span>
+        <span class="keyword">let</span> <span class="struct">Packed</span> <span class="brace">{</span> <span class="keyword unsafe">ref</span> <span class="field">a</span> <span class="brace">}</span> <span class="operator">=</span> <span class="variable">packed</span><span class="semicolon">;</span>
+        <span class="keyword">let</span> <span class="struct">Packed</span> <span class="brace">{</span> <span class="field">a</span><span class="colon">:</span> <span class="keyword unsafe">ref</span> <span class="variable declaration">_a</span> <span class="brace">}</span> <span class="operator">=</span> <span class="variable">packed</span><span class="semicolon">;</span>
 
         <span class="comment">// unsafe auto ref of packed field</span>
-        <span class="variable">packed</span><span class="operator">.</span><span class="field">a</span><span class="operator">.</span><span class="function associated unsafe">calls_autoref</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="punctuation">}</span>
-<span class="punctuation">}</span></code></pre>
\ No newline at end of file
+        <span class="variable">packed</span><span class="operator">.</span><span class="field">a</span><span class="operator">.</span><span class="function associated unsafe">calls_autoref</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="brace">}</span>
+<span class="brace">}</span></code></pre>
\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 02270b077..6b7447c46 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -36,187 +36,187 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><span class="keyword">use</span> <span class="module">inner</span><span class="operator">::</span><span class="punctuation">{</span><span class="self_keyword">self</span> <span class="keyword">as</span> <span class="module declaration">inner_mod</span><span class="punctuation">}</span><span class="punctuation">;</span>
-<span class="keyword">mod</span> <span class="module declaration">inner</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+<pre><code><span class="keyword">use</span> <span class="module">inner</span><span class="operator">::</span><span class="brace">{</span><span class="self_keyword">self</span> <span class="keyword">as</span> <span class="module declaration">inner_mod</span><span class="brace">}</span><span class="semicolon">;</span>
+<span class="keyword">mod</span> <span class="module declaration">inner</span> <span class="brace">{</span><span class="brace">}</span>
 
 <span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">rustc_builtin_macro</span><span class="attribute attribute">]</span>
-<span class="keyword">macro</span> <span class="unresolved_reference declaration">Copy</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+<span class="keyword">macro</span> <span class="unresolved_reference declaration">Copy</span> <span class="brace">{</span><span class="brace">}</span>
 
 <span class="comment">// Needed for function consuming vs normal</span>
-<span class="keyword">pub</span> <span class="keyword">mod</span> <span class="module declaration">marker</span> <span class="punctuation">{</span>
+<span class="keyword">pub</span> <span class="keyword">mod</span> <span class="module declaration">marker</span> <span class="brace">{</span>
     <span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">lang</span><span class="attribute attribute"> </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"copy"</span><span class="attribute attribute">]</span>
-    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">Copy</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-<span class="punctuation">}</span>
+    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">Copy</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="keyword">pub</span> <span class="keyword">mod</span> <span class="module declaration">ops</span> <span class="punctuation">{</span>
+<span class="keyword">pub</span> <span class="keyword">mod</span> <span class="module declaration">ops</span> <span class="brace">{</span>
     <span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">lang</span><span class="attribute attribute"> </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"fn_once"</span><span class="attribute attribute">]</span>
-    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">FnOnce</span><span class="punctuation">&lt;</span><span class="type_param declaration">Args</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">FnOnce</span><span class="angle">&lt;</span><span class="type_param declaration">Args</span><span class="angle">&gt;</span> <span class="brace">{</span><span class="brace">}</span>
 
     <span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">lang</span><span class="attribute attribute"> </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"fn_mut"</span><span class="attribute attribute">]</span>
-    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">FnMut</span><span class="punctuation">&lt;</span><span class="type_param declaration">Args</span><span class="punctuation">&gt;</span><span class="punctuation">:</span> <span class="trait">FnOnce</span><span class="punctuation">&lt;</span><span class="type_param">Args</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">FnMut</span><span class="angle">&lt;</span><span class="type_param declaration">Args</span><span class="angle">&gt;</span><span class="colon">:</span> <span class="trait">FnOnce</span><span class="angle">&lt;</span><span class="type_param">Args</span><span class="angle">&gt;</span> <span class="brace">{</span><span class="brace">}</span>
 
     <span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">lang</span><span class="attribute attribute"> </span><span class="operator attribute">=</span><span class="attribute attribute"> </span><span class="string_literal attribute">"fn"</span><span class="attribute attribute">]</span>
-    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">Fn</span><span class="punctuation">&lt;</span><span class="type_param declaration">Args</span><span class="punctuation">&gt;</span><span class="punctuation">:</span> <span class="trait">FnMut</span><span class="punctuation">&lt;</span><span class="type_param">Args</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-<span class="punctuation">}</span>
+    <span class="keyword">pub</span> <span class="keyword">trait</span> <span class="trait declaration">Fn</span><span class="angle">&lt;</span><span class="type_param declaration">Args</span><span class="angle">&gt;</span><span class="colon">:</span> <span class="trait">FnMut</span><span class="angle">&lt;</span><span class="type_param">Args</span><span class="angle">&gt;</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="brace">}</span>
 
 
-<span class="keyword">struct</span> <span class="struct declaration">Foo</span> <span class="punctuation">{</span>
-    <span class="keyword">pub</span> <span class="field declaration">x</span><span class="punctuation">:</span> <span class="builtin_type">i32</span><span class="punctuation">,</span>
-    <span class="keyword">pub</span> <span class="field declaration">y</span><span class="punctuation">:</span> <span class="builtin_type">i32</span><span class="punctuation">,</span>
-<span class="punctuation">}</span>
+<span class="keyword">struct</span> <span class="struct declaration">Foo</span> <span class="brace">{</span>
+    <span class="keyword">pub</span> <span class="field declaration">x</span><span class="colon">:</span> <span class="builtin_type">i32</span><span class="comma">,</span>
+    <span class="keyword">pub</span> <span class="field declaration">y</span><span class="colon">:</span> <span class="builtin_type">i32</span><span class="comma">,</span>
+<span class="brace">}</span>
 
-<span class="keyword">trait</span> <span class="trait declaration">Bar</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">bar</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span><span class="punctuation">;</span>
-<span class="punctuation">}</span>
+<span class="keyword">trait</span> <span class="trait declaration">Bar</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">bar</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span><span class="semicolon">;</span>
+<span class="brace">}</span>
 
-<span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">bar</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
+<span class="keyword">impl</span> <span class="trait">Bar</span> <span class="keyword">for</span> <span class="struct">Foo</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">bar</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
         <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
-    <span class="punctuation">}</span>
-<span class="punctuation">}</span>
+    <span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="keyword">impl</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">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="operator">.</span><span class="function consuming associated">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">impl</span> <span class="struct">Foo</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">baz</span><span class="parenthesis">(</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="comma">,</span> <span class="value_param declaration">f</span><span class="colon">:</span> <span class="struct">Foo</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
+        <span class="value_param">f</span><span class="operator">.</span><span class="function consuming associated">baz</span><span class="parenthesis">(</span><span class="self_keyword mutable consuming">self</span><span class="parenthesis">)</span>
+    <span class="brace">}</span>
 
-    <span class="keyword">fn</span> <span class="function declaration associated">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>
-        <span class="self_keyword mutable">self</span><span class="operator">.</span><span class="field">x</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="punctuation">;</span>
-    <span class="punctuation">}</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">qux</span><span class="parenthesis">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="parenthesis">)</span> <span class="brace">{</span>
+        <span class="self_keyword mutable">self</span><span class="operator">.</span><span class="field">x</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="semicolon">;</span>
+    <span class="brace">}</span>
 
-    <span class="keyword">fn</span> <span class="function declaration associated">quop</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">quop</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">i32</span> <span class="brace">{</span>
         <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
-    <span class="punctuation">}</span>
-<span class="punctuation">}</span>
+    <span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">derive</span><span class="punctuation attribute">(</span><span class="attribute attribute">Copy</span><span class="punctuation attribute">)</span><span class="attribute attribute">]</span>
-<span class="keyword">struct</span> <span class="struct declaration">FooCopy</span> <span class="punctuation">{</span>
-    <span class="field declaration">x</span><span class="punctuation">:</span> <span class="builtin_type">u32</span><span class="punctuation">,</span>
-<span class="punctuation">}</span>
+<span class="attribute attribute">#</span><span class="attribute attribute">[</span><span class="function attribute">derive</span><span class="parenthesis attribute">(</span><span class="attribute attribute">Copy</span><span class="parenthesis attribute">)</span><span class="attribute attribute">]</span>
+<span class="keyword">struct</span> <span class="struct declaration">FooCopy</span> <span class="brace">{</span>
+    <span class="field declaration">x</span><span class="colon">:</span> <span class="builtin_type">u32</span><span class="comma">,</span>
+<span class="brace">}</span>
 
-<span class="keyword">impl</span> <span class="struct">FooCopy</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">baz</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">,</span> <span class="value_param declaration">f</span><span class="punctuation">:</span> <span class="struct">FooCopy</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="punctuation">{</span>
-        <span class="value_param">f</span><span class="operator">.</span><span class="function associated">baz</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">)</span>
-    <span class="punctuation">}</span>
+<span class="keyword">impl</span> <span class="struct">FooCopy</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">baz</span><span class="parenthesis">(</span><span class="self_keyword">self</span><span class="comma">,</span> <span class="value_param declaration">f</span><span class="colon">:</span> <span class="struct">FooCopy</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="brace">{</span>
+        <span class="value_param">f</span><span class="operator">.</span><span class="function associated">baz</span><span class="parenthesis">(</span><span class="self_keyword">self</span><span class="parenthesis">)</span>
+    <span class="brace">}</span>
 
-    <span class="keyword">fn</span> <span class="function declaration associated">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>
-        <span class="self_keyword mutable">self</span><span class="operator">.</span><span class="field">x</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="punctuation">;</span>
-    <span class="punctuation">}</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">qux</span><span class="parenthesis">(</span><span class="operator">&</span><span class="keyword">mut</span> <span class="self_keyword mutable">self</span><span class="parenthesis">)</span> <span class="brace">{</span>
+        <span class="self_keyword mutable">self</span><span class="operator">.</span><span class="field">x</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="semicolon">;</span>
+    <span class="brace">}</span>
 
-    <span class="keyword">fn</span> <span class="function declaration associated">quop</span><span class="punctuation">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="punctuation">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">quop</span><span class="parenthesis">(</span><span class="operator">&</span><span class="self_keyword">self</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">u32</span> <span class="brace">{</span>
         <span class="self_keyword">self</span><span class="operator">.</span><span class="field">x</span>
-    <span class="punctuation">}</span>
-<span class="punctuation">}</span>
+    <span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable unsafe">STATIC_MUT</span><span class="punctuation">:</span> <span class="builtin_type">i32</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="punctuation">;</span>
+<span class="keyword">static</span> <span class="keyword">mut</span> <span class="static declaration mutable unsafe">STATIC_MUT</span><span class="colon">:</span> <span class="builtin_type">i32</span> <span class="operator">=</span> <span class="numeric_literal">0</span><span class="semicolon">;</span>
 
-<span class="keyword">fn</span> <span class="function declaration">foo</span><span class="punctuation">&lt;</span><span class="lifetime declaration">'a</span><span class="punctuation">,</span> <span class="type_param declaration">T</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="type_param">T</span> <span class="punctuation">{</span>
-    <span class="function">foo</span><span class="operator">::</span><span class="punctuation">&lt;</span><span class="lifetime">'a</span><span class="punctuation">,</span> <span class="builtin_type">i32</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="punctuation">)</span>
-<span class="punctuation">}</span>
+<span class="keyword">fn</span> <span class="function declaration">foo</span><span class="angle">&lt;</span><span class="lifetime declaration">'a</span><span class="comma">,</span> <span class="type_param declaration">T</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="type_param">T</span> <span class="brace">{</span>
+    <span class="function">foo</span><span class="operator">::</span><span class="angle">&lt;</span><span class="lifetime">'a</span><span class="comma">,</span> <span class="builtin_type">i32</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="parenthesis">)</span>
+<span class="brace">}</span>
 
-<span class="keyword">fn</span> <span class="function declaration">never</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">!</span> <span class="punctuation">{</span>
-    <span class="keyword control">loop</span> <span class="punctuation">{</span><span class="punctuation">}</span>
-<span class="punctuation">}</span>
+<span class="keyword">fn</span> <span class="function declaration">never</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">!</span> <span class="brace">{</span>
+    <span class="keyword control">loop</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="keyword">fn</span> <span class="function declaration">const_param</span><span class="punctuation">&lt;</span><span class="keyword">const</span> <span class="const_param declaration">FOO</span><span class="punctuation">:</span> <span class="builtin_type">usize</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">usize</span> <span class="punctuation">{</span>
+<span class="keyword">fn</span> <span class="function declaration">const_param</span><span class="angle">&lt;</span><span class="keyword">const</span> <span class="const_param declaration">FOO</span><span class="colon">:</span> <span class="builtin_type">usize</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="builtin_type">usize</span> <span class="brace">{</span>
     <span class="const_param">FOO</span>
-<span class="punctuation">}</span>
+<span class="brace">}</span>
 
-<span class="keyword">use</span> <span class="module">ops</span><span class="operator">::</span><span class="trait">Fn</span><span class="punctuation">;</span>
-<span class="keyword">fn</span> <span class="function declaration">baz</span><span class="punctuation">&lt;</span><span class="type_param declaration">F</span><span class="punctuation">:</span> <span class="trait">Fn</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="value_param declaration callable">f</span><span class="punctuation">:</span> <span class="type_param">F</span><span class="punctuation">)</span> <span class="punctuation">{</span>
-    <span class="value_param callable">f</span><span class="punctuation">(</span><span class="punctuation">)</span>
-<span class="punctuation">}</span>
+<span class="keyword">use</span> <span class="module">ops</span><span class="operator">::</span><span class="trait">Fn</span><span class="semicolon">;</span>
+<span class="keyword">fn</span> <span class="function declaration">baz</span><span class="angle">&lt;</span><span class="type_param declaration">F</span><span class="colon">:</span> <span class="trait">Fn</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="parenthesis">(</span><span class="parenthesis">)</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="value_param declaration callable">f</span><span class="colon">:</span> <span class="type_param">F</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="value_param callable">f</span><span class="parenthesis">(</span><span class="parenthesis">)</span>
+<span class="brace">}</span>
 
-<span class="keyword">fn</span> <span class="function declaration">foobar</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="keyword">impl</span> <span class="macro">Copy</span> <span class="punctuation">{</span><span class="punctuation">}</span>
+<span class="keyword">fn</span> <span class="function declaration">foobar</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="keyword">impl</span> <span class="macro">Copy</span> <span class="brace">{</span><span class="brace">}</span>
 
-<span class="keyword">fn</span> <span class="function declaration">foo</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
-    <span class="keyword">let</span> <span class="variable declaration">bar</span> <span class="operator">=</span> <span class="function">foobar</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-<span class="punctuation">}</span>
+<span class="keyword">fn</span> <span class="function declaration">foo</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="keyword">let</span> <span class="variable declaration">bar</span> <span class="operator">=</span> <span class="function">foobar</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+<span class="brace">}</span>
 
-<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">def_fn</span> <span class="punctuation">{</span>
-    <span class="punctuation">(</span><span class="punctuation">$</span><span class="punctuation">(</span><span class="punctuation">$</span>tt<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="punctuation">$</span>tt<span class="punctuation">)</span><span class="punctuation">*</span><span class="punctuation">}</span>
-<span class="punctuation">}</span>
+<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">def_fn</span> <span class="brace">{</span>
+    <span class="parenthesis">(</span><span class="punctuation">$</span><span class="parenthesis">(</span><span class="punctuation">$</span>tt<span class="colon">:</span>tt<span class="parenthesis">)</span><span class="punctuation">*</span><span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="brace">{</span><span class="punctuation">$</span><span class="parenthesis">(</span><span class="punctuation">$</span>tt<span class="parenthesis">)</span><span class="punctuation">*</span><span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="macro">def_fn!</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration">bar</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-</span><span class="operator">&gt;</span> <span class="builtin_type">u32</span> <span class="punctuation">{</span>
+<span class="macro">def_fn!</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function declaration">bar</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="operator">-</span><span class="operator">&gt;</span> <span class="builtin_type">u32</span> <span class="brace">{</span>
         <span class="numeric_literal">100</span>
-    <span class="punctuation">}</span>
-<span class="punctuation">}</span>
+    <span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">noop</span> <span class="punctuation">{</span>
-    <span class="punctuation">(</span><span class="punctuation">$</span>expr<span class="punctuation">:</span>expr<span class="punctuation">)</span> <span class="operator">=</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
+<span class="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">noop</span> <span class="brace">{</span>
+    <span class="parenthesis">(</span><span class="punctuation">$</span>expr<span class="colon">:</span>expr<span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="brace">{</span>
         <span class="punctuation">$</span>expr
-    <span class="punctuation">}</span>
-<span class="punctuation">}</span>
+    <span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="keyword">macro_rules</span><span class="punctuation">!</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="keyword">macro_rules</span><span class="punctuation">!</span> <span class="macro declaration">keyword_frag</span> <span class="brace">{</span>
+    <span class="parenthesis">(</span><span class="punctuation">$</span>type<span class="colon">:</span>ty<span class="parenthesis">)</span> <span class="operator">=</span><span class="angle">&gt;</span> <span class="parenthesis">(</span><span class="punctuation">$</span>type<span class="parenthesis">)</span>
+<span class="brace">}</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>
-
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">vec</span> <span class="operator">=</span> <span class="unresolved_reference">Vec</span><span class="operator">::</span><span class="unresolved_reference">new</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="keyword control">if</span> <span class="bool_literal">true</span> <span class="punctuation">{</span>
-        <span class="keyword">let</span> <span class="variable declaration">x</span> <span class="operator">=</span> <span class="numeric_literal">92</span><span class="punctuation">;</span>
-        <span class="variable mutable">vec</span><span class="operator">.</span><span class="unresolved_reference">push</span><span class="punctuation">(</span><span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">x</span><span class="punctuation">,</span> <span class="field">y</span><span class="punctuation">:</span> <span class="numeric_literal">1</span> <span class="punctuation">}</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="punctuation">}</span>
-    <span class="keyword unsafe">unsafe</span> <span class="punctuation">{</span>
-        <span class="variable mutable">vec</span><span class="operator">.</span><span class="unresolved_reference">set_len</span><span class="punctuation">(</span><span class="numeric_literal">0</span><span class="punctuation">)</span><span class="punctuation">;</span>
-        <span class="static mutable unsafe">STATIC_MUT</span> <span class="operator">=</span> <span class="numeric_literal">1</span><span class="punctuation">;</span>
-    <span class="punctuation">}</span>
-
-    <span class="keyword control">for</span> <span class="variable declaration">e</span> <span class="keyword control">in</span> <span class="variable mutable">vec</span> <span class="punctuation">{</span>
+<span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="macro">println!</span><span class="parenthesis">(</span><span class="string_literal">"Hello, {}!"</span><span class="comma">,</span> <span class="numeric_literal">92</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">vec</span> <span class="operator">=</span> <span class="unresolved_reference">Vec</span><span class="operator">::</span><span class="unresolved_reference">new</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="keyword control">if</span> <span class="bool_literal">true</span> <span class="brace">{</span>
+        <span class="keyword">let</span> <span class="variable declaration">x</span> <span class="operator">=</span> <span class="numeric_literal">92</span><span class="semicolon">;</span>
+        <span class="variable mutable">vec</span><span class="operator">.</span><span class="unresolved_reference">push</span><span class="parenthesis">(</span><span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="comma">,</span> <span class="field">y</span><span class="colon">:</span> <span class="numeric_literal">1</span> <span class="brace">}</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="brace">}</span>
+    <span class="keyword unsafe">unsafe</span> <span class="brace">{</span>
+        <span class="variable mutable">vec</span><span class="operator">.</span><span class="unresolved_reference">set_len</span><span class="parenthesis">(</span><span class="numeric_literal">0</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+        <span class="static mutable unsafe">STATIC_MUT</span> <span class="operator">=</span> <span class="numeric_literal">1</span><span class="semicolon">;</span>
+    <span class="brace">}</span>
+
+    <span class="keyword control">for</span> <span class="variable declaration">e</span> <span class="keyword control">in</span> <span class="variable mutable">vec</span> <span class="brace">{</span>
         <span class="comment">// Do nothing</span>
-    <span class="punctuation">}</span>
+    <span class="brace">}</span>
 
-    <span class="macro">noop!</span><span class="punctuation">(</span><span class="macro">noop</span><span class="macro">!</span><span class="punctuation">(</span><span class="numeric_literal">1</span><span class="punctuation">)</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="macro">noop!</span><span class="parenthesis">(</span><span class="macro">noop</span><span class="macro">!</span><span class="parenthesis">(</span><span class="numeric_literal">1</span><span class="parenthesis">)</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">x</span> <span class="operator">=</span> <span class="numeric_literal">42</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration mutable">y</span> <span class="operator">=</span> <span class="operator">&</span><span class="keyword">mut</span> <span class="variable mutable">x</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration">z</span> <span class="operator">=</span> <span class="operator">&</span><span class="variable mutable">y</span><span class="punctuation">;</span>
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">x</span> <span class="operator">=</span> <span class="numeric_literal">42</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration mutable">y</span> <span class="operator">=</span> <span class="operator">&</span><span class="keyword">mut</span> <span class="variable mutable">x</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration">z</span> <span class="operator">=</span> <span class="operator">&</span><span class="variable mutable">y</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">x</span><span class="punctuation">:</span> <span class="variable declaration">z</span><span class="punctuation">,</span> <span class="field">y</span> <span class="punctuation">}</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">x</span><span class="punctuation">:</span> <span class="variable">z</span><span class="punctuation">,</span> <span class="field">y</span> <span class="punctuation">}</span><span class="punctuation">;</span>
+    <span class="keyword">let</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="colon">:</span> <span class="variable declaration">z</span><span class="comma">,</span> <span class="field">y</span> <span class="brace">}</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="colon">:</span> <span class="variable">z</span><span class="comma">,</span> <span class="field">y</span> <span class="brace">}</span><span class="semicolon">;</span>
 
-    <span class="variable">y</span><span class="punctuation">;</span>
+    <span class="variable">y</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">x</span><span class="punctuation">,</span> <span class="field">y</span><span class="punctuation">:</span> <span class="variable mutable">x</span> <span class="punctuation">}</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration">foo2</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">x</span><span class="punctuation">,</span> <span class="field">y</span><span class="punctuation">:</span> <span class="variable mutable">x</span> <span class="punctuation">}</span><span class="punctuation">;</span>
-    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function associated">quop</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function mutable associated">qux</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function consuming associated">baz</span><span class="punctuation">(</span><span class="variable consuming">foo2</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">foo</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="comma">,</span> <span class="field">y</span><span class="colon">:</span> <span class="variable mutable">x</span> <span class="brace">}</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration">foo2</span> <span class="operator">=</span> <span class="struct">Foo</span> <span class="brace">{</span> <span class="field">x</span><span class="comma">,</span> <span class="field">y</span><span class="colon">:</span> <span class="variable mutable">x</span> <span class="brace">}</span><span class="semicolon">;</span>
+    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function associated">quop</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function mutable associated">qux</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="variable mutable">foo</span><span class="operator">.</span><span class="function consuming associated">baz</span><span class="parenthesis">(</span><span class="variable consuming">foo2</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">copy</span> <span class="operator">=</span> <span class="struct">FooCopy</span> <span class="punctuation">{</span> <span class="field">x</span> <span class="punctuation">}</span><span class="punctuation">;</span>
-    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated">quop</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function mutable associated">qux</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated">baz</span><span class="punctuation">(</span><span class="variable mutable">copy</span><span class="punctuation">)</span><span class="punctuation">;</span>
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable">copy</span> <span class="operator">=</span> <span class="struct">FooCopy</span> <span class="brace">{</span> <span class="field">x</span> <span class="brace">}</span><span class="semicolon">;</span>
+    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated">quop</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function mutable associated">qux</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="variable mutable">copy</span><span class="operator">.</span><span class="function associated">baz</span><span class="parenthesis">(</span><span class="variable mutable">copy</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="variable declaration callable">a</span> <span class="operator">=</span> <span class="punctuation">|</span><span class="value_param declaration">x</span><span class="punctuation">|</span> <span class="value_param">x</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration callable">bar</span> <span class="operator">=</span> <span class="struct">Foo</span><span class="operator">::</span><span class="function associated">baz</span><span class="punctuation">;</span>
+    <span class="keyword">let</span> <span class="variable declaration callable">a</span> <span class="operator">=</span> <span class="punctuation">|</span><span class="value_param declaration">x</span><span class="punctuation">|</span> <span class="value_param">x</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration callable">bar</span> <span class="operator">=</span> <span class="struct">Foo</span><span class="operator">::</span><span class="function associated">baz</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="numeric_literal">-</span><span class="numeric_literal">42</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="operator">-</span><span class="variable">baz</span><span class="punctuation">;</span>
+    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="numeric_literal">-</span><span class="numeric_literal">42</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration">baz</span> <span class="operator">=</span> <span class="operator">-</span><span class="variable">baz</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="operator">!</span><span class="bool_literal">true</span><span class="punctuation">;</span>
+    <span class="keyword">let</span> <span class="punctuation">_</span> <span class="operator">=</span> <span class="operator">!</span><span class="bool_literal">true</span><span class="semicolon">;</span>
 
-    <span class="label declaration">'foo</span><span class="punctuation">:</span> <span class="keyword control">loop</span> <span class="punctuation">{</span>
-        <span class="keyword control">break</span> <span class="label">'foo</span><span class="punctuation">;</span>
-        <span class="keyword control">continue</span> <span class="label">'foo</span><span class="punctuation">;</span>
-    <span class="punctuation">}</span>
-<span class="punctuation">}</span>
+    <span class="label declaration">'foo</span><span class="colon">:</span> <span class="keyword control">loop</span> <span class="brace">{</span>
+        <span class="keyword control">break</span> <span class="label">'foo</span><span class="semicolon">;</span>
+        <span class="keyword control">continue</span> <span class="label">'foo</span><span class="semicolon">;</span>
+    <span class="brace">}</span>
+<span class="brace">}</span>
 
-<span class="keyword">enum</span> <span class="enum declaration">Option</span><span class="punctuation">&lt;</span><span class="type_param declaration">T</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
-    <span class="enum_variant declaration">Some</span><span class="punctuation">(</span><span class="type_param">T</span><span class="punctuation">)</span><span class="punctuation">,</span>
-    <span class="enum_variant declaration">None</span><span class="punctuation">,</span>
-<span class="punctuation">}</span>
-<span class="keyword">use</span> <span class="enum">Option</span><span class="operator">::</span><span class="punctuation">*</span><span class="punctuation">;</span>
+<span class="keyword">enum</span> <span class="enum declaration">Option</span><span class="angle">&lt;</span><span class="type_param declaration">T</span><span class="angle">&gt;</span> <span class="brace">{</span>
+    <span class="enum_variant declaration">Some</span><span class="parenthesis">(</span><span class="type_param">T</span><span class="parenthesis">)</span><span class="comma">,</span>
+    <span class="enum_variant declaration">None</span><span class="comma">,</span>
+<span class="brace">}</span>
+<span class="keyword">use</span> <span class="enum">Option</span><span class="operator">::</span><span class="punctuation">*</span><span class="semicolon">;</span>
 
-<span class="keyword">impl</span><span class="punctuation">&lt;</span><span class="type_param declaration">T</span><span class="punctuation">&gt;</span> <span class="enum">Option</span><span class="punctuation">&lt;</span><span class="type_param">T</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
-    <span class="keyword">fn</span> <span class="function declaration associated">and</span><span class="punctuation">&lt;</span><span class="type_param declaration">U</span><span class="punctuation">&gt;</span><span class="punctuation">(</span><span class="self_keyword">self</span><span class="punctuation">,</span> <span class="value_param declaration">other</span><span class="punctuation">:</span> <span class="enum">Option</span><span class="punctuation">&lt;</span><span class="type_param">U</span><span class="punctuation">&gt;</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="enum">Option</span><span class="punctuation">&lt;</span><span class="punctuation">(</span><span class="type_param">T</span><span class="punctuation">,</span> <span class="type_param">U</span><span class="punctuation">)</span><span class="punctuation">&gt;</span> <span class="punctuation">{</span>
-        <span class="keyword control">match</span> <span class="value_param">other</span> <span class="punctuation">{</span>
-            <span class="enum_variant">None</span> <span class="operator">=&gt;</span> <span class="macro">unimplemented!</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">,</span>
-            <span class="variable declaration">Nope</span> <span class="operator">=&gt;</span> <span class="variable">Nope</span><span class="punctuation">,</span>
-        <span class="punctuation">}</span>
-    <span class="punctuation">}</span>
-<span class="punctuation">}</span></code></pre>
\ No newline at end of file
+<span class="keyword">impl</span><span class="angle">&lt;</span><span class="type_param declaration">T</span><span class="angle">&gt;</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="type_param">T</span><span class="angle">&gt;</span> <span class="brace">{</span>
+    <span class="keyword">fn</span> <span class="function declaration associated">and</span><span class="angle">&lt;</span><span class="type_param declaration">U</span><span class="angle">&gt;</span><span class="parenthesis">(</span><span class="self_keyword">self</span><span class="comma">,</span> <span class="value_param declaration">other</span><span class="colon">:</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="type_param">U</span><span class="angle">&gt;</span><span class="parenthesis">)</span> <span class="operator">-&gt;</span> <span class="enum">Option</span><span class="angle">&lt;</span><span class="parenthesis">(</span><span class="type_param">T</span><span class="comma">,</span> <span class="type_param">U</span><span class="parenthesis">)</span><span class="angle">&gt;</span> <span class="brace">{</span>
+        <span class="keyword control">match</span> <span class="value_param">other</span> <span class="brace">{</span>
+            <span class="enum_variant">None</span> <span class="operator">=&gt;</span> <span class="macro">unimplemented!</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="comma">,</span>
+            <span class="variable declaration">Nope</span> <span class="operator">=&gt;</span> <span class="variable">Nope</span><span class="comma">,</span>
+        <span class="brace">}</span>
+    <span class="brace">}</span>
+<span class="brace">}</span></code></pre>
\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/test_data/injection.html b/crates/ide/src/syntax_highlighting/test_data/injection.html
new file mode 100644
index 000000000..78dfec951
--- /dev/null
+++ b/crates/ide/src/syntax_highlighting/test_data/injection.html
@@ -0,0 +1,48 @@
+
+<style>
+body                { margin: 0; }
+pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
+
+.lifetime           { color: #DFAF8F; font-style: italic; }
+.label              { color: #DFAF8F; font-style: italic; }
+.comment            { color: #7F9F7F; }
+.documentation      { color: #629755; }
+.injected           { opacity: 0.65 ; }
+.struct, .enum      { color: #7CB8BB; }
+.enum_variant       { color: #BDE0F3; }
+.string_literal     { color: #CC9393; }
+.field              { color: #94BFF3; }
+.function           { color: #93E0E3; }
+.function.unsafe    { color: #BC8383; }
+.operator.unsafe    { color: #BC8383; }
+.parameter          { color: #94BFF3; }
+.text               { color: #DCDCCC; }
+.type               { color: #7CB8BB; }
+.builtin_type       { color: #8CD0D3; }
+.type_param         { color: #DFAF8F; }
+.attribute          { color: #94BFF3; }
+.numeric_literal    { color: #BFEBBF; }
+.bool_literal       { color: #BFE6EB; }
+.macro              { color: #94BFF3; }
+.module             { color: #AFD8AF; }
+.value_param        { color: #DCDCCC; }
+.variable           { color: #DCDCCC; }
+.format_specifier   { color: #CC696B; }
+.mutable            { text-decoration: underline; }
+.escape_sequence    { color: #94BFF3; }
+.keyword            { color: #F0DFAF; font-weight: bold; }
+.keyword.unsafe     { color: #BC8383; font-weight: bold; }
+.control            { font-style: italic; }
+
+.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
+</style>
+<pre><code><span class="keyword">fn</span> <span class="function declaration">f</span><span class="parenthesis">(</span><span class="value_param declaration">ra_fixture</span><span class="colon">:</span> <span class="operator">&</span><span class="builtin_type">str</span><span class="parenthesis">)</span> <span class="brace">{</span><span class="brace">}</span>
+<span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="function">f</span><span class="parenthesis">(</span><span class="string_literal">r"</span>
+<span class="keyword">fn</span> <span class="function declaration">foo</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="function">foo</span><span class="parenthesis">(</span><span class="keyword">$0</span><span class="brace">{</span>
+        <span class="numeric_literal">92</span>
+    <span class="brace">}</span><span class="keyword">$0</span><span class="parenthesis">)</span>
+<span class="brace">}</span><span class="string_literal">"</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+<span class="brace">}</span>
+    </code></pre>
\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html b/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
index 8b3dfa69f..e64f2e5e9 100644
--- a/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/rainbow_highlighting.html
@@ -36,15 +36,15 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 .unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
 </style>
-<pre><code><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="keyword">let</span> <span class="variable declaration" data-binding-hash="8121853618659664005" style="color: hsl(273,88%,88%);">hello</span> <span class="operator">=</span> <span class="string_literal">"hello"</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="2705725358298919760" style="color: hsl(76,47%,83%);">x</span> <span class="operator">=</span> <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(273,88%,88%);">hello</span><span class="operator">.</span><span class="unresolved_reference">to_string</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="3365759661443752373" style="color: hsl(15,86%,51%);">y</span> <span class="operator">=</span> <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(273,88%,88%);">hello</span><span class="operator">.</span><span class="unresolved_reference">to_string</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
+<pre><code><span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="8121853618659664005" style="color: hsl(273,88%,88%);">hello</span> <span class="operator">=</span> <span class="string_literal">"hello"</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="2705725358298919760" style="color: hsl(76,47%,83%);">x</span> <span class="operator">=</span> <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(273,88%,88%);">hello</span><span class="operator">.</span><span class="unresolved_reference">to_string</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="3365759661443752373" style="color: hsl(15,86%,51%);">y</span> <span class="operator">=</span> <span class="variable" data-binding-hash="8121853618659664005" style="color: hsl(273,88%,88%);">hello</span><span class="operator">.</span><span class="unresolved_reference">to_string</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="794745962933817518" style="color: hsl(127,71%,87%);">x</span> <span class="operator">=</span> <span class="string_literal">"other color please!"</span><span class="punctuation">;</span>
-    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="6717528807933952652" style="color: hsl(90,74%,79%);">y</span> <span class="operator">=</span> <span class="variable" data-binding-hash="794745962933817518" style="color: hsl(127,71%,87%);">x</span><span class="operator">.</span><span class="unresolved_reference">to_string</span><span class="punctuation">(</span><span class="punctuation">)</span><span class="punctuation">;</span>
-<span class="punctuation">}</span>
+    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="794745962933817518" style="color: hsl(127,71%,87%);">x</span> <span class="operator">=</span> <span class="string_literal">"other color please!"</span><span class="semicolon">;</span>
+    <span class="keyword">let</span> <span class="variable declaration" data-binding-hash="6717528807933952652" style="color: hsl(90,74%,79%);">y</span> <span class="operator">=</span> <span class="variable" data-binding-hash="794745962933817518" style="color: hsl(127,71%,87%);">x</span><span class="operator">.</span><span class="unresolved_reference">to_string</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
+<span class="brace">}</span>
 
-<span class="keyword">fn</span> <span class="function declaration">bar</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable" data-binding-hash="8121853618659664005" style="color: hsl(273,88%,88%);">hello</span> <span class="operator">=</span> <span class="string_literal">"hello"</span><span class="punctuation">;</span>
-<span class="punctuation">}</span></code></pre>
\ No newline at end of file
+<span class="keyword">fn</span> <span class="function declaration">bar</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable declaration mutable" data-binding-hash="8121853618659664005" style="color: hsl(273,88%,88%);">hello</span> <span class="operator">=</span> <span class="string_literal">"hello"</span><span class="semicolon">;</span>
+<span class="brace">}</span></code></pre>
\ No newline at end of file
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index 30b5b648e..a62704c39 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -446,6 +446,11 @@ struct Foo {
 }
 
 impl Foo {
+    /// ```
+    /// let _ = "Call me
+    //    KILLER WHALE
+    ///     Ishmael.";
+    /// ```
     pub const bar: bool = true;
 
     /// Constructs a new `Foo`.
@@ -555,6 +560,25 @@ impl t for foo {
     )
 }
 
+#[test]
+fn test_injection() {
+    check_highlighting(
+        r##"
+fn f(ra_fixture: &str) {}
+fn main() {
+    f(r"
+fn foo() {
+    foo(\$0{
+        92
+    }\$0)
+}");
+}
+    "##,
+        expect_file!["./test_data/injection.html"],
+        false,
+    );
+}
+
 /// Highlights the code given by the `ra_fixture` argument, renders the
 /// result as HTML, and compares it with the HTML file given as `snapshot`.
 /// Note that the `snapshot` file is overwritten by the rendered HTML.
diff --git a/crates/ide/src/syntax_tree.rs b/crates/ide/src/syntax_tree.rs
index 6dd05c05d..1f26f8043 100644
--- a/crates/ide/src/syntax_tree.rs
+++ b/crates/ide/src/syntax_tree.rs
@@ -85,7 +85,7 @@ fn syntax_tree_for_token(node: &SyntaxToken, text_range: TextRange) -> Option<St
         .trim_end_matches('"')
         .trim()
         // Remove custom markers
-        .replace("<|>", "");
+        .replace("$0", "");
 
     let parsed = SourceFile::parse(&text);
 
@@ -182,7 +182,7 @@ [email protected]
 
     #[test]
     fn test_syntax_tree_with_range() {
-        let (analysis, range) = fixture::range(r#"<|>fn foo() {}<|>"#.trim());
+        let (analysis, range) = fixture::range(r#"$0fn foo() {}$0"#.trim());
         let syn = analysis.syntax_tree(range.file_id, Some(range.range)).unwrap();
 
         assert_eq_text!(
@@ -206,10 +206,10 @@ [email protected]
 
         let (analysis, range) = fixture::range(
             r#"fn test() {
-    <|>assert!("
+    $0assert!("
     fn foo() {
     }
-    ", "");<|>
+    ", "");$0
 }"#
             .trim(),
         );
@@ -243,8 +243,8 @@ [email protected]
         let (analysis, range) = fixture::range(
             r#"fn test() {
     assert!("
-<|>fn foo() {
-}<|>
+$0fn foo() {
+}$0
 fn bar() {
 }
     ", "");
@@ -277,8 +277,8 @@ [email protected]
         let (analysis, range) = fixture::range(
             r###"fn test() {
     assert!(r#"
-<|>fn foo() {
-}<|>
+$0fn foo() {
+}$0
 fn bar() {
 }
     "#, "");
@@ -310,11 +310,11 @@ [email protected]
         // With a raw string
         let (analysis, range) = fixture::range(
             r###"fn test() {
-    assert!(r<|>#"
+    assert!(r$0#"
 fn foo() {
 }
 fn bar() {
-}"<|>#, "");
+}"$0#, "");
 }"###
                 .trim(),
         );
diff --git a/crates/ide/src/typing.rs b/crates/ide/src/typing.rs
index 43458a3a2..88c905003 100644
--- a/crates/ide/src/typing.rs
+++ b/crates/ide/src/typing.rs
@@ -170,7 +170,7 @@ mod tests {
     fn test_on_eq_typed() {
         //     do_check(r"
         // fn foo() {
-        //     let foo =<|>
+        //     let foo =$0
         // }
         // ", r"
         // fn foo() {
@@ -181,7 +181,7 @@ mod tests {
             '=',
             r"
 fn foo() {
-    let foo <|> 1 + 1
+    let foo $0 1 + 1
 }
 ",
             r"
@@ -192,7 +192,7 @@ fn foo() {
         );
         //     do_check(r"
         // fn foo() {
-        //     let foo =<|>
+        //     let foo =$0
         //     let bar = 1;
         // }
         // ", r"
@@ -210,7 +210,7 @@ fn foo() {
             r"
             fn main() {
                 xs.foo()
-                <|>
+                $0
             }
             ",
             r"
@@ -225,7 +225,7 @@ fn foo() {
             r"
             fn main() {
                 xs.foo()
-                    <|>
+                    $0
             }
             ",
         )
@@ -238,7 +238,7 @@ fn foo() {
             r"
             fn main() {
                 xs.foo()
-                <|>;
+                $0;
             }
             ",
             r"
@@ -253,7 +253,7 @@ fn foo() {
             r"
             fn main() {
                 xs.foo()
-                    <|>;
+                    $0;
             }
             ",
         )
@@ -266,7 +266,7 @@ fn foo() {
             r#"
 fn main() {
     let _ = foo
-    <|>
+    $0
     bar()
 }
 "#,
@@ -288,7 +288,7 @@ fn main() {
             fn main() {
                 xs.foo()
                     .first()
-                <|>
+                $0
             }
             ",
             r"
@@ -305,7 +305,7 @@ fn main() {
             fn main() {
                 xs.foo()
                     .first()
-                    <|>
+                    $0
             }
             ",
         );
@@ -318,7 +318,7 @@ fn main() {
             r"
             fn source_impl() {
                 let var = enum_defvariant_list().unwrap()
-                <|>
+                $0
                     .nth(92)
                     .unwrap();
             }
@@ -337,7 +337,7 @@ fn main() {
             r"
             fn source_impl() {
                 let var = enum_defvariant_list().unwrap()
-                    <|>
+                    $0
                     .nth(92)
                     .unwrap();
             }
@@ -351,7 +351,7 @@ fn main() {
             '.',
             r"
             fn main() {
-                <|>
+                $0
             }
             ",
         );
@@ -359,7 +359,7 @@ fn main() {
             '.',
             r"
             fn main() {
-            <|>
+            $0
             }
             ",
         );
@@ -367,6 +367,6 @@ fn main() {
 
     #[test]
     fn adds_space_after_return_type() {
-        type_char('>', "fn foo() -<|>{ 92 }", "fn foo() -> { 92 }")
+        type_char('>', "fn foo() -$0{ 92 }", "fn foo() -> { 92 }")
     }
 }
diff --git a/crates/ide/src/typing/on_enter.rs b/crates/ide/src/typing/on_enter.rs
index f4ea30352..63cd51b69 100644
--- a/crates/ide/src/typing/on_enter.rs
+++ b/crates/ide/src/typing/on_enter.rs
@@ -136,7 +136,7 @@ mod tests {
     fn continues_doc_comment() {
         do_check(
             r"
-/// Some docs<|>
+/// Some docs$0
 fn foo() {
 }
 ",
@@ -151,7 +151,7 @@ fn foo() {
         do_check(
             r"
 impl S {
-    /// Some<|> docs.
+    /// Some$0 docs.
     fn foo() {}
 }
 ",
@@ -166,7 +166,7 @@ impl S {
 
         do_check(
             r"
-///<|> Some docs
+///$0 Some docs
 fn foo() {
 }
 ",
@@ -181,7 +181,7 @@ fn foo() {
 
     #[test]
     fn does_not_continue_before_doc_comment() {
-        do_check_noop(r"<|>//! docz");
+        do_check_noop(r"$0//! docz");
     }
 
     #[test]
@@ -189,7 +189,7 @@ fn foo() {
         do_check(
             r"
 fn main() {
-    // Fix<|> me
+    // Fix$0 me
     let x = 1 + 1;
 }
 ",
@@ -208,7 +208,7 @@ fn main() {
         do_check(
             r"
 fn main() {
-    // Fix<|>
+    // Fix$0
     // me
     let x = 1 + 1;
 }
@@ -229,7 +229,7 @@ fn main() {
         do_check_noop(
             r"
 fn main() {
-    // Fix me<|>
+    // Fix me$0
     let x = 1 + 1;
 }
 ",
@@ -242,7 +242,7 @@ fn main() {
         do_check(
             r#"
 fn main() {
-    // Fix me <|>
+    // Fix me $0
     let x = 1 + 1;
 }
 "#,
@@ -261,7 +261,7 @@ fn main() {
         do_check(
             "
 fn main() {
-    // Fix me  \t\t   <|>
+    // Fix me  \t\t   $0
     let x = 1 + 1;
 }
 ",