1 files changed, 252 insertions, 380 deletions

diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs
index 812229b4e..b94b6a022 100644
--- a/crates/ra_ide/src/syntax_highlighting.rs
+++ b/crates/ra_ide/src/syntax_highlighting.rs
@@ -1,134 +1,141 @@
-//! FIXME: write short doc here
+//! Implements syntax highlighting.
 
-use hir::{HirFileId, InFile, Name, SourceAnalyzer, SourceBinder};
-use ra_db::SourceDatabase;
-use ra_ide_db::{defs::NameDefinition, RootDatabase};
+mod tags;
+mod html;
+#[cfg(test)]
+mod tests;
+
+use hir::{Name, Semantics};
+use ra_ide_db::{
+    defs::{classify_name, NameClass, NameDefinition},
+    RootDatabase,
+};
 use ra_prof::profile;
 use ra_syntax::{
-    ast, AstNode, Direction, SyntaxElement, SyntaxKind, SyntaxKind::*, SyntaxToken, TextRange,
-    WalkEvent, T,
+    ast::{self, HasQuotes, HasStringValue},
+    AstNode, AstToken, Direction, NodeOrToken, SyntaxElement,
+    SyntaxKind::*,
+    SyntaxToken, TextRange, WalkEvent, T,
 };
 use rustc_hash::FxHashMap;
 
-use crate::{
-    expand::descend_into_macros_with_analyzer,
-    references::{classify_name, classify_name_ref},
-    FileId,
-};
+use crate::{call_info::call_info_for_token, references::classify_name_ref, Analysis, FileId};
 
-pub mod tags {
-    pub const FIELD: &str = "field";
-    pub const FUNCTION: &str = "function";
-    pub const MODULE: &str = "module";
-    pub const CONSTANT: &str = "constant";
-    pub const MACRO: &str = "macro";
-
-    pub const VARIABLE: &str = "variable";
-    pub const VARIABLE_MUT: &str = "variable.mut";
-
-    pub const TYPE: &str = "type";
-    pub const TYPE_BUILTIN: &str = "type.builtin";
-    pub const TYPE_SELF: &str = "type.self";
-    pub const TYPE_PARAM: &str = "type.param";
-    pub const TYPE_LIFETIME: &str = "type.lifetime";
-
-    pub const LITERAL_BYTE: &str = "literal.byte";
-    pub const LITERAL_NUMERIC: &str = "literal.numeric";
-    pub const LITERAL_CHAR: &str = "literal.char";
-
-    pub const LITERAL_COMMENT: &str = "comment";
-    pub const LITERAL_STRING: &str = "string";
-    pub const LITERAL_ATTRIBUTE: &str = "attribute";
-
-    pub const KEYWORD: &str = "keyword";
-    pub const KEYWORD_UNSAFE: &str = "keyword.unsafe";
-    pub const KEYWORD_CONTROL: &str = "keyword.control";
-}
+pub(crate) use html::highlight_as_html;
+pub use tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag};
 
 #[derive(Debug)]
 pub struct HighlightedRange {
     pub range: TextRange,
-    pub tag: &'static str,
+    pub highlight: Highlight,
     pub binding_hash: Option<u64>,
 }
 
-fn is_control_keyword(kind: SyntaxKind) -> bool {
-    match kind {
-        T![for]
-        | T![loop]
-        | T![while]
-        | T![continue]
-        | T![break]
-        | T![if]
-        | T![else]
-        | T![match]
-        | T![return] => true,
-        _ => false,
-    }
-}
-
-pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRange> {
+pub(crate) fn highlight(
+    db: &RootDatabase,
+    file_id: FileId,
+    range_to_highlight: Option<TextRange>,
+) -> Vec<HighlightedRange> {
     let _p = profile("highlight");
-    let parse = db.parse(file_id);
-    let root = parse.tree().syntax().clone();
+    let sema = Semantics::new(db);
+
+    // Determine the root based on the given range.
+    let (root, range_to_highlight) = {
+        let source_file = sema.parse(file_id);
+        match range_to_highlight {
+            Some(range) => {
+                let node = match source_file.syntax().covering_element(range) {
+                    NodeOrToken::Node(it) => it,
+                    NodeOrToken::Token(it) => it.parent(),
+                };
+                (node, range)
+            }
+            None => (source_file.syntax().clone(), source_file.syntax().text_range()),
+        }
+    };
 
-    let mut sb = SourceBinder::new(db);
     let mut bindings_shadow_count: FxHashMap<Name, u32> = FxHashMap::default();
     let mut res = Vec::new();
-    let analyzer = sb.analyze(InFile::new(file_id.into(), &root), None);
 
-    let mut in_macro_call = None;
+    let mut current_macro_call: Option<ast::MacroCall> = None;
 
+    // Walk all nodes, keeping track of whether we are inside a macro or not.
+    // If in macro, expand it first and highlight the expanded code.
     for event in root.preorder_with_tokens() {
-        match event {
-            WalkEvent::Enter(node) => match node.kind() {
-                MACRO_CALL => {
-                    in_macro_call = Some(node.clone());
-                    if let Some(range) = highlight_macro(InFile::new(file_id.into(), node)) {
-                        res.push(HighlightedRange { range, tag: tags::MACRO, binding_hash: None });
-                    }
-                }
-                _ if in_macro_call.is_some() => {
-                    if let Some(token) = node.as_token() {
-                        if let Some((tag, binding_hash)) = highlight_token_tree(
-                            &mut sb,
-                            &analyzer,
-                            &mut bindings_shadow_count,
-                            InFile::new(file_id.into(), token.clone()),
-                        ) {
-                            res.push(HighlightedRange {
-                                range: node.text_range(),
-                                tag,
-                                binding_hash,
-                            });
-                        }
-                    }
-                }
-                _ => {
-                    if let Some((tag, binding_hash)) = highlight_node(
-                        &mut sb,
-                        &mut bindings_shadow_count,
-                        InFile::new(file_id.into(), node.clone()),
-                    ) {
-                        res.push(HighlightedRange { range: node.text_range(), tag, binding_hash });
-                    }
-                }
-            },
-            WalkEvent::Leave(node) => {
-                if let Some(m) = in_macro_call.as_ref() {
-                    if *m == node {
-                        in_macro_call = None;
-                    }
+        let event_range = match &event {
+            WalkEvent::Enter(it) => it.text_range(),
+            WalkEvent::Leave(it) => it.text_range(),
+        };
+
+        // Element outside of the viewport, no need to highlight
+        if range_to_highlight.intersection(&event_range).is_none() {
+            continue;
+        }
+
+        // Track "inside macro" state
+        match event.clone().map(|it| it.into_node().and_then(ast::MacroCall::cast)) {
+            WalkEvent::Enter(Some(mc)) => {
+                current_macro_call = Some(mc.clone());
+                if let Some(range) = macro_call_range(&mc) {
+                    res.push(HighlightedRange {
+                        range,
+                        highlight: HighlightTag::Macro.into(),
+                        binding_hash: None,
+                    });
                 }
+                continue;
             }
+            WalkEvent::Leave(Some(mc)) => {
+                assert!(current_macro_call == Some(mc));
+                current_macro_call = None;
+                continue;
+            }
+            _ => (),
+        }
+
+        let element = match event {
+            WalkEvent::Enter(it) => it,
+            WalkEvent::Leave(_) => continue,
+        };
+
+        let range = element.text_range();
+
+        let element_to_highlight = if current_macro_call.is_some() {
+            // Inside a macro -- expand it first
+            let token = match element.clone().into_token() {
+                Some(it) if it.parent().kind() == TOKEN_TREE => it,
+                _ => continue,
+            };
+            let token = sema.descend_into_macros(token.clone());
+            let parent = token.parent();
+            // We only care Name and Name_ref
+            match (token.kind(), parent.kind()) {
+                (IDENT, NAME) | (IDENT, NAME_REF) => parent.into(),
+                _ => token.into(),
+            }
+        } else {
+            element.clone()
+        };
+
+        if let Some(token) = element.as_token().cloned().and_then(ast::RawString::cast) {
+            let expanded = element_to_highlight.as_token().unwrap().clone();
+            if highlight_injection(&mut res, &sema, token, expanded).is_some() {
+                eprintln!("res = {:?}", res);
+                continue;
+            }
+        }
+
+        if let Some((highlight, binding_hash)) =
+            highlight_element(&sema, &mut bindings_shadow_count, element_to_highlight)
+        {
+            res.push(HighlightedRange { range, highlight, binding_hash });
         }
     }
 
     res
 }
 
-fn highlight_macro(node: InFile<SyntaxElement>) -> Option<TextRange> {
-    let macro_call = ast::MacroCall::cast(node.value.as_node()?.clone())?;
+fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
     let path = macro_call.path()?;
     let name_ref = path.segment()?.name_ref()?;
 
@@ -144,101 +151,100 @@ fn highlight_macro(node: InFile<SyntaxElement>) -> Option<TextRange> {
     Some(TextRange::from_to(range_start, range_end))
 }
 
-fn highlight_token_tree(
-    sb: &mut SourceBinder<RootDatabase>,
-    analyzer: &SourceAnalyzer,
-    bindings_shadow_count: &mut FxHashMap<Name, u32>,
-    token: InFile<SyntaxToken>,
-) -> Option<(&'static str, Option<u64>)> {
-    if token.value.parent().kind() != TOKEN_TREE {
-        return None;
-    }
-    let token = descend_into_macros_with_analyzer(sb.db, analyzer, token);
-    let expanded = {
-        let parent = token.value.parent();
-        // We only care Name and Name_ref
-        match (token.value.kind(), parent.kind()) {
-            (IDENT, NAME) | (IDENT, NAME_REF) => token.with_value(parent.into()),
-            _ => token.map(|it| it.into()),
-        }
-    };
-
-    highlight_node(sb, bindings_shadow_count, expanded)
-}
-
-fn highlight_node(
-    sb: &mut SourceBinder<RootDatabase>,
+fn highlight_element(
+    sema: &Semantics<RootDatabase>,
     bindings_shadow_count: &mut FxHashMap<Name, u32>,
-    node: InFile<SyntaxElement>,
-) -> Option<(&'static str, Option<u64>)> {
-    let db = sb.db;
+    element: SyntaxElement,
+) -> Option<(Highlight, Option<u64>)> {
+    let db = sema.db;
     let mut binding_hash = None;
-    let tag = match node.value.kind() {
+    let highlight: Highlight = match element.kind() {
         FN_DEF => {
             bindings_shadow_count.clear();
             return None;
         }
-        COMMENT => tags::LITERAL_COMMENT,
-        STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => tags::LITERAL_STRING,
-        ATTR => tags::LITERAL_ATTRIBUTE,
-        // Special-case field init shorthand
-        NAME_REF if node.value.parent().and_then(ast::RecordField::cast).is_some() => tags::FIELD,
-        NAME_REF if node.value.ancestors().any(|it| it.kind() == ATTR) => return None,
-        NAME_REF => {
-            let name_ref = node.value.as_node().cloned().and_then(ast::NameRef::cast).unwrap();
-            let name_kind = classify_name_ref(sb, node.with_value(&name_ref));
+
+        // Highlight definitions depending on the "type" of the definition.
+        NAME => {
+            let name = element.into_node().and_then(ast::Name::cast).unwrap();
+            let name_kind = classify_name(sema, &name);
+
+            if let Some(NameClass::NameDefinition(NameDefinition::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(name_kind) => {
-                    if let NameDefinition::Local(local) = &name_kind {
-                        if let Some(name) = local.name(db) {
-                            let shadow_count =
-                                bindings_shadow_count.entry(name.clone()).or_default();
-                            binding_hash =
-                                Some(calc_binding_hash(node.file_id, &name, *shadow_count))
-                        }
-                    };
-
-                    highlight_name(db, name_kind)
+                Some(NameClass::NameDefinition(def)) => {
+                    highlight_name(db, def) | HighlightModifier::Definition
                 }
-                _ => return None,
+                Some(NameClass::ConstReference(def)) => highlight_name(db, def),
+                None => highlight_name_by_syntax(name) | HighlightModifier::Definition,
             }
         }
-        NAME => {
-            let name = node.value.as_node().cloned().and_then(ast::Name::cast).unwrap();
-            let name_kind = classify_name(sb, node.with_value(&name));
 
-            if let Some(NameDefinition::Local(local)) = &name_kind {
+        // Highlight references like the definitions they resolve to
+
+        // Special-case field init shorthand
+        NAME_REF if element.parent().and_then(ast::RecordField::cast).is_some() => {
+            HighlightTag::Field.into()
+        }
+        NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => return None,
+        NAME_REF => {
+            let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
+            let name_kind = classify_name_ref(sema, &name_ref)?;
+
+            if let NameDefinition::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(node.file_id, &name, *shadow_count))
+                    binding_hash = Some(calc_binding_hash(&name, *shadow_count))
                 }
             };
 
-            match name_kind {
-                Some(name_kind) => highlight_name(db, name_kind),
-                None => name.syntax().parent().map_or(tags::FUNCTION, |x| match x.kind() {
-                    STRUCT_DEF | ENUM_DEF | TRAIT_DEF | TYPE_ALIAS_DEF => tags::TYPE,
-                    TYPE_PARAM => tags::TYPE_PARAM,
-                    RECORD_FIELD_DEF => tags::FIELD,
-                    _ => tags::FUNCTION,
-                }),
+            highlight_name(db, name_kind)
+        }
+
+        // Simple token-based highlighting
+        COMMENT => HighlightTag::Comment.into(),
+        STRING | RAW_STRING | RAW_BYTE_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(),
+        LIFETIME => {
+            let h = Highlight::new(HighlightTag::Lifetime);
+            dbg!(match element.parent().map(|it| it.kind()) {
+                Some(LIFETIME_PARAM) | Some(LABEL) => h | HighlightModifier::Definition,
+                _ => h,
+            })
+        }
+
+        k if k.is_keyword() => {
+            let h = Highlight::new(HighlightTag::Keyword);
+            match k {
+                T![break]
+                | T![continue]
+                | T![else]
+                | T![for]
+                | T![if]
+                | T![loop]
+                | T![match]
+                | T![return]
+                | T![while] => h | HighlightModifier::Control,
+                T![unsafe] => h | HighlightModifier::Unsafe,
+                _ => h,
             }
         }
-        INT_NUMBER | FLOAT_NUMBER => tags::LITERAL_NUMERIC,
-        BYTE => tags::LITERAL_BYTE,
-        CHAR => tags::LITERAL_CHAR,
-        LIFETIME => tags::TYPE_LIFETIME,
-        T![unsafe] => tags::KEYWORD_UNSAFE,
-        k if is_control_keyword(k) => tags::KEYWORD_CONTROL,
-        k if k.is_keyword() => tags::KEYWORD,
 
         _ => return None,
     };
 
-    return Some((tag, binding_hash));
+    return Some((highlight, binding_hash));
 
-    fn calc_binding_hash(file_id: HirFileId, name: &Name, shadow_count: u32) -> u64 {
+    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};
 
@@ -247,232 +253,98 @@ fn highlight_node(
             hasher.finish()
         }
 
-        hash((file_id, name, shadow_count))
-    }
-}
-
-pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: bool) -> String {
-    let parse = db.parse(file_id);
-
-    fn rainbowify(seed: u64) -> String {
-        use rand::prelude::*;
-        let mut rng = SmallRng::seed_from_u64(seed);
-        format!(
-            "hsl({h},{s}%,{l}%)",
-            h = rng.gen_range::<u16, _, _>(0, 361),
-            s = rng.gen_range::<u16, _, _>(42, 99),
-            l = rng.gen_range::<u16, _, _>(40, 91),
-        )
-    }
-
-    let mut ranges = highlight(db, file_id);
-    ranges.sort_by_key(|it| it.range.start());
-    // quick non-optimal heuristic to intersect token ranges and highlighted ranges
-    let mut frontier = 0;
-    let mut could_intersect: Vec<&HighlightedRange> = Vec::new();
-
-    let mut buf = String::new();
-    buf.push_str(&STYLE);
-    buf.push_str("<pre><code>");
-    let tokens = parse.tree().syntax().descendants_with_tokens().filter_map(|it| it.into_token());
-    for token in tokens {
-        could_intersect.retain(|it| token.text_range().start() <= it.range.end());
-        while let Some(r) = ranges.get(frontier) {
-            if r.range.start() <= token.text_range().end() {
-                could_intersect.push(r);
-                frontier += 1;
-            } else {
-                break;
-            }
-        }
-        let text = html_escape(&token.text());
-        let ranges = could_intersect
-            .iter()
-            .filter(|it| token.text_range().is_subrange(&it.range))
-            .collect::<Vec<_>>();
-        if ranges.is_empty() {
-            buf.push_str(&text);
-        } else {
-            let classes = ranges.iter().map(|x| x.tag).collect::<Vec<_>>().join(" ");
-            let binding_hash = ranges.first().and_then(|x| x.binding_hash);
-            let color = match (rainbow, binding_hash) {
-                (true, Some(hash)) => format!(
-                    " data-binding-hash=\"{}\" style=\"color: {};\"",
-                    hash,
-                    rainbowify(hash)
-                ),
-                _ => "".into(),
-            };
-            buf.push_str(&format!("<span class=\"{}\"{}>{}</span>", classes, color, text));
-        }
+        hash((name, shadow_count))
     }
-    buf.push_str("</code></pre>");
-    buf
 }
 
-fn highlight_name(db: &RootDatabase, def: NameDefinition) -> &'static str {
+fn highlight_name(db: &RootDatabase, def: NameDefinition) -> Highlight {
     match def {
-        NameDefinition::Macro(_) => tags::MACRO,
-        NameDefinition::StructField(_) => tags::FIELD,
-        NameDefinition::ModuleDef(hir::ModuleDef::Module(_)) => tags::MODULE,
-        NameDefinition::ModuleDef(hir::ModuleDef::Function(_)) => tags::FUNCTION,
-        NameDefinition::ModuleDef(hir::ModuleDef::Adt(_)) => tags::TYPE,
-        NameDefinition::ModuleDef(hir::ModuleDef::EnumVariant(_)) => tags::CONSTANT,
-        NameDefinition::ModuleDef(hir::ModuleDef::Const(_)) => tags::CONSTANT,
-        NameDefinition::ModuleDef(hir::ModuleDef::Static(_)) => tags::CONSTANT,
-        NameDefinition::ModuleDef(hir::ModuleDef::Trait(_)) => tags::TYPE,
-        NameDefinition::ModuleDef(hir::ModuleDef::TypeAlias(_)) => tags::TYPE,
-        NameDefinition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => tags::TYPE_BUILTIN,
-        NameDefinition::SelfType(_) => tags::TYPE_SELF,
-        NameDefinition::TypeParam(_) => tags::TYPE_PARAM,
+        NameDefinition::Macro(_) => HighlightTag::Macro,
+        NameDefinition::StructField(_) => HighlightTag::Field,
+        NameDefinition::ModuleDef(def) => match def {
+            hir::ModuleDef::Module(_) => HighlightTag::Module,
+            hir::ModuleDef::Function(_) => HighlightTag::Function,
+            hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HighlightTag::Struct,
+            hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HighlightTag::Enum,
+            hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Union,
+            hir::ModuleDef::EnumVariant(_) => HighlightTag::EnumVariant,
+            hir::ModuleDef::Const(_) => HighlightTag::Constant,
+            hir::ModuleDef::Static(_) => HighlightTag::Static,
+            hir::ModuleDef::Trait(_) => HighlightTag::Trait,
+            hir::ModuleDef::TypeAlias(_) => HighlightTag::TypeAlias,
+            hir::ModuleDef::BuiltinType(_) => HighlightTag::BuiltinType,
+        },
+        NameDefinition::SelfType(_) => HighlightTag::SelfType,
+        NameDefinition::TypeParam(_) => HighlightTag::TypeParam,
+        // FIXME: distinguish between locals and parameters
         NameDefinition::Local(local) => {
+            let mut h = Highlight::new(HighlightTag::Local);
             if local.is_mut(db) || local.ty(db).is_mutable_reference() {
-                tags::VARIABLE_MUT
-            } else {
-                tags::VARIABLE
+                h |= HighlightModifier::Mutable;
             }
+            return h;
         }
     }
+    .into()
 }
 
-//FIXME: like, real html escaping
-fn html_escape(text: &str) -> String {
-    text.replace("<", "&lt;").replace(">", "&gt;")
-}
-
-const STYLE: &str = "
-<style>
-body                { margin: 0; }
-pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
-
-.comment            { color: #7F9F7F; }
-.string             { color: #CC9393; }
-.field              { color: #94BFF3; }
-.function           { color: #93E0E3; }
-.parameter          { color: #94BFF3; }
-.text               { color: #DCDCCC; }
-.type               { color: #7CB8BB; }
-.type\\.builtin     { color: #8CD0D3; }
-.type\\.param       { color: #20999D; }
-.attribute          { color: #94BFF3; }
-.literal            { color: #BFEBBF; }
-.literal\\.numeric  { color: #6A8759; }
-.macro              { color: #94BFF3; }
-.module             { color: #AFD8AF; }
-.variable           { color: #DCDCCC; }
-.variable\\.mut     { color: #DCDCCC; text-decoration: underline; }
-
-.keyword            { color: #F0DFAF; }
-.keyword\\.unsafe   { color: #DFAF8F; }
-.keyword\\.control  { color: #F0DFAF; font-weight: bold; }
-</style>
-";
-
-#[cfg(test)]
-mod tests {
-    use std::fs;
-
-    use test_utils::{assert_eq_text, project_dir, read_text};
-
-    use crate::mock_analysis::{single_file, MockAnalysis};
-
-    #[test]
-    fn test_highlighting() {
-        let (analysis, file_id) = single_file(
-            r#"
-#[derive(Clone, Debug)]
-struct Foo {
-    pub x: i32,
-    pub y: i32,
-}
-
-fn foo<T>() -> T {
-    unimplemented!();
-    foo::<i32>();
-}
+fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
+    let default = HighlightTag::Function.into();
 
-macro_rules! def_fn {
-    ($($tt:tt)*) => {$($tt)*}
-}
+    let parent = match name.syntax().parent() {
+        Some(it) => it,
+        _ => return default,
+    };
 
-def_fn!{
-    fn bar() -> u32 {
-        100
+    match parent.kind() {
+        STRUCT_DEF => HighlightTag::Struct.into(),
+        ENUM_DEF => HighlightTag::Enum.into(),
+        UNION_DEF => HighlightTag::Union.into(),
+        TRAIT_DEF => HighlightTag::Trait.into(),
+        TYPE_ALIAS_DEF => HighlightTag::TypeAlias.into(),
+        TYPE_PARAM => HighlightTag::TypeParam.into(),
+        RECORD_FIELD_DEF => HighlightTag::Field.into(),
+        _ => default,
     }
 }
 
-// comment
-fn main() {
-    println!("Hello, {}!", 92);
-
-    let mut vec = Vec::new();
-    if true {
-        let x = 92;
-        vec.push(Foo { x, y: 1 });
+fn highlight_injection(
+    acc: &mut Vec<HighlightedRange>,
+    sema: &Semantics<RootDatabase>,
+    literal: ast::RawString,
+    expanded: SyntaxToken,
+) -> Option<()> {
+    let call_info = call_info_for_token(&sema, expanded)?;
+    let idx = call_info.active_parameter?;
+    let name = call_info.signature.parameter_names.get(idx)?;
+    if name != "ra_fixture" {
+        return None;
     }
-    unsafe { vec.set_len(0); }
-
-    let mut x = 42;
-    let y = &mut x;
-    let z = &y;
-
-    y;
-}
-
-enum E<X> {
-    V(X)
-}
-
-impl<X> E<X> {
-    fn new<T>() -> E<T> {}
-}
-"#
-            .trim(),
-        );
-        let dst_file = project_dir().join("crates/ra_ide/src/snapshots/highlighting.html");
-        let actual_html = &analysis.highlight_as_html(file_id, false).unwrap();
-        let expected_html = &read_text(&dst_file);
-        fs::write(dst_file, &actual_html).unwrap();
-        assert_eq_text!(expected_html, actual_html);
+    let value = literal.value()?;
+    let (analysis, tmp_file_id) = Analysis::from_single_file(value);
+
+    if let Some(range) = literal.open_quote_text_range() {
+        acc.push(HighlightedRange {
+            range,
+            highlight: HighlightTag::StringLiteral.into(),
+            binding_hash: None,
+        })
     }
 
-    #[test]
-    fn test_rainbow_highlighting() {
-        let (analysis, file_id) = single_file(
-            r#"
-fn main() {
-    let hello = "hello";
-    let x = hello.to_string();
-    let y = hello.to_string();
-
-    let x = "other color please!";
-    let y = x.to_string();
-}
-
-fn bar() {
-    let mut hello = "hello";
-}
-"#
-            .trim(),
-        );
-        let dst_file = project_dir().join("crates/ra_ide/src/snapshots/rainbow_highlighting.html");
-        let actual_html = &analysis.highlight_as_html(file_id, true).unwrap();
-        let expected_html = &read_text(&dst_file);
-        fs::write(dst_file, &actual_html).unwrap();
-        assert_eq_text!(expected_html, actual_html);
+    for mut h in analysis.highlight(tmp_file_id).unwrap() {
+        if let Some(r) = literal.map_range_up(h.range) {
+            h.range = r;
+            acc.push(h)
+        }
     }
 
-    #[test]
-    fn accidentally_quadratic() {
-        let file = project_dir().join("crates/ra_syntax/test_data/accidentally_quadratic");
-        let src = fs::read_to_string(file).unwrap();
-
-        let mut mock = MockAnalysis::new();
-        let file_id = mock.add_file("/main.rs", &src);
-        let host = mock.analysis_host();
-
-        // let t = std::time::Instant::now();
-        let _ = host.analysis().highlight(file_id).unwrap();
-        // eprintln!("elapsed: {:?}", t.elapsed());
+    if let Some(range) = literal.close_quote_text_range() {
+        acc.push(HighlightedRange {
+            range,
+            highlight: HighlightTag::StringLiteral.into(),
+            binding_hash: None,
+        })
     }
+
+    Some(())
 }