From 6fb52af521ab8ca2fdd3ea7cfa95eaebd0cba1fc Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sat, 9 Jan 2021 14:41:31 +0300 Subject: Rename dummy -> none --- crates/ide/src/syntax_highlighting/highlights.rs | 2 +- crates/ide/src/syntax_highlighting/tags.rs | 8 ++++---- .../test_data/highlight_doctest.html | 20 ++++++++++---------- crates/rust-analyzer/src/to_proto.rs | 2 +- 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/crates/ide/src/syntax_highlighting/highlights.rs b/crates/ide/src/syntax_highlighting/highlights.rs index 3e733c87c..7ff1593ae 100644 --- a/crates/ide/src/syntax_highlighting/highlights.rs +++ b/crates/ide/src/syntax_highlighting/highlights.rs @@ -20,7 +20,7 @@ impl Highlights { Highlights { root: Node::new(HighlightedRange { range, - highlight: HighlightTag::Dummy.into(), + highlight: HighlightTag::None.into(), binding_hash: None, }), } diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs index a0286b72d..07c788b50 100644 --- a/crates/ide/src/syntax_highlighting/tags.rs +++ b/crates/ide/src/syntax_highlighting/tags.rs @@ -33,8 +33,8 @@ pub enum HighlightTag { Operator, UnresolvedReference, - // For things which don't have proper Tag, but want to use modifiers. - Dummy, + // For things which don't have a specific highlight. + None, } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] @@ -100,7 +100,7 @@ impl HighlightTag { HighlightTag::Operator => "operator", HighlightTag::StringLiteral => "string_literal", HighlightTag::UnresolvedReference => "unresolved_reference", - HighlightTag::Dummy => "dummy", + HighlightTag::None => "none", } } } @@ -174,7 +174,7 @@ impl Highlight { Highlight { tag, modifiers: HighlightModifiers::default() } } pub fn is_empty(&self) -> bool { - self.tag == HighlightTag::Dummy && self.modifiers == HighlightModifiers::default() + self.tag == HighlightTag::None && self.modifiers == HighlightModifiers::default() } } 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 9d42b11c1..7d1d2a839 100644 --- a/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html +++ b/crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html @@ -37,7 +37,7 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd .unresolved_reference { color: #FC5555; text-decoration: wavy underline; } 
/// ```
-/// let _ = "early doctests should not go boom";
+/// let _ = "early doctests should not go boom";
 /// ```
 struct Foo {
     bar: bool,
@@ -45,7 +45,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
 impl Foo {
     /// ```
-    /// let _ = "Call me
+    /// let _ = "Call me
     //    KILLER WHALE
     ///     Ishmael.";
     /// ```
@@ -56,8 +56,8 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     /// # Examples
     ///
     /// ```
-    /// # #![allow(unused_mut)]
-    /// let mut foo: Foo = Foo::new();
+    /// # #![allow(unused_mut)]
+    /// let mut foo: Foo = Foo::new();
     /// ```
     pub const fn new() -> Foo {
         Foo { bar: true }
@@ -68,26 +68,26 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
     /// # Examples
     ///
     /// ```
-    /// use x::y;
+    /// use x::y;
     ///
-    /// let foo = Foo::new();
+    /// let foo = Foo::new();
     ///
     /// // calls bar on foo
-    /// assert!(foo.bar());
+    /// assert!(foo.bar());
     ///
-    /// let bar = foo.bar || Foo::bar;
+    /// let bar = foo.bar || Foo::bar;
     ///
     /// /* multi-line
     ///        comment */
     ///
-    /// let multi_line_string = "Foo
+    /// let multi_line_string = "Foo
     ///   bar
     ///          ";
     ///
     /// ```
     ///
     /// ```rust,no_run
-    /// let foobar = Foo::new().bar();
+    /// let foobar = Foo::new().bar();
     /// ```
     ///
     /// ```sh
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 204cae265..4cfe6ff51 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -413,7 +413,7 @@ fn semantic_token_type_and_modifiers(
             SymbolKind::Macro => lsp_types::SemanticTokenType::MACRO,
         },
         HighlightTag::BuiltinType => semantic_tokens::BUILTIN_TYPE,
-        HighlightTag::Dummy => semantic_tokens::GENERIC,
+        HighlightTag::None => semantic_tokens::GENERIC,
         HighlightTag::ByteLiteral | HighlightTag::NumericLiteral => {
             lsp_types::SemanticTokenType::NUMBER
         }
-- 
cgit v1.2.3


From 64a6ee45351a71cdeb1d1dddc8fc746abdcff07b Mon Sep 17 00:00:00 2001
From: Aleksey Kladov 
Date: Sat, 9 Jan 2021 14:44:01 +0300
Subject: Shorten frequent names

---
 crates/ide/src/lib.rs                             |   2 +-
 crates/ide/src/syntax_highlighting.rs             | 239 ++++++++++------------
 crates/ide/src/syntax_highlighting/format.rs      |  10 +-
 crates/ide/src/syntax_highlighting/highlights.rs  |   4 +-
 crates/ide/src/syntax_highlighting/injection.rs   |  10 +-
 crates/ide/src/syntax_highlighting/macro_rules.rs |   4 +-
 crates/ide/src/syntax_highlighting/tags.rs        | 134 ++++++------
 crates/rust-analyzer/src/to_proto.rs              |  65 +++---
 8 files changed, 222 insertions(+), 246 deletions(-)

diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index cea2a13c8..674c72c23 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, HighlightModifier, HighlightModifiers, HighlightTag},
+        tags::{Highlight, HlMod, HlMods, HlTag},
         HighlightedRange,
     },
 };
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 2eb63a0b7..d73ddf35b 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -26,7 +26,7 @@ use crate::{
     syntax_highlighting::{
         format::FormatStringHighlighter, macro_rules::MacroRulesHighlighter, tags::Highlight,
     },
-    FileId, HighlightModifier, HighlightTag, SymbolKind,
+    FileId, HlMod, HlTag, SymbolKind,
 };
 
 pub(crate) use html::highlight_as_html;
@@ -98,7 +98,7 @@ pub(crate) fn highlight(
                 if let Some(range) = macro_call_range(&mc) {
                     stack.add(HighlightedRange {
                         range,
-                        highlight: HighlightTag::Symbol(SymbolKind::Macro).into(),
+                        highlight: HlTag::Symbol(SymbolKind::Macro).into(),
                         binding_hash: None,
                     });
                 }
@@ -192,7 +192,7 @@ pub(crate) fn highlight(
             element_to_highlight.clone(),
         ) {
             if inside_attribute {
-                highlight = highlight | HighlightModifier::Attribute;
+                highlight = highlight | HlMod::Attribute;
             }
 
             if macro_rules_highlighter.highlight(element_to_highlight.clone()).is_none() {
@@ -209,7 +209,7 @@ pub(crate) fn highlight(
                         if string.text()[piece_range.start().into()..].starts_with('\\') {
                             stack.add(HighlightedRange {
                                 range: piece_range + range.start(),
-                                highlight: HighlightTag::EscapeSequence.into(),
+                                highlight: HlTag::EscapeSequence.into(),
                                 binding_hash: None,
                             });
                         }
@@ -292,22 +292,20 @@ fn highlight_element(
             };
 
             match name_kind {
-                Some(NameClass::ExternCrate(_)) => HighlightTag::Symbol(SymbolKind::Module).into(),
-                Some(NameClass::Definition(def)) => {
-                    highlight_def(db, def) | HighlightModifier::Definition
-                }
+                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 = HighlightTag::Symbol(SymbolKind::Field).into();
+                    let mut h = HlTag::Symbol(SymbolKind::Field).into();
                     if let Definition::Field(field) = field_ref {
                         if let VariantDef::Union(_) = field.parent_def(db) {
-                            h |= HighlightModifier::Unsafe;
+                            h |= HlMod::Unsafe;
                         }
                     }
 
                     h
                 }
-                None => highlight_name_by_syntax(name) | HighlightModifier::Definition,
+                None => highlight_name_by_syntax(name) | HlMod::Definition,
             }
         }
 
@@ -315,16 +313,14 @@ fn highlight_element(
         NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => {
             // even though we track whether we are in an attribute or not we still need this special case
             // as otherwise we would emit unresolved references for name refs inside attributes
-            Highlight::from(HighlightTag::Symbol(SymbolKind::Function))
+            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(_) => {
-                            HighlightTag::Symbol(SymbolKind::Module).into()
-                        }
+                        NameRefClass::ExternCrate(_) => HlTag::Symbol(SymbolKind::Module).into(),
                         NameRefClass::Definition(def) => {
                             if let Definition::Local(local) = &def {
                                 if let Some(name) = local.name(db) {
@@ -338,7 +334,7 @@ fn highlight_element(
 
                             if let Definition::Local(local) = &def {
                                 if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) {
-                                    h |= HighlightModifier::Consuming;
+                                    h |= HlMod::Consuming;
                                 }
                             }
 
@@ -346,7 +342,7 @@ fn highlight_element(
                                 if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) {
                                     if let Definition::Field(field) = def {
                                         if let VariantDef::Union(_) = field.parent_def(db) {
-                                            h |= HighlightModifier::Unsafe;
+                                            h |= HlMod::Unsafe;
                                         }
                                     }
                                 }
@@ -355,13 +351,13 @@ fn highlight_element(
                             h
                         }
                         NameRefClass::FieldShorthand { .. } => {
-                            HighlightTag::Symbol(SymbolKind::Field).into()
+                            HlTag::Symbol(SymbolKind::Field).into()
                         }
                     },
                     None if syntactic_name_ref_highlighting => {
                         highlight_name_ref_by_syntax(name_ref, sema)
                     }
-                    None => HighlightTag::UnresolvedReference.into(),
+                    None => HlTag::UnresolvedReference.into(),
                 }
             })
         }
@@ -369,60 +365,53 @@ fn highlight_element(
         // Simple token-based highlighting
         COMMENT => {
             let comment = element.into_token().and_then(ast::Comment::cast)?;
-            let h = HighlightTag::Comment;
+            let h = HlTag::Comment;
             match comment.kind().doc {
-                Some(_) => h | HighlightModifier::Documentation,
+                Some(_) => h | HlMod::Documentation,
                 None => h.into(),
             }
         }
-        STRING | BYTE_STRING => HighlightTag::StringLiteral.into(),
-        ATTR => HighlightTag::Attribute.into(),
-        INT_NUMBER | FLOAT_NUMBER => HighlightTag::NumericLiteral.into(),
-        BYTE => HighlightTag::ByteLiteral.into(),
-        CHAR => HighlightTag::CharLiteral.into(),
-        QUESTION => Highlight::new(HighlightTag::Operator) | HighlightModifier::ControlFlow,
+        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) | HighlightModifier::Definition
-                }
+                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(HighlightTag::Symbol(SymbolKind::LifetimeParam)),
+                    _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)),
                 },
-                _ => {
-                    Highlight::new(HighlightTag::Symbol(SymbolKind::LifetimeParam))
-                        | HighlightModifier::Definition
-                }
+                _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)) | HlMod::Definition,
             }
         }
         p if p.is_punct() => match p {
             T![&] => {
-                let h = HighlightTag::Operator.into();
+                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 | HighlightModifier::Unsafe
+                    h | HlMod::Unsafe
                 } else {
                     h
                 }
             }
-            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => {
-                HighlightTag::Operator.into()
-            }
+            T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => HlTag::Operator.into(),
             T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
-                HighlightTag::Symbol(SymbolKind::Macro).into()
+                HlTag::Symbol(SymbolKind::Macro).into()
             }
             T![!] if element.parent().and_then(ast::NeverType::cast).is_some() => {
-                HighlightTag::BuiltinType.into()
+                HlTag::BuiltinType.into()
             }
             T![*] if element.parent().and_then(ast::PtrType::cast).is_some() => {
-                HighlightTag::Keyword.into()
+                HlTag::Keyword.into()
             }
             T![*] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
                 let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
@@ -430,11 +419,11 @@ fn highlight_element(
                 let expr = prefix_expr.expr()?;
                 let ty = sema.type_of_expr(&expr)?;
                 if ty.is_raw_ptr() {
-                    HighlightTag::Operator | HighlightModifier::Unsafe
+                    HlTag::Operator | HlMod::Unsafe
                 } else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() {
-                    HighlightTag::Operator.into()
+                    HlTag::Operator.into()
                 } else {
-                    HighlightTag::Punctuation.into()
+                    HlTag::Punctuation.into()
                 }
             }
             T![-] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
@@ -442,34 +431,26 @@ fn highlight_element(
 
                 let expr = prefix_expr.expr()?;
                 match expr {
-                    ast::Expr::Literal(_) => HighlightTag::NumericLiteral,
-                    _ => HighlightTag::Operator,
+                    ast::Expr::Literal(_) => HlTag::NumericLiteral,
+                    _ => HlTag::Operator,
                 }
                 .into()
             }
             _ if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
-                HighlightTag::Operator.into()
-            }
-            _ if element.parent().and_then(ast::BinExpr::cast).is_some() => {
-                HighlightTag::Operator.into()
+                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() => {
-                HighlightTag::Operator.into()
-            }
-            _ if element.parent().and_then(ast::RangePat::cast).is_some() => {
-                HighlightTag::Operator.into()
-            }
-            _ if element.parent().and_then(ast::RestPat::cast).is_some() => {
-                HighlightTag::Operator.into()
-            }
-            _ if element.parent().and_then(ast::Attr::cast).is_some() => {
-                HighlightTag::Attribute.into()
+                HlTag::Operator.into()
             }
-            _ => HighlightTag::Punctuation.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(HighlightTag::Keyword);
+            let h = Highlight::new(HlTag::Keyword);
             match k {
                 T![break]
                 | T![continue]
@@ -479,10 +460,10 @@ fn highlight_element(
                 | T![match]
                 | T![return]
                 | T![while]
-                | T![in] => h | HighlightModifier::ControlFlow,
-                T![for] if !is_child_of_impl(&element) => h | HighlightModifier::ControlFlow,
-                T![unsafe] => h | HighlightModifier::Unsafe,
-                T![true] | T![false] => HighlightTag::BoolLiteral.into(),
+                | T![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()
@@ -495,7 +476,7 @@ fn highlight_element(
                         .and_then(SyntaxNode::parent)
                         .and_then(ast::Path::cast)
                         .and_then(|p| sema.resolve_path(&p));
-                    let mut h = HighlightTag::Symbol(SymbolKind::SelfParam).into();
+                    let mut h = HlTag::Symbol(SymbolKind::SelfParam).into();
                     if self_param_is_mut
                         || matches!(self_path,
                             Some(hir::PathResolution::Local(local))
@@ -503,12 +484,12 @@ fn highlight_element(
                                     && (local.is_mut(db) || local.ty(db).is_mutable_reference())
                         )
                     {
-                        h |= HighlightModifier::Mutable
+                        h |= HlMod::Mutable
                     }
 
                     if let Some(hir::PathResolution::Local(local)) = self_path {
                         if is_consumed_lvalue(element, &local, db) {
-                            h |= HighlightModifier::Consuming;
+                            h |= HlMod::Consuming;
                         }
                     }
 
@@ -519,7 +500,7 @@ fn highlight_element(
                     .and_then(ast::IdentPat::cast)
                     .and_then(|ident_pat| {
                         if sema.is_unsafe_ident_pat(&ident_pat) {
-                            Some(HighlightModifier::Unsafe)
+                            Some(HlMod::Unsafe)
                         } else {
                             None
                         }
@@ -568,21 +549,21 @@ fn highlight_method_call(
     method_call: &ast::MethodCallExpr,
 ) -> Option {
     let func = sema.resolve_method_call(&method_call)?;
-    let mut h = HighlightTag::Symbol(SymbolKind::Function).into();
-    h |= HighlightModifier::Associated;
+    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 |= HighlightModifier::Unsafe;
+        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 |= HighlightModifier::Mutable,
+            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 |= HighlightModifier::Consuming
+                        h |= HlMod::Consuming
                     }
                 }
             }
@@ -593,78 +574,78 @@ fn highlight_method_call(
 
 fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
     match def {
-        Definition::Macro(_) => HighlightTag::Symbol(SymbolKind::Macro),
-        Definition::Field(_) => HighlightTag::Symbol(SymbolKind::Field),
+        Definition::Macro(_) => HlTag::Symbol(SymbolKind::Macro),
+        Definition::Field(_) => HlTag::Symbol(SymbolKind::Field),
         Definition::ModuleDef(def) => match def {
-            hir::ModuleDef::Module(_) => HighlightTag::Symbol(SymbolKind::Module),
+            hir::ModuleDef::Module(_) => HlTag::Symbol(SymbolKind::Module),
             hir::ModuleDef::Function(func) => {
-                let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::Function));
+                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Function));
                 if func.as_assoc_item(db).is_some() {
-                    h |= HighlightModifier::Associated;
+                    h |= HlMod::Associated;
                     if func.self_param(db).is_none() {
-                        h |= HighlightModifier::Static
+                        h |= HlMod::Static
                     }
                 }
                 if func.is_unsafe(db) {
-                    h |= HighlightModifier::Unsafe;
+                    h |= HlMod::Unsafe;
                 }
                 return h;
             }
-            hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HighlightTag::Symbol(SymbolKind::Struct),
-            hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HighlightTag::Symbol(SymbolKind::Enum),
-            hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Symbol(SymbolKind::Union),
-            hir::ModuleDef::Variant(_) => HighlightTag::Symbol(SymbolKind::Variant),
+            hir::ModuleDef::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(HighlightTag::Symbol(SymbolKind::Const));
+                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Const));
                 if konst.as_assoc_item(db).is_some() {
-                    h |= HighlightModifier::Associated
+                    h |= HlMod::Associated
                 }
                 return h;
             }
-            hir::ModuleDef::Trait(_) => HighlightTag::Symbol(SymbolKind::Trait),
+            hir::ModuleDef::Trait(_) => HlTag::Symbol(SymbolKind::Trait),
             hir::ModuleDef::TypeAlias(type_) => {
-                let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::TypeAlias));
+                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::TypeAlias));
                 if type_.as_assoc_item(db).is_some() {
-                    h |= HighlightModifier::Associated
+                    h |= HlMod::Associated
                 }
                 return h;
             }
-            hir::ModuleDef::BuiltinType(_) => HighlightTag::BuiltinType,
+            hir::ModuleDef::BuiltinType(_) => HlTag::BuiltinType,
             hir::ModuleDef::Static(s) => {
-                let mut h = Highlight::new(HighlightTag::Symbol(SymbolKind::Static));
+                let mut h = Highlight::new(HlTag::Symbol(SymbolKind::Static));
                 if s.is_mut(db) {
-                    h |= HighlightModifier::Mutable;
-                    h |= HighlightModifier::Unsafe;
+                    h |= HlMod::Mutable;
+                    h |= HlMod::Unsafe;
                 }
                 return h;
             }
         },
-        Definition::SelfType(_) => HighlightTag::Symbol(SymbolKind::Impl),
-        Definition::TypeParam(_) => HighlightTag::Symbol(SymbolKind::TypeParam),
-        Definition::ConstParam(_) => HighlightTag::Symbol(SymbolKind::ConstParam),
+        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) {
-                HighlightTag::Symbol(SymbolKind::ValueParam)
+                HlTag::Symbol(SymbolKind::ValueParam)
             } else {
-                HighlightTag::Symbol(SymbolKind::Local)
+                HlTag::Symbol(SymbolKind::Local)
             };
             let mut h = Highlight::new(tag);
             if local.is_mut(db) || local.ty(db).is_mutable_reference() {
-                h |= HighlightModifier::Mutable;
+                h |= HlMod::Mutable;
             }
             if local.ty(db).as_callable(db).is_some() || local.ty(db).impls_fnonce(db) {
-                h |= HighlightModifier::Callable;
+                h |= HlMod::Callable;
             }
             return h;
         }
-        Definition::LifetimeParam(_) => HighlightTag::Symbol(SymbolKind::LifetimeParam),
-        Definition::Label(_) => HighlightTag::Symbol(SymbolKind::Label),
+        Definition::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),
+        Definition::Label(_) => HlTag::Symbol(SymbolKind::Label),
     }
     .into()
 }
 
 fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
-    let default = HighlightTag::UnresolvedReference;
+    let default = HlTag::UnresolvedReference;
 
     let parent = match name.syntax().parent() {
         Some(it) => it,
@@ -672,19 +653,19 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
     };
 
     let tag = match parent.kind() {
-        STRUCT => HighlightTag::Symbol(SymbolKind::Struct),
-        ENUM => HighlightTag::Symbol(SymbolKind::Enum),
-        VARIANT => HighlightTag::Symbol(SymbolKind::Variant),
-        UNION => HighlightTag::Symbol(SymbolKind::Union),
-        TRAIT => HighlightTag::Symbol(SymbolKind::Trait),
-        TYPE_ALIAS => HighlightTag::Symbol(SymbolKind::TypeAlias),
-        TYPE_PARAM => HighlightTag::Symbol(SymbolKind::TypeParam),
-        RECORD_FIELD => HighlightTag::Symbol(SymbolKind::Field),
-        MODULE => HighlightTag::Symbol(SymbolKind::Module),
-        FN => HighlightTag::Symbol(SymbolKind::Function),
-        CONST => HighlightTag::Symbol(SymbolKind::Const),
-        STATIC => HighlightTag::Symbol(SymbolKind::Static),
-        IDENT_PAT => HighlightTag::Symbol(SymbolKind::Local),
+        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,
     };
 
@@ -692,7 +673,7 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
 }
 
 fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics) -> Highlight {
-    let default = HighlightTag::UnresolvedReference;
+    let default = HlTag::UnresolvedReference;
 
     let parent = match name.syntax().parent() {
         Some(it) => it,
@@ -703,10 +684,10 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics {
             return ast::MethodCallExpr::cast(parent)
                 .and_then(|method_call| highlight_method_call(sema, &method_call))
-                .unwrap_or_else(|| HighlightTag::Symbol(SymbolKind::Function).into());
+                .unwrap_or_else(|| HlTag::Symbol(SymbolKind::Function).into());
         }
         FIELD_EXPR => {
-            let h = HighlightTag::Symbol(SymbolKind::Field);
+            let h = HlTag::Symbol(SymbolKind::Field);
             let is_union = ast::FieldExpr::cast(parent)
                 .and_then(|field_expr| {
                     let field = sema.resolve_field(&field_expr)?;
@@ -718,7 +699,7 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics {
                     // within path, decide whether it is module or adt by checking for uppercase name
                     return if name.text().chars().next().unwrap_or_default().is_uppercase() {
-                        HighlightTag::Symbol(SymbolKind::Struct)
+                        HlTag::Symbol(SymbolKind::Struct)
                     } else {
-                        HighlightTag::Symbol(SymbolKind::Module)
+                        HlTag::Symbol(SymbolKind::Module)
                     }
                     .into();
                 }
@@ -746,11 +727,11 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics HighlightTag::Symbol(SymbolKind::Function).into(),
+                CALL_EXPR => HlTag::Symbol(SymbolKind::Function).into(),
                 _ => if name.text().chars().next().unwrap_or_default().is_uppercase() {
-                    HighlightTag::Symbol(SymbolKind::Struct)
+                    HlTag::Symbol(SymbolKind::Struct)
                 } else {
-                    HighlightTag::Symbol(SymbolKind::Const)
+                    HlTag::Symbol(SymbolKind::Const)
                 }
                 .into(),
             }
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs
index ab66b406c..94cecd97f 100644
--- a/crates/ide/src/syntax_highlighting/format.rs
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -4,7 +4,7 @@ use syntax::{
     AstNode, AstToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange,
 };
 
-use crate::{HighlightTag, HighlightedRange, SymbolKind};
+use crate::{HighlightedRange, HlTag, SymbolKind};
 
 use super::highlights::Highlights;
 
@@ -57,7 +57,7 @@ impl FormatStringHighlighter {
     }
 }
 
-fn highlight_format_specifier(kind: FormatSpecifier) -> Option {
+fn highlight_format_specifier(kind: FormatSpecifier) -> Option {
     Some(match kind {
         FormatSpecifier::Open
         | FormatSpecifier::Close
@@ -69,8 +69,8 @@ fn highlight_format_specifier(kind: FormatSpecifier) -> Option {
         | FormatSpecifier::DollarSign
         | FormatSpecifier::Dot
         | FormatSpecifier::Asterisk
-        | FormatSpecifier::QuestionMark => HighlightTag::FormatSpecifier,
-        FormatSpecifier::Integer | FormatSpecifier::Zero => HighlightTag::NumericLiteral,
-        FormatSpecifier::Identifier => HighlightTag::Symbol(SymbolKind::Local),
+        | FormatSpecifier::QuestionMark => HlTag::FormatSpecifier,
+        FormatSpecifier::Integer | FormatSpecifier::Zero => HlTag::NumericLiteral,
+        FormatSpecifier::Identifier => HlTag::Symbol(SymbolKind::Local),
     })
 }
diff --git a/crates/ide/src/syntax_highlighting/highlights.rs b/crates/ide/src/syntax_highlighting/highlights.rs
index 7ff1593ae..f52076509 100644
--- a/crates/ide/src/syntax_highlighting/highlights.rs
+++ b/crates/ide/src/syntax_highlighting/highlights.rs
@@ -4,7 +4,7 @@ use std::{cmp::Ordering, iter};
 use stdx::equal_range_by;
 use syntax::TextRange;
 
-use crate::{HighlightTag, HighlightedRange};
+use crate::{HighlightedRange, HlTag};
 
 pub(super) struct Highlights {
     root: Node,
@@ -20,7 +20,7 @@ impl Highlights {
         Highlights {
             root: Node::new(HighlightedRange {
                 range,
-                highlight: HighlightTag::None.into(),
+                highlight: HlTag::None.into(),
                 binding_hash: None,
             }),
         }
diff --git a/crates/ide/src/syntax_highlighting/injection.rs b/crates/ide/src/syntax_highlighting/injection.rs
index 98ee03e0d..a6941234e 100644
--- a/crates/ide/src/syntax_highlighting/injection.rs
+++ b/crates/ide/src/syntax_highlighting/injection.rs
@@ -7,7 +7,7 @@ use ide_db::call_info::ActiveParameter;
 use itertools::Itertools;
 use syntax::{ast, AstToken, SyntaxNode, SyntaxToken, TextRange, TextSize};
 
-use crate::{Analysis, HighlightModifier, HighlightTag, HighlightedRange, RootDatabase};
+use crate::{Analysis, HighlightedRange, HlMod, HlTag, RootDatabase};
 
 use super::{highlights::Highlights, injector::Injector};
 
@@ -28,7 +28,7 @@ pub(super) fn highlight_injection(
     if let Some(range) = literal.open_quote_text_range() {
         acc.add(HighlightedRange {
             range,
-            highlight: HighlightTag::StringLiteral.into(),
+            highlight: HlTag::StringLiteral.into(),
             binding_hash: None,
         })
     }
@@ -44,7 +44,7 @@ pub(super) fn highlight_injection(
     if let Some(range) = literal.close_quote_text_range() {
         acc.add(HighlightedRange {
             range,
-            highlight: HighlightTag::StringLiteral.into(),
+            highlight: HlTag::StringLiteral.into(),
             binding_hash: None,
         })
     }
@@ -171,7 +171,7 @@ pub(super) fn extract_doc_comments(node: &SyntaxNode) -> Option<(Vec &'static str {
         match self {
-            HighlightTag::Symbol(symbol) => match symbol {
+            HlTag::Symbol(symbol) => match symbol {
                 SymbolKind::Const => "constant",
                 SymbolKind::Static => "static",
                 SymbolKind::Enum => "enum",
@@ -86,59 +86,59 @@ impl HighlightTag {
                 SymbolKind::SelfParam => "self_keyword",
                 SymbolKind::Impl => "self_type",
             },
-            HighlightTag::Attribute => "attribute",
-            HighlightTag::BoolLiteral => "bool_literal",
-            HighlightTag::BuiltinType => "builtin_type",
-            HighlightTag::ByteLiteral => "byte_literal",
-            HighlightTag::CharLiteral => "char_literal",
-            HighlightTag::Comment => "comment",
-            HighlightTag::EscapeSequence => "escape_sequence",
-            HighlightTag::FormatSpecifier => "format_specifier",
-            HighlightTag::Keyword => "keyword",
-            HighlightTag::Punctuation => "punctuation",
-            HighlightTag::NumericLiteral => "numeric_literal",
-            HighlightTag::Operator => "operator",
-            HighlightTag::StringLiteral => "string_literal",
-            HighlightTag::UnresolvedReference => "unresolved_reference",
-            HighlightTag::None => "none",
+            HlTag::Attribute => "attribute",
+            HlTag::BoolLiteral => "bool_literal",
+            HlTag::BuiltinType => "builtin_type",
+            HlTag::ByteLiteral => "byte_literal",
+            HlTag::CharLiteral => "char_literal",
+            HlTag::Comment => "comment",
+            HlTag::EscapeSequence => "escape_sequence",
+            HlTag::FormatSpecifier => "format_specifier",
+            HlTag::Keyword => "keyword",
+            HlTag::Punctuation => "punctuation",
+            HlTag::NumericLiteral => "numeric_literal",
+            HlTag::Operator => "operator",
+            HlTag::StringLiteral => "string_literal",
+            HlTag::UnresolvedReference => "unresolved_reference",
+            HlTag::None => "none",
         }
     }
 }
 
-impl fmt::Display for HighlightTag {
+impl fmt::Display for HlTag {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(self.as_str(), f)
     }
 }
 
-impl HighlightModifier {
-    const ALL: &'static [HighlightModifier; HighlightModifier::Unsafe as u8 as usize + 1] = &[
-        HighlightModifier::Attribute,
-        HighlightModifier::ControlFlow,
-        HighlightModifier::Definition,
-        HighlightModifier::Documentation,
-        HighlightModifier::Injected,
-        HighlightModifier::Mutable,
-        HighlightModifier::Consuming,
-        HighlightModifier::Callable,
-        HighlightModifier::Static,
-        HighlightModifier::Associated,
-        HighlightModifier::Unsafe,
+impl HlMod {
+    const ALL: &'static [HlMod; HlMod::Unsafe as u8 as usize + 1] = &[
+        HlMod::Attribute,
+        HlMod::ControlFlow,
+        HlMod::Definition,
+        HlMod::Documentation,
+        HlMod::Injected,
+        HlMod::Mutable,
+        HlMod::Consuming,
+        HlMod::Callable,
+        HlMod::Static,
+        HlMod::Associated,
+        HlMod::Unsafe,
     ];
 
     fn as_str(self) -> &'static str {
         match self {
-            HighlightModifier::Attribute => "attribute",
-            HighlightModifier::ControlFlow => "control",
-            HighlightModifier::Definition => "declaration",
-            HighlightModifier::Documentation => "documentation",
-            HighlightModifier::Injected => "injected",
-            HighlightModifier::Mutable => "mutable",
-            HighlightModifier::Consuming => "consuming",
-            HighlightModifier::Unsafe => "unsafe",
-            HighlightModifier::Callable => "callable",
-            HighlightModifier::Static => "static",
-            HighlightModifier::Associated => "associated",
+            HlMod::Attribute => "attribute",
+            HlMod::ControlFlow => "control",
+            HlMod::Definition => "declaration",
+            HlMod::Documentation => "documentation",
+            HlMod::Injected => "injected",
+            HlMod::Mutable => "mutable",
+            HlMod::Consuming => "consuming",
+            HlMod::Unsafe => "unsafe",
+            HlMod::Callable => "callable",
+            HlMod::Static => "static",
+            HlMod::Associated => "associated",
         }
     }
 
@@ -147,7 +147,7 @@ impl HighlightModifier {
     }
 }
 
-impl fmt::Display for HighlightModifier {
+impl fmt::Display for HlMod {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(self.as_str(), f)
     }
@@ -156,63 +156,63 @@ impl fmt::Display for HighlightModifier {
 impl fmt::Display for Highlight {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.tag)?;
-        for modifier in self.modifiers.iter() {
+        for modifier in self.mods.iter() {
             write!(f, ".{}", modifier)?
         }
         Ok(())
     }
 }
 
-impl From for Highlight {
-    fn from(tag: HighlightTag) -> Highlight {
+impl From for Highlight {
+    fn from(tag: HlTag) -> Highlight {
         Highlight::new(tag)
     }
 }
 
 impl Highlight {
-    pub(crate) fn new(tag: HighlightTag) -> Highlight {
-        Highlight { tag, modifiers: HighlightModifiers::default() }
+    pub(crate) fn new(tag: HlTag) -> Highlight {
+        Highlight { tag, mods: HlMods::default() }
     }
     pub fn is_empty(&self) -> bool {
-        self.tag == HighlightTag::None && self.modifiers == HighlightModifiers::default()
+        self.tag == HlTag::None && self.mods == HlMods::default()
     }
 }
 
-impl ops::BitOr for HighlightTag {
+impl ops::BitOr for HlTag {
     type Output = Highlight;
 
-    fn bitor(self, rhs: HighlightModifier) -> Highlight {
+    fn bitor(self, rhs: HlMod) -> Highlight {
         Highlight::new(self) | rhs
     }
 }
 
-impl ops::BitOrAssign for HighlightModifiers {
-    fn bitor_assign(&mut self, rhs: HighlightModifier) {
+impl ops::BitOrAssign for HlMods {
+    fn bitor_assign(&mut self, rhs: HlMod) {
         self.0 |= rhs.mask();
     }
 }
 
-impl ops::BitOrAssign for Highlight {
-    fn bitor_assign(&mut self, rhs: HighlightModifier) {
-        self.modifiers |= rhs;
+impl ops::BitOrAssign for Highlight {
+    fn bitor_assign(&mut self, rhs: HlMod) {
+        self.mods |= rhs;
     }
 }
 
-impl ops::BitOr for Highlight {
+impl ops::BitOr for Highlight {
     type Output = Highlight;
 
-    fn bitor(mut self, rhs: HighlightModifier) -> Highlight {
+    fn bitor(mut self, rhs: HlMod) -> Highlight {
         self |= rhs;
         self
     }
 }
 
-impl HighlightModifiers {
-    pub fn contains(self, m: HighlightModifier) -> bool {
+impl HlMods {
+    pub fn contains(self, m: HlMod) -> bool {
         self.0 & m.mask() == m.mask()
     }
 
-    pub fn iter(self) -> impl Iterator {
-        HighlightModifier::ALL.iter().copied().filter(move |it| self.0 & it.mask() == it.mask())
+    pub fn iter(self) -> impl Iterator {
+        HlMod::ALL.iter().copied().filter(move |it| self.0 & it.mask() == it.mask())
     }
 }
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 4cfe6ff51..0c31a9fed 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -6,10 +6,9 @@ use std::{
 
 use ide::{
     Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind, Documentation, FileId,
-    FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HighlightModifier, HighlightTag,
-    HighlightedRange, Indel, InlayHint, InlayKind, InsertTextFormat, LineIndex, Markup,
-    NavigationTarget, ReferenceAccess, Runnable, Severity, SourceChange, SourceFileEdit,
-    SymbolKind, TextEdit, TextRange, TextSize,
+    FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HighlightedRange, HlMod, HlTag, Indel,
+    InlayHint, InlayKind, InsertTextFormat, LineIndex, Markup, NavigationTarget, ReferenceAccess,
+    Runnable, Severity, SourceChange, SourceFileEdit, SymbolKind, TextEdit, TextRange, TextSize,
 };
 use itertools::Itertools;
 
@@ -377,7 +376,7 @@ fn semantic_token_type_and_modifiers(
 ) -> (lsp_types::SemanticTokenType, semantic_tokens::ModifierSet) {
     let mut mods = semantic_tokens::ModifierSet::default();
     let type_ = match highlight.tag {
-        HighlightTag::Symbol(symbol) => match symbol {
+        HlTag::Symbol(symbol) => match symbol {
             SymbolKind::Module => lsp_types::SemanticTokenType::NAMESPACE,
             SymbolKind::Impl => lsp_types::SemanticTokenType::TYPE,
             SymbolKind::Field => lsp_types::SemanticTokenType::PROPERTY,
@@ -389,7 +388,7 @@ fn semantic_token_type_and_modifiers(
             SymbolKind::SelfParam => semantic_tokens::SELF_KEYWORD,
             SymbolKind::Local => lsp_types::SemanticTokenType::VARIABLE,
             SymbolKind::Function => {
-                if highlight.modifiers.contains(HighlightModifier::Associated) {
+                if highlight.mods.contains(HlMod::Associated) {
                     lsp_types::SemanticTokenType::METHOD
                 } else {
                     lsp_types::SemanticTokenType::FUNCTION
@@ -412,38 +411,34 @@ fn semantic_token_type_and_modifiers(
             SymbolKind::Trait => lsp_types::SemanticTokenType::INTERFACE,
             SymbolKind::Macro => lsp_types::SemanticTokenType::MACRO,
         },
-        HighlightTag::BuiltinType => semantic_tokens::BUILTIN_TYPE,
-        HighlightTag::None => semantic_tokens::GENERIC,
-        HighlightTag::ByteLiteral | HighlightTag::NumericLiteral => {
-            lsp_types::SemanticTokenType::NUMBER
-        }
-        HighlightTag::BoolLiteral => semantic_tokens::BOOLEAN,
-        HighlightTag::CharLiteral | HighlightTag::StringLiteral => {
-            lsp_types::SemanticTokenType::STRING
-        }
-        HighlightTag::Comment => lsp_types::SemanticTokenType::COMMENT,
-        HighlightTag::Attribute => semantic_tokens::ATTRIBUTE,
-        HighlightTag::Keyword => lsp_types::SemanticTokenType::KEYWORD,
-        HighlightTag::UnresolvedReference => semantic_tokens::UNRESOLVED_REFERENCE,
-        HighlightTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
-        HighlightTag::Operator => lsp_types::SemanticTokenType::OPERATOR,
-        HighlightTag::EscapeSequence => semantic_tokens::ESCAPE_SEQUENCE,
-        HighlightTag::Punctuation => semantic_tokens::PUNCTUATION,
+        HlTag::BuiltinType => semantic_tokens::BUILTIN_TYPE,
+        HlTag::None => semantic_tokens::GENERIC,
+        HlTag::ByteLiteral | HlTag::NumericLiteral => lsp_types::SemanticTokenType::NUMBER,
+        HlTag::BoolLiteral => semantic_tokens::BOOLEAN,
+        HlTag::CharLiteral | HlTag::StringLiteral => lsp_types::SemanticTokenType::STRING,
+        HlTag::Comment => lsp_types::SemanticTokenType::COMMENT,
+        HlTag::Attribute => semantic_tokens::ATTRIBUTE,
+        HlTag::Keyword => lsp_types::SemanticTokenType::KEYWORD,
+        HlTag::UnresolvedReference => semantic_tokens::UNRESOLVED_REFERENCE,
+        HlTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
+        HlTag::Operator => lsp_types::SemanticTokenType::OPERATOR,
+        HlTag::EscapeSequence => semantic_tokens::ESCAPE_SEQUENCE,
+        HlTag::Punctuation => semantic_tokens::PUNCTUATION,
     };
 
-    for modifier in highlight.modifiers.iter() {
+    for modifier in highlight.mods.iter() {
         let modifier = match modifier {
-            HighlightModifier::Attribute => semantic_tokens::ATTRIBUTE_MODIFIER,
-            HighlightModifier::Definition => lsp_types::SemanticTokenModifier::DECLARATION,
-            HighlightModifier::Documentation => lsp_types::SemanticTokenModifier::DOCUMENTATION,
-            HighlightModifier::Injected => semantic_tokens::INJECTED,
-            HighlightModifier::ControlFlow => semantic_tokens::CONTROL_FLOW,
-            HighlightModifier::Mutable => semantic_tokens::MUTABLE,
-            HighlightModifier::Consuming => semantic_tokens::CONSUMING,
-            HighlightModifier::Unsafe => semantic_tokens::UNSAFE,
-            HighlightModifier::Callable => semantic_tokens::CALLABLE,
-            HighlightModifier::Static => lsp_types::SemanticTokenModifier::STATIC,
-            HighlightModifier::Associated => continue,
+            HlMod::Attribute => semantic_tokens::ATTRIBUTE_MODIFIER,
+            HlMod::Definition => lsp_types::SemanticTokenModifier::DECLARATION,
+            HlMod::Documentation => lsp_types::SemanticTokenModifier::DOCUMENTATION,
+            HlMod::Injected => semantic_tokens::INJECTED,
+            HlMod::ControlFlow => semantic_tokens::CONTROL_FLOW,
+            HlMod::Mutable => semantic_tokens::MUTABLE,
+            HlMod::Consuming => semantic_tokens::CONSUMING,
+            HlMod::Unsafe => semantic_tokens::UNSAFE,
+            HlMod::Callable => semantic_tokens::CALLABLE,
+            HlMod::Static => lsp_types::SemanticTokenModifier::STATIC,
+            HlMod::Associated => continue,
         };
         mods |= modifier;
     }
-- 
cgit v1.2.3


From c6150a370616ebb918620623bae24855a6d8cb65 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov 
Date: Sat, 9 Jan 2021 14:45:47 +0300
Subject: Reorder modules

---
 crates/ide/src/syntax_highlighting.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index d73ddf35b..086c1245e 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -1,11 +1,13 @@
+pub(crate) mod tags;
+
 mod highlights;
 mod injector;
 
 mod format;
-mod html;
 mod injection;
 mod macro_rules;
-pub(crate) mod tags;
+
+mod html;
 #[cfg(test)]
 mod tests;
 
-- 
cgit v1.2.3


From 3dfa2768acdd6bbf0e6999cdc4eb5cf0718b95a4 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov 
Date: Sat, 9 Jan 2021 14:48:15 +0300
Subject: Shorten names

---
 crates/ide/src/lib.rs                             |  6 +--
 crates/ide/src/syntax_highlighting.rs             | 10 ++--
 crates/ide/src/syntax_highlighting/format.rs      |  4 +-
 crates/ide/src/syntax_highlighting/highlights.rs  | 61 ++++++++++-------------
 crates/ide/src/syntax_highlighting/injection.rs   | 22 +++-----
 crates/ide/src/syntax_highlighting/macro_rules.rs |  6 +--
 crates/rust-analyzer/src/to_proto.rs              |  8 +--
 7 files changed, 50 insertions(+), 67 deletions(-)

diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 674c72c23..409507bd0 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -77,7 +77,7 @@ pub use crate::{
     runnables::{Runnable, RunnableKind, TestId},
     syntax_highlighting::{
         tags::{Highlight, HlMod, HlMods, HlTag},
-        HighlightedRange,
+        HlRange,
     },
 };
 pub use assists::{Assist, AssistConfig, AssistId, AssistKind, InsertUseConfig};
@@ -449,12 +449,12 @@ impl Analysis {
     }
 
     /// Computes syntax highlighting for the given file
-    pub fn highlight(&self, file_id: FileId) -> Cancelable> {
+    pub fn highlight(&self, file_id: FileId) -> Cancelable> {
         self.with_db(|db| syntax_highlighting::highlight(db, file_id, None, false))
     }
 
     /// Computes syntax highlighting for the given file range.
-    pub fn highlight_range(&self, frange: FileRange) -> Cancelable> {
+    pub fn highlight_range(&self, frange: FileRange) -> Cancelable> {
         self.with_db(|db| {
             syntax_highlighting::highlight(db, frange.file_id, Some(frange.range), false)
         })
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 086c1245e..8bb7acb82 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -34,7 +34,7 @@ use crate::{
 pub(crate) use html::highlight_as_html;
 
 #[derive(Debug, Clone)]
-pub struct HighlightedRange {
+pub struct HlRange {
     pub range: TextRange,
     pub highlight: Highlight,
     pub binding_hash: Option,
@@ -54,7 +54,7 @@ pub(crate) fn highlight(
     file_id: FileId,
     range_to_highlight: Option,
     syntactic_name_ref_highlighting: bool,
-) -> Vec {
+) -> Vec {
     let _p = profile::span("highlight");
     let sema = Semantics::new(db);
 
@@ -98,7 +98,7 @@ pub(crate) fn highlight(
         match event.clone().map(|it| it.into_node().and_then(ast::MacroCall::cast)) {
             WalkEvent::Enter(Some(mc)) => {
                 if let Some(range) = macro_call_range(&mc) {
-                    stack.add(HighlightedRange {
+                    stack.add(HlRange {
                         range,
                         highlight: HlTag::Symbol(SymbolKind::Macro).into(),
                         binding_hash: None,
@@ -198,7 +198,7 @@ pub(crate) fn highlight(
             }
 
             if macro_rules_highlighter.highlight(element_to_highlight.clone()).is_none() {
-                stack.add(HighlightedRange { range, highlight, binding_hash });
+                stack.add(HlRange { range, highlight, binding_hash });
             }
 
             if let Some(string) =
@@ -209,7 +209,7 @@ pub(crate) fn highlight(
                 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('\\') {
-                            stack.add(HighlightedRange {
+                            stack.add(HlRange {
                                 range: piece_range + range.start(),
                                 highlight: HlTag::EscapeSequence.into(),
                                 binding_hash: None,
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs
index 94cecd97f..d807ad0ad 100644
--- a/crates/ide/src/syntax_highlighting/format.rs
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -4,7 +4,7 @@ use syntax::{
     AstNode, AstToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange,
 };
 
-use crate::{HighlightedRange, HlTag, SymbolKind};
+use crate::{HlRange, HlTag, SymbolKind};
 
 use super::highlights::Highlights;
 
@@ -46,7 +46,7 @@ impl FormatStringHighlighter {
         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(HighlightedRange {
+                    stack.add(HlRange {
                         range: piece_range + range.start(),
                         highlight: highlight.into(),
                         binding_hash: None,
diff --git a/crates/ide/src/syntax_highlighting/highlights.rs b/crates/ide/src/syntax_highlighting/highlights.rs
index f52076509..11c11ed28 100644
--- a/crates/ide/src/syntax_highlighting/highlights.rs
+++ b/crates/ide/src/syntax_highlighting/highlights.rs
@@ -4,33 +4,29 @@ use std::{cmp::Ordering, iter};
 use stdx::equal_range_by;
 use syntax::TextRange;
 
-use crate::{HighlightedRange, HlTag};
+use crate::{HlRange, HlTag};
 
 pub(super) struct Highlights {
     root: Node,
 }
 
 struct Node {
-    highlighted_range: HighlightedRange,
+    hl_range: HlRange,
     nested: Vec,
 }
 
 impl Highlights {
     pub(super) fn new(range: TextRange) -> Highlights {
         Highlights {
-            root: Node::new(HighlightedRange {
-                range,
-                highlight: HlTag::None.into(),
-                binding_hash: None,
-            }),
+            root: Node::new(HlRange { range, highlight: HlTag::None.into(), binding_hash: None }),
         }
     }
 
-    pub(super) fn add(&mut self, highlighted_range: HighlightedRange) {
-        self.root.add(highlighted_range);
+    pub(super) fn add(&mut self, hl_range: HlRange) {
+        self.root.add(hl_range);
     }
 
-    pub(super) fn to_vec(self) -> Vec {
+    pub(super) fn to_vec(self) -> Vec {
         let mut res = Vec::new();
         self.root.flatten(&mut res);
         res
@@ -38,59 +34,54 @@ impl Highlights {
 }
 
 impl Node {
-    fn new(highlighted_range: HighlightedRange) -> Node {
-        Node { highlighted_range, nested: Vec::new() }
+    fn new(hl_range: HlRange) -> Node {
+        Node { hl_range, nested: Vec::new() }
     }
 
-    fn add(&mut self, highlighted_range: HighlightedRange) {
-        assert!(self.highlighted_range.range.contains_range(highlighted_range.range));
+    fn add(&mut self, hl_range: HlRange) {
+        assert!(self.hl_range.range.contains_range(hl_range.range));
 
         // Fast path
         if let Some(last) = self.nested.last_mut() {
-            if last.highlighted_range.range.contains_range(highlighted_range.range) {
-                return last.add(highlighted_range);
+            if last.hl_range.range.contains_range(hl_range.range) {
+                return last.add(hl_range);
             }
-            if last.highlighted_range.range.end() <= highlighted_range.range.start() {
-                return self.nested.push(Node::new(highlighted_range));
+            if last.hl_range.range.end() <= hl_range.range.start() {
+                return self.nested.push(Node::new(hl_range));
             }
         }
 
-        let (start, len) = equal_range_by(&self.nested, |n| {
-            ordering(n.highlighted_range.range, highlighted_range.range)
-        });
+        let (start, len) =
+            equal_range_by(&self.nested, |n| ordering(n.hl_range.range, hl_range.range));
 
-        if len == 1
-            && self.nested[start].highlighted_range.range.contains_range(highlighted_range.range)
-        {
-            return self.nested[start].add(highlighted_range);
+        if len == 1 && self.nested[start].hl_range.range.contains_range(hl_range.range) {
+            return self.nested[start].add(hl_range);
         }
 
         let nested = self
             .nested
-            .splice(start..start + len, iter::once(Node::new(highlighted_range)))
+            .splice(start..start + len, iter::once(Node::new(hl_range)))
             .collect::>();
         self.nested[start].nested = nested;
     }
 
-    fn flatten(&self, acc: &mut Vec) {
-        let mut start = self.highlighted_range.range.start();
+    fn flatten(&self, acc: &mut Vec) {
+        let mut start = self.hl_range.range.start();
         let mut nested = self.nested.iter();
         loop {
             let next = nested.next();
-            let end = next.map_or(self.highlighted_range.range.end(), |it| {
-                it.highlighted_range.range.start()
-            });
+            let end = next.map_or(self.hl_range.range.end(), |it| it.hl_range.range.start());
             if start < end {
-                acc.push(HighlightedRange {
+                acc.push(HlRange {
                     range: TextRange::new(start, end),
-                    highlight: self.highlighted_range.highlight,
-                    binding_hash: self.highlighted_range.binding_hash,
+                    highlight: self.hl_range.highlight,
+                    binding_hash: self.hl_range.binding_hash,
                 });
             }
             start = match next {
                 Some(child) => {
                     child.flatten(acc);
-                    child.highlighted_range.range.end()
+                    child.hl_range.range.end()
                 }
                 None => break,
             }
diff --git a/crates/ide/src/syntax_highlighting/injection.rs b/crates/ide/src/syntax_highlighting/injection.rs
index a6941234e..13dde1dc4 100644
--- a/crates/ide/src/syntax_highlighting/injection.rs
+++ b/crates/ide/src/syntax_highlighting/injection.rs
@@ -7,7 +7,7 @@ use ide_db::call_info::ActiveParameter;
 use itertools::Itertools;
 use syntax::{ast, AstToken, SyntaxNode, SyntaxToken, TextRange, TextSize};
 
-use crate::{Analysis, HighlightedRange, HlMod, HlTag, RootDatabase};
+use crate::{Analysis, HlMod, HlRange, HlTag, RootDatabase};
 
 use super::{highlights::Highlights, injector::Injector};
 
@@ -26,11 +26,7 @@ pub(super) fn highlight_injection(
     let (analysis, tmp_file_id) = Analysis::from_single_file(marker_info.cleaned_text.clone());
 
     if let Some(range) = literal.open_quote_text_range() {
-        acc.add(HighlightedRange {
-            range,
-            highlight: HlTag::StringLiteral.into(),
-            binding_hash: None,
-        })
+        acc.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
     }
 
     for mut h in analysis.highlight(tmp_file_id).unwrap() {
@@ -42,11 +38,7 @@ pub(super) fn highlight_injection(
     }
 
     if let Some(range) = literal.close_quote_text_range() {
-        acc.add(HighlightedRange {
-            range,
-            highlight: HlTag::StringLiteral.into(),
-            binding_hash: None,
-        })
+        acc.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
     }
 
     Some(())
@@ -116,7 +108,7 @@ const RUSTDOC_FENCE_TOKENS: &[&'static str] = &[
 /// 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, Injector)> {
+pub(super) fn extract_doc_comments(node: &SyntaxNode) -> Option<(Vec, Injector)> {
     let mut inj = Injector::default();
     // wrap the doctest into function body to get correct syntax highlighting
     let prefix = "fn doctest() {\n";
@@ -166,7 +158,7 @@ pub(super) fn extract_doc_comments(node: &SyntaxNode) -> Option<(Vec Option<(Vec,
+    new_comments: Vec,
     inj: Injector,
     stack: &mut Highlights,
 ) {
@@ -207,7 +199,7 @@ pub(super) fn highlight_doc_comment(
 
     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(HighlightedRange {
+            stack.add(HlRange {
                 range: r,
                 highlight: h.highlight | HlMod::Injected,
                 binding_hash: h.binding_hash,
diff --git a/crates/ide/src/syntax_highlighting/macro_rules.rs b/crates/ide/src/syntax_highlighting/macro_rules.rs
index 71dd1ccc5..21d8a9835 100644
--- a/crates/ide/src/syntax_highlighting/macro_rules.rs
+++ b/crates/ide/src/syntax_highlighting/macro_rules.rs
@@ -1,7 +1,7 @@
 //! Syntax highlighting for macro_rules!.
 use syntax::{SyntaxElement, SyntaxKind, SyntaxToken, TextRange, T};
 
-use crate::{HighlightedRange, HlTag};
+use crate::{HlRange, HlTag};
 
 #[derive(Default)]
 pub(super) struct MacroRulesHighlighter {
@@ -19,11 +19,11 @@ impl MacroRulesHighlighter {
         }
     }
 
-    pub(super) fn highlight(&self, element: SyntaxElement) -> Option {
+    pub(super) fn highlight(&self, element: SyntaxElement) -> Option {
         if let Some(state) = self.state.as_ref() {
             if matches!(state.rule_state, RuleState::Matcher | RuleState::Expander) {
                 if let Some(range) = is_metavariable(element) {
-                    return Some(HighlightedRange {
+                    return Some(HlRange {
                         range,
                         highlight: HlTag::UnresolvedReference.into(),
                         binding_hash: None,
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 0c31a9fed..d6bf60cde 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -6,9 +6,9 @@ use std::{
 
 use ide::{
     Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind, Documentation, FileId,
-    FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HighlightedRange, HlMod, HlTag, Indel,
-    InlayHint, InlayKind, InsertTextFormat, LineIndex, Markup, NavigationTarget, ReferenceAccess,
-    Runnable, Severity, SourceChange, SourceFileEdit, SymbolKind, TextEdit, TextRange, TextSize,
+    FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HlMod, HlRange, HlTag, Indel, InlayHint,
+    InlayKind, InsertTextFormat, LineIndex, Markup, NavigationTarget, ReferenceAccess, Runnable,
+    Severity, SourceChange, SourceFileEdit, SymbolKind, TextEdit, TextRange, TextSize,
 };
 use itertools::Itertools;
 
@@ -336,7 +336,7 @@ static TOKEN_RESULT_COUNTER: AtomicU32 = AtomicU32::new(1);
 pub(crate) fn semantic_tokens(
     text: &str,
     line_index: &LineIndex,
-    highlights: Vec,
+    highlights: Vec,
 ) -> lsp_types::SemanticTokens {
     let id = TOKEN_RESULT_COUNTER.fetch_add(1, Ordering::SeqCst).to_string();
     let mut builder = semantic_tokens::SemanticTokensBuilder::new(id);
-- 
cgit v1.2.3


From 8a0bd500363fd2953c2a469083b00be54c602ebb Mon Sep 17 00:00:00 2001
From: Aleksey Kladov 
Date: Sat, 9 Jan 2021 15:12:21 +0300
Subject: Reduce duplication

---
 crates/ide/src/syntax_highlighting/injector.rs | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/crates/ide/src/syntax_highlighting/injector.rs b/crates/ide/src/syntax_highlighting/injector.rs
index 0513a9fd6..e8f17eb69 100644
--- a/crates/ide/src/syntax_highlighting/injector.rs
+++ b/crates/ide/src/syntax_highlighting/injector.rs
@@ -17,17 +17,15 @@ impl Injector {
     pub(super) fn add(&mut self, text: &str, source_range: TextRange) {
         let len = TextSize::of(text);
         assert_eq!(len, source_range.len());
-
-        let target_range = TextRange::at(TextSize::of(&self.buf), len);
-        self.ranges
-            .push((target_range, Some(Delta::new(target_range.start(), source_range.start()))));
-        self.buf.push_str(text);
+        self.add_impl(text, Some(source_range.start()));
     }
     pub(super) fn add_unmapped(&mut self, text: &str) {
+        self.add_impl(text, None);
+    }
+    fn add_impl(&mut self, text: &str, source: Option) {
         let len = TextSize::of(text);
-
         let target_range = TextRange::at(TextSize::of(&self.buf), len);
-        self.ranges.push((target_range, None));
+        self.ranges.push((target_range, source.map(|it| Delta::new(target_range.start(), it))));
         self.buf.push_str(text);
     }
 
-- 
cgit v1.2.3


From d4fb7476efc8bf956c56ba2b0e946f48f38a6efc Mon Sep 17 00:00:00 2001
From: Aleksey Kladov 
Date: Sat, 9 Jan 2021 15:18:49 +0300
Subject: Better names

---
 crates/ide/src/syntax_highlighting.rs           | 16 ++++++++--------
 crates/ide/src/syntax_highlighting/html.rs      | 16 ++++++++--------
 crates/ide/src/syntax_highlighting/injection.rs | 15 ++++++++-------
 3 files changed, 24 insertions(+), 23 deletions(-)

diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 8bb7acb82..3ba91b3f5 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -74,7 +74,7 @@ pub(crate) fn highlight(
     };
 
     let mut bindings_shadow_count: FxHashMap = FxHashMap::default();
-    let mut stack = highlights::Highlights::new(range_to_highlight);
+    let mut hl = highlights::Highlights::new(range_to_highlight);
 
     let mut current_macro_call: Option = None;
     let mut current_macro_rules: Option = None;
@@ -98,7 +98,7 @@ pub(crate) fn highlight(
         match event.clone().map(|it| it.into_node().and_then(ast::MacroCall::cast)) {
             WalkEvent::Enter(Some(mc)) => {
                 if let Some(range) = macro_call_range(&mc) {
-                    stack.add(HlRange {
+                    hl.add(HlRange {
                         range,
                         highlight: HlTag::Symbol(SymbolKind::Macro).into(),
                         binding_hash: None,
@@ -136,7 +136,7 @@ pub(crate) fn highlight(
                     inside_attribute = false
                 }
                 if let Some((new_comments, inj)) = injection::extract_doc_comments(node) {
-                    injection::highlight_doc_comment(new_comments, inj, &mut stack);
+                    injection::highlight_doc_comment(new_comments, inj, &mut hl);
                 }
             }
             WalkEvent::Enter(NodeOrToken::Node(node)) if ast::Attr::can_cast(node.kind()) => {
@@ -181,7 +181,7 @@ pub(crate) fn highlight(
         if let Some(token) = element.as_token().cloned().and_then(ast::String::cast) {
             if token.is_raw() {
                 let expanded = element_to_highlight.as_token().unwrap().clone();
-                if injection::highlight_injection(&mut stack, &sema, token, expanded).is_some() {
+                if injection::highlight_injection(&mut hl, &sema, token, expanded).is_some() {
                     continue;
                 }
             }
@@ -198,18 +198,18 @@ pub(crate) fn highlight(
             }
 
             if macro_rules_highlighter.highlight(element_to_highlight.clone()).is_none() {
-                stack.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 stack, &string, range);
+                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('\\') {
-                            stack.add(HlRange {
+                            hl.add(HlRange {
                                 range: piece_range + range.start(),
                                 highlight: HlTag::EscapeSequence.into(),
                                 binding_hash: None,
@@ -221,7 +221,7 @@ pub(crate) fn highlight(
         }
     }
 
-    stack.to_vec()
+    hl.to_vec()
 }
 
 fn macro_call_range(macro_call: &ast::MacroCall) -> Option {
diff --git a/crates/ide/src/syntax_highlighting/html.rs b/crates/ide/src/syntax_highlighting/html.rs
index 44f611b25..0ee7bc96e 100644
--- a/crates/ide/src/syntax_highlighting/html.rs
+++ b/crates/ide/src/syntax_highlighting/html.rs
@@ -20,26 +20,26 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: boo
         )
     }
 
-    let ranges = highlight(db, file_id, None, false);
+    let hl_ranges = highlight(db, file_id, None, false);
     let text = parse.tree().syntax().to_string();
     let mut buf = String::new();
     buf.push_str(&STYLE);
     buf.push_str("
");
-    for range in &ranges {
-        let curr = &text[range.range];
-        if range.highlight.is_empty() {
-            format_to!(buf, "{}", html_escape(curr));
+    for r in &hl_ranges {
+        let chunk = html_escape(&text[r.range]);
+        if r.highlight.is_empty() {
+            format_to!(buf, "{}", chunk);
             continue;
         }
 
-        let class = range.highlight.to_string().replace('.', " ");
-        let color = match (rainbow, range.binding_hash) {
+        let class = r.highlight.to_string().replace('.', " ");
+        let color = match (rainbow, r.binding_hash) {
             (true, Some(hash)) => {
                 format!(" data-binding-hash=\"{}\" style=\"color: {};\"", hash, rainbowify(hash))
             }
             _ => "".into(),
         };
-        format_to!(buf, "{}", class, color, html_escape(curr));
+        format_to!(buf, "{}", class, color, chunk);
     }
     buf.push_str("
");
     buf
diff --git a/crates/ide/src/syntax_highlighting/injection.rs b/crates/ide/src/syntax_highlighting/injection.rs
index 13dde1dc4..22d7f601a 100644
--- a/crates/ide/src/syntax_highlighting/injection.rs
+++ b/crates/ide/src/syntax_highlighting/injection.rs
@@ -12,7 +12,7 @@ use crate::{Analysis, HlMod, HlRange, HlTag, RootDatabase};
 use super::{highlights::Highlights, injector::Injector};
 
 pub(super) fn highlight_injection(
-    acc: &mut Highlights,
+    hl: &mut Highlights,
     sema: &Semantics,
     literal: ast::String,
     expanded: SyntaxToken,
@@ -21,24 +21,25 @@ pub(super) fn highlight_injection(
     if !active_parameter.name.starts_with("ra_fixture") {
         return None;
     }
+
     let value = literal.value()?;
     let marker_info = MarkerInfo::new(&*value);
     let (analysis, tmp_file_id) = Analysis::from_single_file(marker_info.cleaned_text.clone());
 
     if let Some(range) = literal.open_quote_text_range() {
-        acc.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
+        hl.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
     }
 
-    for mut h in analysis.highlight(tmp_file_id).unwrap() {
-        let range = marker_info.map_range_up(h.range);
+    for mut hl_range in analysis.highlight(tmp_file_id).unwrap() {
+        let range = marker_info.map_range_up(hl_range.range);
         if let Some(range) = literal.map_range_up(range) {
-            h.range = range;
-            acc.add(h);
+            hl_range.range = range;
+            hl.add(hl_range);
         }
     }
 
     if let Some(range) = literal.close_quote_text_range() {
-        acc.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
+        hl.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
     }
 
     Some(())
-- 
cgit v1.2.3


From 62b17bac92595d384aaeb0a0fdc5c03269a0dbac Mon Sep 17 00:00:00 2001
From: Aleksey Kladov 
Date: Sat, 9 Jan 2021 15:54:38 +0300
Subject: Simplify

---
 crates/ide/src/syntax_highlighting.rs           |  2 +-
 crates/ide/src/syntax_highlighting/injection.rs | 78 +++++++++----------------
 2 files changed, 28 insertions(+), 52 deletions(-)

diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index 3ba91b3f5..ad456bc00 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -33,7 +33,7 @@ use crate::{
 
 pub(crate) use html::highlight_as_html;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub struct HlRange {
     pub range: TextRange,
     pub highlight: Highlight,
diff --git a/crates/ide/src/syntax_highlighting/injection.rs b/crates/ide/src/syntax_highlighting/injection.rs
index 22d7f601a..de2180b04 100644
--- a/crates/ide/src/syntax_highlighting/injection.rs
+++ b/crates/ide/src/syntax_highlighting/injection.rs
@@ -21,74 +21,50 @@ pub(super) fn highlight_injection(
     if !active_parameter.name.starts_with("ra_fixture") {
         return None;
     }
-
     let value = literal.value()?;
-    let marker_info = MarkerInfo::new(&*value);
-    let (analysis, tmp_file_id) = Analysis::from_single_file(marker_info.cleaned_text.clone());
 
     if let Some(range) = literal.open_quote_text_range() {
         hl.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
     }
 
-    for mut hl_range in analysis.highlight(tmp_file_id).unwrap() {
-        let range = marker_info.map_range_up(hl_range.range);
-        if let Some(range) = literal.map_range_up(range) {
-            hl_range.range = range;
-            hl.add(hl_range);
-        }
-    }
-
-    if let Some(range) = literal.close_quote_text_range() {
-        hl.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
-    }
-
-    Some(())
-}
+    let mut inj = Injector::default();
 
-/// Data to remove `$0` from string and map ranges
-#[derive(Default, Debug)]
-struct MarkerInfo {
-    cleaned_text: String,
-    markers: Vec,
-}
+    let mut text = &*value;
+    let mut offset: TextSize = 0.into();
 
-impl MarkerInfo {
-    fn new(mut text: &str) -> Self {
+    while !text.is_empty() {
         let marker = "$0";
+        let idx = text.find(marker).unwrap_or(text.len());
+        let (chunk, next) = text.split_at(idx);
+        inj.add(chunk, TextRange::at(offset, TextSize::of(chunk)));
 
-        let mut res = MarkerInfo::default();
-        let mut offset: TextSize = 0.into();
-        while !text.is_empty() {
-            let idx = text.find(marker).unwrap_or(text.len());
-            let (chunk, next) = text.split_at(idx);
-            text = next;
-            res.cleaned_text.push_str(chunk);
-            offset += TextSize::of(chunk);
+        text = next;
+        offset += TextSize::of(chunk);
 
-            if let Some(next) = text.strip_prefix(marker) {
-                text = next;
+        if let Some(next) = text.strip_prefix(marker) {
+            text = next;
 
-                let marker_len = TextSize::of(marker);
-                res.markers.push(TextRange::at(offset, marker_len));
-                offset += marker_len;
-            }
+            let marker_len = TextSize::of(marker);
+            offset += marker_len;
         }
-        res
     }
-    fn map_range_up(&self, range: TextRange) -> TextRange {
-        TextRange::new(
-            self.map_offset_up(range.start(), true),
-            self.map_offset_up(range.end(), false),
-        )
-    }
-    fn map_offset_up(&self, mut offset: TextSize, start: bool) -> TextSize {
-        for r in &self.markers {
-            if r.start() < offset || (start && r.start() == offset) {
-                offset += r.len()
+
+    let (analysis, tmp_file_id) = Analysis::from_single_file(inj.text().to_string());
+
+    for mut hl_range in analysis.highlight(tmp_file_id).unwrap() {
+        for range in inj.map_range_up(hl_range.range) {
+            if let Some(range) = literal.map_range_up(range) {
+                hl_range.range = range;
+                hl.add(hl_range.clone());
             }
         }
-        offset
     }
+
+    if let Some(range) = literal.close_quote_text_range() {
+        hl.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
+    }
+
+    Some(())
 }
 
 const RUSTDOC_FENCE: &'static str = "```";
-- 
cgit v1.2.3


From 4a8d2c098d88da6f36f3cf95f424b471987c5daa Mon Sep 17 00:00:00 2001
From: Aleksey Kladov 
Date: Sat, 9 Jan 2021 16:07:41 +0300
Subject: Better highlight for fixtures

---
 crates/ide/src/syntax_highlighting/injection.rs             | 4 ++++
 crates/ide/src/syntax_highlighting/test_data/injection.html | 4 ++--
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/crates/ide/src/syntax_highlighting/injection.rs b/crates/ide/src/syntax_highlighting/injection.rs
index de2180b04..008d5ce24 100644
--- a/crates/ide/src/syntax_highlighting/injection.rs
+++ b/crates/ide/src/syntax_highlighting/injection.rs
@@ -42,6 +42,10 @@ pub(super) fn highlight_injection(
         offset += TextSize::of(chunk);
 
         if let Some(next) = text.strip_prefix(marker) {
+            if let Some(range) = literal.map_range_up(TextRange::at(offset, TextSize::of(marker))) {
+                hl.add(HlRange { range, highlight: HlTag::Keyword.into(), binding_hash: None });
+            }
+
             text = next;
 
             let marker_len = TextSize::of(marker);
diff --git a/crates/ide/src/syntax_highlighting/test_data/injection.html b/crates/ide/src/syntax_highlighting/test_data/injection.html
index a54d303b4..6703a84e5 100644
--- a/crates/ide/src/syntax_highlighting/test_data/injection.html
+++ b/crates/ide/src/syntax_highlighting/test_data/injection.html
@@ -40,9 +40,9 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 fn main() {
     f(r"
 fn foo() {
-    foo($0{
+    foo($0{
         92
-    }$0)
+    }$0)
 }");
 }
\ No newline at end of file -- cgit v1.2.3