88 files changed, 1712 insertions, 1349 deletions

diff --git a/Cargo.lock b/Cargo.lock
index bc38c5a37..5563fdeb2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -127,12 +127,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
 
 [[package]]
+name = "cargo-platform"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0226944a63d1bf35a3b5f948dd7c59e263db83695c9e8bffc4037de02e30f1d7"
+dependencies = [
+ "serde",
+]
+
+[[package]]
 name = "cargo_metadata"
-version = "0.12.0"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5a5f7b42f606b7f23674f6f4d877628350682bc40687d3fae65679a58d55345"
+checksum = "11a47b6286279a9998588ef7050d1ebc2500c69892a557c90fe5d071c64415dc"
 dependencies = [
+ "cargo-platform",
  "semver",
+ "semver-parser",
  "serde",
  "serde_json",
 ]
diff --git a/crates/assists/src/handlers/remove_dbg.rs b/crates/assists/src/handlers/remove_dbg.rs
index 0320c2f12..6114091f2 100644
--- a/crates/assists/src/handlers/remove_dbg.rs
+++ b/crates/assists/src/handlers/remove_dbg.rs
@@ -1,6 +1,6 @@
 use syntax::{
     ast::{self, AstNode},
-    match_ast, SyntaxElement, SyntaxKind, TextRange, TextSize, T,
+    match_ast, SyntaxElement, TextRange, TextSize, T,
 };
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -136,14 +136,14 @@ fn needs_parentheses_around_macro_contents(macro_contents: Vec<SyntaxElement>) -
             symbol_kind => {
                 let symbol_not_in_bracket = unpaired_brackets_in_contents.is_empty();
                 if symbol_not_in_bracket
-                    && symbol_kind != SyntaxKind::COLON // paths
-                    && (symbol_kind != SyntaxKind::DOT // field/method access
+                    && symbol_kind != T![:] // paths
+                    && (symbol_kind != T![.] // field/method access
                         || macro_contents // range expressions consist of two SyntaxKind::Dot in macro invocations
                             .peek()
-                            .map(|element| element.kind() == SyntaxKind::DOT)
+                            .map(|element| element.kind() == T![.])
                             .unwrap_or(false))
-                    && symbol_kind != SyntaxKind::QUESTION // try operator
-                    && (symbol_kind.is_punct() || symbol_kind == SyntaxKind::AS_KW)
+                    && symbol_kind != T![?] // try operator
+                    && (symbol_kind.is_punct() || symbol_kind == T![as])
                 {
                     return true;
                 }
diff --git a/crates/completion/src/completions/attribute.rs b/crates/completion/src/completions/attribute.rs
index 3a29b5203..e5522980d 100644
--- a/crates/completion/src/completions/attribute.rs
+++ b/crates/completion/src/completions/attribute.rs
@@ -5,7 +5,7 @@
 
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
-use syntax::{ast, AstNode, SyntaxKind};
+use syntax::{ast, AstNode, T};
 
 use crate::{
     context::CompletionContext,
@@ -21,15 +21,17 @@ pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext)
 
     let attribute = ctx.attribute_under_caret.as_ref()?;
     match (attribute.path(), attribute.token_tree()) {
-        (Some(path), Some(token_tree)) => match path.to_string().as_str() {
-            "derive" => complete_derive(acc, ctx, token_tree),
-            "feature" => complete_lint(acc, ctx, token_tree, FEATURES),
-            "allow" | "warn" | "deny" | "forbid" => {
+        (Some(path), Some(token_tree)) => {
+            let path = path.syntax().text();
+            if path == "derive" {
+                complete_derive(acc, ctx, token_tree)
+            } else if path == "feature" {
+                complete_lint(acc, ctx, token_tree, FEATURES)
+            } else if path == "allow" || path == "warn" || path == "deny" || path == "forbid" {
                 complete_lint(acc, ctx, token_tree.clone(), DEFAULT_LINT_COMPLETIONS);
                 complete_lint(acc, ctx, token_tree, CLIPPY_LINTS);
             }
-            _ => {}
-        },
+        }
         (_, Some(_token_tree)) => {}
         _ => complete_attribute_start(acc, ctx, attribute),
     }
@@ -203,8 +205,7 @@ fn complete_lint(
 fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Result<FxHashSet<String>, ()> {
     match (derive_input.left_delimiter_token(), derive_input.right_delimiter_token()) {
         (Some(left_paren), Some(right_paren))
-            if left_paren.kind() == SyntaxKind::L_PAREN
-                && right_paren.kind() == SyntaxKind::R_PAREN =>
+            if left_paren.kind() == T!['('] && right_paren.kind() == T![')'] =>
         {
             let mut input_derives = FxHashSet::default();
             let mut current_derive = String::new();
@@ -216,7 +217,7 @@ fn parse_comma_sep_input(derive_input: ast::TokenTree) -> Result<FxHashSet<Strin
                 .skip(1)
                 .take_while(|token| token != &right_paren)
             {
-                if SyntaxKind::COMMA == token.kind() {
+                if T![,] == token.kind() {
                     if !current_derive.is_empty() {
                         input_derives.insert(current_derive);
                         current_derive = String::new();
diff --git a/crates/completion/src/completions/dot.rs b/crates/completion/src/completions/dot.rs
index 2e25c8ba2..d04eef65a 100644
--- a/crates/completion/src/completions/dot.rs
+++ b/crates/completion/src/completions/dot.rs
@@ -373,20 +373,20 @@ fn foo(a: A) {
     fn macro_expansion_resilient() {
         check(
             r#"
-macro_rules! dbg {
+macro_rules! d {
     () => {};
     ($val:expr) => {
         match $val { tmp => { tmp } }
     };
     // Trailing comma with single argument is ignored
-    ($val:expr,) => { $crate::dbg!($val) };
+    ($val:expr,) => { $crate::d!($val) };
     ($($val:expr),+ $(,)?) => {
-        ($($crate::dbg!($val)),+,)
+        ($($crate::d!($val)),+,)
     };
 }
 struct A { the_field: u32 }
 fn foo(a: A) {
-    dbg!(a.$0)
+    d!(a.$0)
 }
 "#,
             expect![[r#"
diff --git a/crates/completion/src/completions/postfix.rs b/crates/completion/src/completions/postfix.rs
index 87f0c0b2a..9c34ed0b6 100644
--- a/crates/completion/src/completions/postfix.rs
+++ b/crates/completion/src/completions/postfix.rs
@@ -35,11 +35,14 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
         None => return,
     };
 
+    let ref_removed_ty =
+        std::iter::successors(Some(receiver_ty.clone()), |ty| ty.remove_ref()).last().unwrap();
+
     let cap = match ctx.config.snippet_cap {
         Some(it) => it,
         None => return,
     };
-    let try_enum = TryEnum::from_ty(&ctx.sema, &receiver_ty);
+    let try_enum = TryEnum::from_ty(&ctx.sema, &ref_removed_ty);
     if let Some(try_enum) = &try_enum {
         match try_enum {
             TryEnum::Result => {
@@ -496,6 +499,27 @@ fn main() {
     fn postfix_completion_for_references() {
         check_edit("dbg", r#"fn main() { &&42.$0 }"#, r#"fn main() { dbg!(&&42) }"#);
         check_edit("refm", r#"fn main() { &&42.$0 }"#, r#"fn main() { &&&mut 42 }"#);
+        check_edit(
+            "ifl",
+            r#"
+enum Option<T> { Some(T), None }
+
+fn main() {
+    let bar = &Option::Some(true);
+    bar.$0
+}
+"#,
+            r#"
+enum Option<T> { Some(T), None }
+
+fn main() {
+    let bar = &Option::Some(true);
+    if let Some($1) = bar {
+    $0
+}
+}
+"#,
+        )
     }
 
     #[test]
diff --git a/crates/completion/src/completions/trait_impl.rs b/crates/completion/src/completions/trait_impl.rs
index aa9c845da..135ae49dc 100644
--- a/crates/completion/src/completions/trait_impl.rs
+++ b/crates/completion/src/completions/trait_impl.rs
@@ -93,11 +93,11 @@ fn completion_match(ctx: &CompletionContext) -> Option<(ImplCompletionKind, Synt
         // `impl .. { const $0 }`
         // ERROR      0
         //   CONST_KW <- *
-        SyntaxKind::CONST_KW => 0,
+        T![const] => 0,
         // `impl .. { fn/type $0 }`
         // FN/TYPE_ALIAS  0
         //   FN_KW        <- *
-        SyntaxKind::FN_KW | SyntaxKind::TYPE_KW => 0,
+        T![fn] | T![type] => 0,
         // `impl .. { fn/type/const foo$0 }`
         // FN/TYPE_ALIAS/CONST  1
         //  NAME                0
@@ -121,7 +121,7 @@ fn completion_match(ctx: &CompletionContext) -> Option<(ImplCompletionKind, Synt
     let impl_def = ast::Impl::cast(impl_item.parent()?.parent()?)?;
     let kind = match impl_item.kind() {
         // `impl ... { const $0 fn/type/const }`
-        _ if token.kind() == SyntaxKind::CONST_KW => ImplCompletionKind::Const,
+        _ if token.kind() == T![const] => ImplCompletionKind::Const,
         SyntaxKind::CONST | SyntaxKind::ERROR => ImplCompletionKind::Const,
         SyntaxKind::TYPE_ALIAS => ImplCompletionKind::TypeAlias,
         SyntaxKind::FN => ImplCompletionKind::Fn,
diff --git a/crates/completion/src/patterns.rs b/crates/completion/src/patterns.rs
index f148b9402..f3ce91dd1 100644
--- a/crates/completion/src/patterns.rs
+++ b/crates/completion/src/patterns.rs
@@ -5,7 +5,7 @@ use syntax::{
     ast::{self, LoopBodyOwner},
     match_ast, AstNode, Direction, NodeOrToken, SyntaxElement,
     SyntaxKind::*,
-    SyntaxNode, SyntaxToken,
+    SyntaxNode, SyntaxToken, T,
 };
 
 #[cfg(test)]
@@ -119,7 +119,7 @@ pub(crate) fn unsafe_is_prev(element: SyntaxElement) -> bool {
     element
         .into_token()
         .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == UNSAFE_KW)
+        .filter(|it| it.kind() == T![unsafe])
         .is_some()
 }
 #[test]
@@ -131,7 +131,7 @@ pub(crate) fn if_is_prev(element: SyntaxElement) -> bool {
     element
         .into_token()
         .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == IF_KW)
+        .filter(|it| it.kind() == T![if])
         .is_some()
 }
 
@@ -139,7 +139,7 @@ pub(crate) fn fn_is_prev(element: SyntaxElement) -> bool {
     element
         .into_token()
         .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == FN_KW)
+        .filter(|it| it.kind() == T![fn])
         .is_some()
 }
 #[test]
@@ -154,7 +154,7 @@ pub(crate) fn for_is_prev2(element: SyntaxElement) -> bool {
         .into_token()
         .and_then(|it| previous_non_trivia_token(it))
         .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == FOR_KW)
+        .filter(|it| it.kind() == T![for])
         .is_some()
 }
 #[test]
diff --git a/crates/flycheck/Cargo.toml b/crates/flycheck/Cargo.toml
index 1bad64a1b..1d19c7886 100644
--- a/crates/flycheck/Cargo.toml
+++ b/crates/flycheck/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 crossbeam-channel = "0.5.0"
 log = "0.4.8"
-cargo_metadata = "=0.12.0"
+cargo_metadata = "0.12.2"
 serde_json = "1.0.48"
 jod-thread = "0.1.1"
 
diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index cc1938333..6cbf5cecf 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -1263,6 +1263,24 @@ pub enum GenericParam {
 }
 impl_from!(TypeParam, LifetimeParam, ConstParam for GenericParam);
 
+impl GenericParam {
+    pub fn module(self, db: &dyn HirDatabase) -> Module {
+        match self {
+            GenericParam::TypeParam(it) => it.module(db),
+            GenericParam::LifetimeParam(it) => it.module(db),
+            GenericParam::ConstParam(it) => it.module(db),
+        }
+    }
+
+    pub fn name(self, db: &dyn HirDatabase) -> Name {
+        match self {
+            GenericParam::TypeParam(it) => it.name(db),
+            GenericParam::LifetimeParam(it) => it.name(db),
+            GenericParam::ConstParam(it) => it.name(db),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct TypeParam {
     pub(crate) id: TypeParamId,
diff --git a/crates/hir/src/from_id.rs b/crates/hir/src/from_id.rs
index 3e47a5e9d..c8c5fecd7 100644
--- a/crates/hir/src/from_id.rs
+++ b/crates/hir/src/from_id.rs
@@ -1,6 +1,6 @@
 //! Utility module for converting between hir_def ids and code_model wrappers.
 //!
-//! It's unclear if we need this long-term, but it's definitelly useful while we
+//! It's unclear if we need this long-term, but it's definitely useful while we
 //! are splitting the hir.
 
 use hir_def::{
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 6be1eaade..3dc33f248 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -581,7 +581,7 @@ impl ExprCollector<'_> {
         match res.value {
             Some((mark, expansion)) => {
                 // FIXME: Statements are too complicated to recover from error for now.
-                // It is because we don't have any hygenine for local variable expansion right now.
+                // It is because we don't have any hygiene for local variable expansion right now.
                 if T::can_cast(syntax::SyntaxKind::MACRO_STMTS) && res.err.is_some() {
                     self.expander.exit(self.db, mark);
                     collector(self, None);
@@ -959,7 +959,7 @@ impl ExprCollector<'_> {
 
     fn collect_tuple_pat(&mut self, args: AstChildren<ast::Pat>) -> (Vec<PatId>, Option<usize>) {
         // Find the location of the `..`, if there is one. Note that we do not
-        // consider the possiblity of there being multiple `..` here.
+        // consider the possibility of there being multiple `..` here.
         let ellipsis = args.clone().position(|p| matches!(p, ast::Pat::RestPat(_)));
         // We want to skip the `..` pattern here, since we account for it above.
         let args = args
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index 6a481769d..76f5721e5 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -1,6 +1,6 @@
 //! This module describes hir-level representation of expressions.
 //!
-//! This representaion is:
+//! This representation is:
 //!
 //! 1. Identity-based. Each expression has an `id`, so we can distinguish
 //!    between different `1` in `1 + 1`.
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 77017e4ea..f027fd48d 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -267,7 +267,7 @@ impl DefCollector<'_> {
 
         // Resolve all indeterminate resolved imports again
         // As some of the macros will expand newly import shadowing partial resolved imports
-        // FIXME: We maybe could skip this, if we handle the Indetermine imports in `resolve_imports`
+        // FIXME: We maybe could skip this, if we handle the indeterminate imports in `resolve_imports`
         // correctly
         let partial_resolved = self.resolved_imports.iter().filter_map(|directive| {
             if let PartialResolvedImport::Indeterminate(_) = directive.status {
@@ -402,7 +402,7 @@ impl DefCollector<'_> {
 
     /// Define a proc macro
     ///
-    /// A proc macro is similar to normal macro scope, but it would not visiable in legacy textual scoped.
+    /// A proc macro is similar to normal macro scope, but it would not visible in legacy textual scoped.
     /// And unconditionally exported.
     fn define_proc_macro(&mut self, name: Name, macro_: MacroDefId) {
         self.update(
@@ -592,7 +592,7 @@ impl DefCollector<'_> {
                     // XXX: urgh, so this works by accident! Here, we look at
                     // the enum data, and, in theory, this might require us to
                     // look back at the crate_def_map, creating a cycle. For
-                    // example, `enum E { crate::some_macro!(); }`. Luckely, the
+                    // example, `enum E { crate::some_macro!(); }`. Luckily, the
                     // only kind of macro that is allowed inside enum is a
                     // `cfg_macro`, and we don't need to run name resolution for
                     // it, but this is sheer luck!
@@ -655,7 +655,7 @@ impl DefCollector<'_> {
         &mut self,
         module_id: LocalModuleId,
         resolutions: &[(Option<Name>, PerNs)],
-        // All resolutions are imported with this visibility; the visibilies in
+        // All resolutions are imported with this visibility; the visibilities in
         // the `PerNs` values are ignored and overwritten
         vis: Visibility,
         import_type: ImportType,
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index 129f1dbac..e4152a0be 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -27,7 +27,7 @@ use crate::{
 
 #[derive(Debug, Clone, Default)]
 pub struct Resolver {
-    // FIXME: all usages generally call `.rev`, so maybe reverse once in consturciton?
+    // FIXME: all usages generally call `.rev`, so maybe reverse once in construction?
     scopes: Vec<Scope>,
 }
 
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index ab2637b8c..c62086390 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -40,7 +40,7 @@ impl TokenExpander {
             // FIXME switch these to ExpandResult as well
             TokenExpander::BuiltinDerive(it) => it.expand(db, id, tt).into(),
             TokenExpander::ProcMacro(_) => {
-                // We store the result in salsa db to prevent non-determinisc behavior in
+                // We store the result in salsa db to prevent non-deterministic behavior in
                 // some proc-macro implementation
                 // See #4315 for details
                 db.expand_proc_macro(id.into()).into()
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index a1c484fdf..107417c27 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -379,7 +379,7 @@ pub fn record_literal_missing_fields(
     id: ExprId,
     expr: &Expr,
 ) -> Option<(VariantId, Vec<LocalFieldId>, /*exhaustive*/ bool)> {
-    let (fields, exhausitve) = match expr {
+    let (fields, exhaustive) = match expr {
         Expr::RecordLit { path: _, fields, spread } => (fields, spread.is_none()),
         _ => return None,
     };
@@ -400,7 +400,7 @@ pub fn record_literal_missing_fields(
     if missed_fields.is_empty() {
         return None;
     }
-    Some((variant_def, missed_fields, exhausitve))
+    Some((variant_def, missed_fields, exhaustive))
 }
 
 pub fn record_pattern_missing_fields(
diff --git a/crates/hir_ty/src/diagnostics/match_check.rs b/crates/hir_ty/src/diagnostics/match_check.rs
index 62c329731..61c47eec8 100644
--- a/crates/hir_ty/src/diagnostics/match_check.rs
+++ b/crates/hir_ty/src/diagnostics/match_check.rs
@@ -14,7 +14,7 @@
 //! The algorithm implemented here is a modified version of the one described in
 //! <http://moscova.inria.fr/~maranget/papers/warn/index.html>.
 //! However, to save future implementors from reading the original paper, we
-//! summarise the algorithm here to hopefully save time and be a little clearer
+//! summarize the algorithm here to hopefully save time and be a little clearer
 //! (without being so rigorous).
 //!
 //! The core of the algorithm revolves about a "usefulness" check. In particular, we
@@ -132,7 +132,7 @@
 //! The algorithm is inductive (on the number of columns: i.e., components of tuple patterns).
 //! That means we're going to check the components from left-to-right, so the algorithm
 //! operates principally on the first component of the matrix and new pattern-stack `p`.
-//! This algorithm is realised in the `is_useful` function.
+//! This algorithm is realized in the `is_useful` function.
 //!
 //! Base case (`n = 0`, i.e., an empty tuple pattern):
 //! - If `P` already contains an empty pattern (i.e., if the number of patterns `m > 0`), then
diff --git a/crates/hir_ty/src/lower.rs b/crates/hir_ty/src/lower.rs
index 222f61a11..9594cce8b 100644
--- a/crates/hir_ty/src/lower.rs
+++ b/crates/hir_ty/src/lower.rs
@@ -491,16 +491,16 @@ impl Ty {
     fn from_hir_path_inner(
         ctx: &TyLoweringContext<'_>,
         segment: PathSegment<'_>,
-        typable: TyDefId,
+        typeable: TyDefId,
         infer_args: bool,
     ) -> Ty {
-        let generic_def = match typable {
+        let generic_def = match typeable {
             TyDefId::BuiltinType(_) => None,
             TyDefId::AdtId(it) => Some(it.into()),
             TyDefId::TypeAliasId(it) => Some(it.into()),
         };
         let substs = substs_from_path_segment(ctx, segment, generic_def, infer_args);
-        ctx.db.ty(typable).subst(&substs)
+        ctx.db.ty(typeable).subst(&substs)
     }
 
     /// Collect generic arguments from a path into a `Substs`. See also
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 1ff818de2..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) {
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index 95b4cb9e3..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,
         }
@@ -1145,4 +1200,34 @@ fn foo<'foo>(_: &'foo ()) {
 }"#,
         )
     }
+
+    #[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/hover.rs b/crates/ide/src/hover.rs
index 88d215129..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, runnable_fn},
+    runnables::{runnable_fn, runnable_mod},
     FileId, FilePosition, NavigationTarget, RangeInfo, Runnable,
 };
 
@@ -187,7 +187,7 @@ fn runnable_action(
         Definition::ModuleDef(it) => match it {
             ModuleDef::Module(it) => match it.definition_source(sema.db).value {
                 ModuleSource::Module(it) => {
-                    runnable(&sema, it.syntax().clone()).map(|it| HoverAction::Runnable(it))
+                    runnable_mod(&sema, it).map(|it| HoverAction::Runnable(it))
                 }
                 _ => None,
             },
@@ -215,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,
         };
 
@@ -352,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>
@@ -1946,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]()
@@ -1982,16 +1984,16 @@ pub fn fo$0o() {}
                 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
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index a74829cd0..3e9a65d9c 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -353,13 +353,25 @@ fn is_argument_similar_to_param_name(
     }
     match get_string_representation(argument) {
         None => false,
-        Some(mut repr) => {
-            let param_name = param_name.to_ascii_lowercase();
-            let argument_string = {
-                repr.make_ascii_lowercase();
-                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)),
+            )
         }
     }
 }
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 409507bd0..1f368cbd0 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -76,7 +76,7 @@ pub use crate::{
     references::{rename::RenameError, Declaration, ReferenceSearchResult},
     runnables::{Runnable, RunnableKind, TestId},
     syntax_highlighting::{
-        tags::{Highlight, HlMod, HlMods, HlTag},
+        tags::{Highlight, HlMod, HlMods, HlPunct, HlTag},
         HlRange,
     },
 };
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index c95ed669c..b774a2be1 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
@@ -21,7 +21,7 @@ use ide_db::{
 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};
@@ -130,7 +130,10 @@ 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;
     };
 
@@ -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,7 @@ 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 self_token = syntax.token_at_offset(position.offset).find(|t| t.kind() == T![self])?;
     let parent = self_token.parent();
     match_ast! {
         match parent {
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 44dfa9a0e..3edc43e08 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -1005,7 +1005,7 @@ use crate::foo$0::FooContent;
 //- /lib.rs
 mod fo$0o;
 //- /foo/mod.rs
-// emtpy
+// empty
 "#,
             expect![[r#"
                 RangeInfo {
@@ -1055,7 +1055,7 @@ mod fo$0o;
 mod outer { mod fo$0o; }
 
 //- /outer/foo.rs
-// emtpy
+// empty
 "#,
             expect![[r#"
                 RangeInfo {
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
index 557563d7e..f5ee7de86 100644
--- a/crates/ide/src/runnables.rs
+++ b/crates/ide/src/runnables.rs
@@ -3,7 +3,7 @@ use std::fmt;
 use assists::utils::test_related_attribute;
 use cfg::CfgExpr;
 use hir::{AsAssocItem, HasAttrs, HasSource, Semantics};
-use ide_db::RootDatabase;
+use ide_db::{defs::Definition, RootDatabase};
 use itertools::Itertools;
 use syntax::{
     ast::{self, AstNode, AttrsOwner, ModuleItemOwner},
@@ -96,21 +96,26 @@ 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)).collect()
-}
-
-pub(crate) fn runnable(sema: &Semantics<RootDatabase>, item: SyntaxNode) -> Option<Runnable> {
-    let runnable_item = match_ast! {
-        match (item.clone()) {
-            ast::Fn(func) => {
-                let def = sema.to_def(&func)?;
-                runnable_fn(sema, def)
-            },
-            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()
 }
 
 pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) -> Option<Runnable> {
@@ -145,20 +150,49 @@ pub(crate) fn runnable_fn(sema: &Semantics<RootDatabase>, def: hir::Function) ->
     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> {
@@ -253,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 {
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index ad456bc00..f2d4da78d 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -3,30 +3,29 @@ pub(crate) mod tags;
 mod highlights;
 mod injector;
 
+mod highlight;
 mod format;
-mod injection;
 mod macro_rules;
+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, HlMod, HlTag, SymbolKind,
 };
@@ -73,12 +72,22 @@ pub(crate) fn highlight(
         }
     };
 
-    let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default();
     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();
 
     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;
 
@@ -110,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();
             }
             _ => (),
         }
@@ -128,26 +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((new_comments, inj)) = injection::extract_doc_comments(node) {
-                    injection::highlight_doc_comment(new_comments, inj, &mut hl);
-                }
-            }
             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();
@@ -167,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(),
@@ -181,13 +185,17 @@ 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 hl, &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,
@@ -197,31 +205,25 @@ pub(crate) fn highlight(
                 highlight = highlight | HlMod::Attribute;
             }
 
-            if macro_rules_highlighter.highlight(element_to_highlight.clone()).is_none() {
-                hl.add(HlRange { range, highlight, binding_hash });
-            }
+            hl.add(HlRange { range, highlight, binding_hash });
+        }
 
-            if let Some(string) =
-                element_to_highlight.as_token().cloned().and_then(ast::String::cast)
-            {
-                format_string_highlighter.highlight_format_string(&mut 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,
-                            });
-                        }
+        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,
+                        });
                     }
                 }
             }
         }
     }
-
-    hl.to_vec()
 }
 
 fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
@@ -239,505 +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(_)) => 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.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(),
-            _ => HlTag::Punctuation.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: &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 = 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_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::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),
-        Definition::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),
-        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::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),
-        Definition::Label(_) => HlTag::Symbol(SymbolKind::Label),
-    }
-    .into()
-}
-
-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(|method_call| highlight_method_call(sema, &method_call))
-                .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(),
-    }
-}
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs
index d807ad0ad..a74ca844b 100644
--- a/crates/ide/src/syntax_highlighting/format.rs
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -1,60 +1,48 @@
 //! Syntax highlighting for format macro strings.
 use syntax::{
     ast::{self, FormatSpecifier, HasFormatSpecifier},
-    AstNode, AstToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange,
+    AstNode, AstToken, TextRange,
 };
 
-use crate::{HlRange, HlTag, SymbolKind};
+use crate::{syntax_highlighting::highlights::Highlights, HlRange, HlTag, SymbolKind};
 
-use super::highlights::Highlights;
+pub(super) fn highlight_format_string(
+    stack: &mut Highlights,
+    string: &ast::String,
+    range: TextRange,
+) {
+    if is_format_string(string).is_none() {
+        return;
+    }
 
-#[derive(Default)]
-pub(super) struct FormatStringHighlighter {
-    format_string: Option<SyntaxElement>,
+    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,
+            });
+        }
+    });
 }
 
-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()))
-                }
-                _ => {}
-            }
-        }
+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;
     }
-    pub(super) fn highlight_format_string(
-        &self,
-        stack: &mut Highlights,
-        string: &impl HasFormatSpecifier,
-        range: TextRange,
-    ) {
-        if self.format_string.as_ref() == Some(&SyntaxElement::from(string.syntax().clone())) {
-            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,
-                    });
-                }
-            });
-        }
+
+    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<HlTag> {
@@ -70,7 +58,9 @@ fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HlTag> {
         | FormatSpecifier::Dot
         | FormatSpecifier::Asterisk
         | 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
index 11c11ed28..c6f0417ec 100644
--- a/crates/ide/src/syntax_highlighting/highlights.rs
+++ b/crates/ide/src/syntax_highlighting/highlights.rs
@@ -51,18 +51,20 @@ impl Node {
             }
         }
 
-        let (start, len) =
+        let overlapping =
             equal_range_by(&self.nested, |n| ordering(n.hl_range.range, hl_range.range));
 
-        if len == 1 && self.nested[start].hl_range.range.contains_range(hl_range.range) {
-            return self.nested[start].add(hl_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(start..start + len, iter::once(Node::new(hl_range)))
+            .splice(overlapping.clone(), iter::once(Node::new(hl_range)))
             .collect::<Vec<_>>();
-        self.nested[start].nested = nested;
+        self.nested[overlapping.start].nested = nested;
     }
 
     fn flatten(&self, acc: &mut Vec<HlRange>) {
diff --git a/crates/ide/src/syntax_highlighting/injection.rs b/crates/ide/src/syntax_highlighting/inject.rs
index 008d5ce24..281461493 100644
--- a/crates/ide/src/syntax_highlighting/injection.rs
+++ b/crates/ide/src/syntax_highlighting/inject.rs
@@ -1,17 +1,14 @@
-//! Syntax highlighting injections such as highlighting of documentation tests.
-
-use std::convert::TryFrom;
+//! "Recursive" Syntax highlighting for code in doctests and fixtures.
 
 use hir::Semantics;
 use ide_db::call_info::ActiveParameter;
-use itertools::Itertools;
 use syntax::{ast, AstToken, SyntaxNode, SyntaxToken, TextRange, TextSize};
 
 use crate::{Analysis, HlMod, HlRange, HlTag, RootDatabase};
 
 use super::{highlights::Highlights, injector::Injector};
 
-pub(super) fn highlight_injection(
+pub(super) fn ra_fixture(
     hl: &mut Highlights,
     sema: &Semantics<RootDatabase>,
     literal: ast::String,
@@ -84,107 +81,78 @@ const RUSTDOC_FENCE_TOKENS: &[&'static str] = &[
     "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<(Vec<HlRange>, Injector)> {
+/// 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();
-    // wrap the doctest into function body to get correct syntax highlighting
-    let prefix = "fn doctest() {\n";
-    let suffix = "}\n";
+    inj.add_unmapped("fn doctest() {\n");
 
-    let mut line_start = TextSize::of(prefix);
     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();
-
-    inj.add_unmapped(prefix);
-    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) {
+    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;
-                false
-            } else {
-                is_doctest
+                continue;
             }
-        })
-        .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
-            };
-
-            new_comments.push(HlRange {
-                range: TextRange::new(
-                    range.start(),
-                    range.start() + TextSize::try_from(pos).unwrap(),
-                ),
-                highlight: HlTag::Comment | HlMod::Documentation,
-                binding_hash: None,
-            });
-            line_start += range.len() - TextSize::try_from(pos).unwrap();
-            line_start += TextSize::of("\n");
-
-            inj.add(
-                &line[pos..],
-                TextRange::new(range.start() + TextSize::try_from(pos).unwrap(), range.end()),
-            );
-            inj.add_unmapped("\n");
-            line[pos..].to_owned()
-        })
-        .join("\n");
-    inj.add_unmapped(suffix);
-
-    if doctest.is_empty() {
-        return None;
-    }
+            None if !is_doctest => continue,
+            None => (),
+        }
 
-    Some((new_comments, inj))
-}
+        let line: &str = comment.text().as_str();
+        let range = comment.syntax().text_range();
 
-/// Injection of syntax highlighting of doctests.
-pub(super) fn highlight_doc_comment(
-    new_comments: Vec<HlRange>,
-    inj: Injector,
-    stack: &mut Highlights,
-) {
-    let (analysis, tmp_file_id) = Analysis::from_single_file(inj.text().to_string());
-    for comment in new_comments {
-        stack.add(comment);
+        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) {
-            stack.add(HlRange {
+            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/injector.rs b/crates/ide/src/syntax_highlighting/injector.rs
index e8f17eb69..fd4025694 100644
--- a/crates/ide/src/syntax_highlighting/injector.rs
+++ b/crates/ide/src/syntax_highlighting/injector.rs
@@ -33,8 +33,7 @@ impl Injector {
         &self.buf
     }
     pub(super) fn map_range_up(&self, range: TextRange) -> impl Iterator<Item = TextRange> + '_ {
-        let (start, len) = equal_range_by(&self.ranges, |&(r, _)| ordering(r, range));
-        (start..start + len).filter_map(move |i| {
+        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?)
diff --git a/crates/ide/src/syntax_highlighting/macro_rules.rs b/crates/ide/src/syntax_highlighting/macro_rules.rs
index 21d8a9835..44620e912 100644
--- a/crates/ide/src/syntax_highlighting/macro_rules.rs
+++ b/crates/ide/src/syntax_highlighting/macro_rules.rs
@@ -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 2f39bcc8e..8dd05ac52 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -29,7 +29,7 @@ pub enum HlTag {
     EscapeSequence,
     FormatSpecifier,
     Keyword,
-    Punctuation,
+    Punctuation(HlPunct),
     Operator,
     UnresolvedReference,
 
@@ -61,6 +61,28 @@ pub enum HlMod {
     Unsafe,
 }
 
+#[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 {
@@ -95,7 +117,17 @@ impl HlTag {
             HlTag::EscapeSequence => "escape_sequence",
             HlTag::FormatSpecifier => "format_specifier",
             HlTag::Keyword => "keyword",
-            HlTag::Punctuation => "punctuation",
+            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",
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 7d1d2a839..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,72 +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="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="punctuation injected">;</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="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="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">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="punctuation injected">;</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="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">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="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="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="none injected"> </span><span class="keyword injected">mut</span><span class="none injected"> </span><span class="variable declaration injected mutable">foo</span><span class="punctuation 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="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</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="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="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="none 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="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="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="none injected">foo</span><span class="operator injected">.</span><span class="none 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="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="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 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="punctuation injected">;</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="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="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="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="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="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></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