Merge #1319

1319: Rainbow highlighting spike 🌈 r=killercup a=killercup

Very simple approach: For each identifier, set the hash of the range
where it's defined as its 'id' and use it in the VSCode extension to
generate unique colors.

Thus, the generated colors are per-file. They are also quite fragile,
and I'm not entirely sure why. Looks like we need to make sure the
same ranges aren't overwritten by a later request?

Co-authored-by: Pascal Hertleif <[email protected]>

9 files changed, 165 insertions, 43 deletions

diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
index 93aba4c70..84a1564ce 100644
--- a/crates/ra_cli/src/main.rs
+++ b/crates/ra_cli/src/main.rs
@@ -16,7 +16,10 @@ fn main() -> Result<()> {
         .setting(clap::AppSettings::SubcommandRequiredElseHelp)
         .subcommand(SubCommand::with_name("parse").arg(Arg::with_name("no-dump").long("--no-dump")))
         .subcommand(SubCommand::with_name("symbols"))
-        .subcommand(SubCommand::with_name("highlight"))
+        .subcommand(
+            SubCommand::with_name("highlight")
+                .arg(Arg::with_name("rainbow").short("r").long("rainbow")),
+        )
         .subcommand(
             SubCommand::with_name("analysis-stats")
                 .arg(Arg::with_name("verbose").short("v").long("verbose"))
@@ -39,9 +42,9 @@ fn main() -> Result<()> {
                 println!("{:?}", s);
             }
         }
-        ("highlight", _) => {
+        ("highlight", Some(matches)) => {
             let (analysis, file_id) = Analysis::from_single_file(read_stdin()?);
-            let html = analysis.highlight_as_html(file_id).unwrap();
+            let html = analysis.highlight_as_html(file_id, matches.is_present("rainbow")).unwrap();
             println!("{}", html);
         }
         ("analysis-stats", Some(matches)) => {
diff --git a/crates/ra_ide_api/Cargo.toml b/crates/ra_ide_api/Cargo.toml
index d399d5e2e..8939e9d79 100644
--- a/crates/ra_ide_api/Cargo.toml
+++ b/crates/ra_ide_api/Cargo.toml
@@ -15,6 +15,7 @@ rustc-hash = "1.0"
 parking_lot = "0.7.0"
 unicase = "2.2.0"
 superslice = "1.0.0"
+rand = "0.6.5"
 
 jemallocator = { version = "0.1.9", optional = true }
 jemalloc-ctl = { version = "0.2.0", optional = true }
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index d3456d5b2..452407e8e 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -463,8 +463,8 @@ impl Analysis {
     }
 
     /// Computes syntax highlighting for the given file.
-    pub fn highlight_as_html(&self, file_id: FileId) -> Cancelable<String> {
-        self.with_db(|db| syntax_highlighting::highlight_as_html(db, file_id))
+    pub fn highlight_as_html(&self, file_id: FileId, rainbow: bool) -> Cancelable<String> {
+        self.with_db(|db| syntax_highlighting::highlight_as_html(db, file_id, rainbow))
     }
 
     /// Computes completions at the given position.
@@ -472,7 +472,7 @@ impl Analysis {
         self.with_db(|db| completion::completions(db, position).map(Into::into))
     }
 
-    /// Computes assists (aks code actons aka intentions) for the given
+    /// Computes assists (aka code actions aka intentions) for the given
     /// position.
     pub fn assists(&self, frange: FileRange) -> Cancelable<Vec<Assist>> {
         self.with_db(|db| assists::assists(db, frange))
diff --git a/crates/ra_ide_api/src/snapshots/highlighting.html b/crates/ra_ide_api/src/snapshots/highlighting.html
index bfc0a67b1..ebd187a35 100644
--- a/crates/ra_ide_api/src/snapshots/highlighting.html
+++ b/crates/ra_ide_api/src/snapshots/highlighting.html
@@ -1,10 +1,7 @@
 
 <style>
-pre {
-    color: #DCDCCC;
-    background-color: #3F3F3F;
-    font-size: 22px;
-}
+body       { margin: 0; }
+pre        { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
 
 .comment   { color: #7F9F7F; }
 .string    { color: #CC9393; }
@@ -19,10 +16,8 @@ pre {
 .keyword           { color: #F0DFAF; }
 .keyword\.unsafe  { color: #F0DFAF; font-weight: bold; }
 .keyword\.control { color: #DC8CC3; }
-
 </style>
-<pre><code>
-<span class="attribute">#</span><span class="attribute">[</span><span class="attribute">derive</span><span class="attribute">(</span><span class="attribute">Clone</span><span class="attribute">,</span><span class="attribute"> </span><span class="attribute">Debug</span><span class="attribute">)</span><span class="attribute">]</span>
+<pre><code><span class="attribute">#</span><span class="attribute">[</span><span class="attribute">derive</span><span class="attribute">(</span><span class="attribute">Clone</span><span class="attribute">,</span><span class="attribute"> </span><span class="attribute">Debug</span><span class="attribute">)</span><span class="attribute">]</span>
 <span class="keyword">struct</span> <span class="function">Foo</span> {
     <span class="keyword">pub</span> <span class="function">x</span>: <span class="text">i32</span>,
     <span class="keyword">pub</span> <span class="function">y</span>: <span class="text">i32</span>,
@@ -36,10 +31,9 @@ pre {
 <span class="keyword">fn</span> <span class="function">main</span>() {
     <span class="macro">println</span><span class="macro">!</span>(<span class="string">"Hello, {}!"</span>, <span class="literal">92</span>);
 
-    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="function">vec</span> = <span class="text">Vec</span>::<span class="text">new</span>();
+    <span class="keyword">let</span> <span class="keyword">mut</span> <span class="variable" data-binding-hash="9636295041291189729" style="color: hsl(51,57%,74%);">vec</span> = <span class="text">Vec</span>::<span class="text">new</span>();
     <span class="keyword.control">if</span> <span class="keyword">true</span> {
-        <span class="text">vec</span>.<span class="text">push</span>(<span class="type">Foo</span> { <span class="field">x</span>: <span class="literal">0</span>, <span class="field">y</span>: <span class="literal">1</span> });
+        <span class="variable" data-binding-hash="8496027264380925433" style="color: hsl(18,48%,55%);">vec</span>.<span class="text">push</span>(<span class="type">Foo</span> { <span class="field">x</span>: <span class="literal">0</span>, <span class="field">y</span>: <span class="literal">1</span> });
     }
-    <span class="keyword.unsafe">unsafe</span> { <span class="text">vec</span>.<span class="text">set_len</span>(<span class="literal">0</span>); }
-}
-</code></pre>
\ No newline at end of file
+    <span class="keyword.unsafe">unsafe</span> { <span class="variable" data-binding-hash="8496027264380925433" style="color: hsl(18,48%,55%);">vec</span>.<span class="text">set_len</span>(<span class="literal">0</span>); }
+}</code></pre>
\ No newline at end of file
diff --git a/crates/ra_ide_api/src/snapshots/rainbow_highlighting.html b/crates/ra_ide_api/src/snapshots/rainbow_highlighting.html
new file mode 100644
index 000000000..729d129d0
--- /dev/null
+++ b/crates/ra_ide_api/src/snapshots/rainbow_highlighting.html
@@ -0,0 +1,27 @@
+
+<style>
+body       { margin: 0; }
+pre        { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
+
+.comment   { color: #7F9F7F; }
+.string    { color: #CC9393; }
+.function  { color: #93E0E3; }
+.parameter { color: #94BFF3; }
+.builtin   { color: #DD6718; }
+.text      { color: #DCDCCC; }
+.attribute { color: #BFEBBF; }
+.literal   { color: #DFAF8F; }
+.macro     { color: #DFAF8F; }
+
+.keyword           { color: #F0DFAF; }
+.keyword\.unsafe  { color: #F0DFAF; font-weight: bold; }
+.keyword\.control { color: #DC8CC3; }
+</style>
+<pre><code><span class="keyword">fn</span> <span class="function">main</span>() {
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="3888301305669440875" style="color: hsl(242,59%,59%);">hello</span> = <span class="string">"hello"</span>;
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="5695551762718493399" style="color: hsl(272,48%,45%);">x</span> = <span class="variable" data-binding-hash="3888301305669440875" style="color: hsl(242,59%,59%);">hello</span>.<span class="text">to_string</span>();
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="5435401749617022797" style="color: hsl(353,77%,74%);">y</span> = <span class="variable" data-binding-hash="3888301305669440875" style="color: hsl(242,59%,59%);">hello</span>.<span class="text">to_string</span>();
+
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="1903207544374197704" style="color: hsl(58,61%,61%);">x</span> = <span class="string">"other color please!"</span>;
+    <span class="keyword">let</span> <span class="variable" data-binding-hash="14878783531007968800" style="color: hsl(265,73%,83%);">y</span> = <span class="variable" data-binding-hash="1903207544374197704" style="color: hsl(58,61%,61%);">x</span>.<span class="text">to_string</span>();
+}</code></pre>
\ No newline at end of file
diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs
index 87e053364..dcefb0513 100644
--- a/crates/ra_ide_api/src/syntax_highlighting.rs
+++ b/crates/ra_ide_api/src/syntax_highlighting.rs
@@ -1,6 +1,6 @@
-use rustc_hash::FxHashSet;
+use rustc_hash::{FxHashSet, FxHashMap};
 
-use ra_syntax::{ast, AstNode, TextRange, Direction, SyntaxKind, SyntaxKind::*, SyntaxElement, T};
+use ra_syntax::{ast, AstNode, TextRange, Direction, SmolStr, SyntaxKind, SyntaxKind::*, SyntaxElement, T};
 use ra_db::SourceDatabase;
 use ra_prof::profile;
 
@@ -10,6 +10,7 @@ use crate::{FileId, db::RootDatabase};
 pub struct HighlightedRange {
     pub range: TextRange,
     pub tag: &'static str,
+    pub binding_hash: Option<u64>,
 }
 
 fn is_control_keyword(kind: SyntaxKind) -> bool {
@@ -29,22 +30,36 @@ fn is_control_keyword(kind: SyntaxKind) -> bool {
 
 pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRange> {
     let _p = profile("highlight");
-
     let source_file = db.parse(file_id);
 
+    fn calc_binding_hash(file_id: FileId, text: &SmolStr, shadow_count: u32) -> u64 {
+        fn hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
+            use std::{collections::hash_map::DefaultHasher, hash::Hasher};
+
+            let mut hasher = DefaultHasher::new();
+            x.hash(&mut hasher);
+            hasher.finish()
+        }
+
+        hash((file_id, text, shadow_count))
+    }
+
     // Visited nodes to handle highlighting priorities
     let mut highlighted: FxHashSet<SyntaxElement> = FxHashSet::default();
+    let mut bindings_shadow_count: FxHashMap<SmolStr, u32> = FxHashMap::default();
+
     let mut res = Vec::new();
     for node in source_file.syntax().descendants_with_tokens() {
         if highlighted.contains(&node) {
             continue;
         }
+        let mut binding_hash = None;
         let tag = match node.kind() {
             COMMENT => "comment",
             STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => "string",
             ATTR => "attribute",
             NAME_REF => {
-                if let Some(name_ref) = node.as_node().and_then(|n| ast::NameRef::cast(n)) {
+                if let Some(name_ref) = node.as_node().and_then(ast::NameRef::cast) {
                     use crate::name_ref_kind::{classify_name_ref, NameRefKind::*};
                     use hir::{ModuleDef, ImplItem};
 
@@ -68,7 +83,20 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                         Some(Def(ModuleDef::Trait(_))) => "type",
                         Some(Def(ModuleDef::TypeAlias(_))) => "type",
                         Some(SelfType(_)) => "type",
-                        Some(Pat(_)) => "text",
+                        Some(Pat(ptr)) => {
+                            binding_hash = Some({
+                                let text = ptr
+                                    .syntax_node_ptr()
+                                    .to_node(&source_file.syntax())
+                                    .text()
+                                    .to_smol_string();
+                                let shadow_count =
+                                    bindings_shadow_count.entry(text.clone()).or_default();
+                                calc_binding_hash(file_id, &text, *shadow_count)
+                            });
+
+                            "variable"
+                        }
                         Some(SelfParam(_)) => "type",
                         Some(GenericParam(_)) => "type",
                         None => "text",
@@ -77,7 +105,24 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                     "text"
                 }
             }
-            NAME => "function",
+            NAME => {
+                if let Some(name) = node.as_node().and_then(ast::Name::cast) {
+                    if name.syntax().ancestors().any(|x| ast::BindPat::cast(x).is_some()) {
+                        binding_hash = Some({
+                            let text = name.syntax().text().to_smol_string();
+                            let shadow_count =
+                                bindings_shadow_count.entry(text.clone()).or_insert(0);
+                            *shadow_count += 1;
+                            calc_binding_hash(file_id, &text, *shadow_count)
+                        });
+                        "variable"
+                    } else {
+                        "function"
+                    }
+                } else {
+                    "text"
+                }
+            }
             TYPE_ALIAS_DEF | TYPE_ARG | TYPE_PARAM => "type",
             INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE => "literal",
             LIFETIME => "parameter",
@@ -85,6 +130,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
             k if is_control_keyword(k) => "keyword.control",
             k if k.is_keyword() => "keyword",
             _ => {
+                // let analyzer = hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
                 if let Some(macro_call) = node.as_node().and_then(ast::MacroCall::cast) {
                     if let Some(path) = macro_call.path() {
                         if let Some(segment) = path.segment() {
@@ -101,6 +147,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                                 res.push(HighlightedRange {
                                     range: TextRange::from_to(range_start, range_end),
                                     tag: "macro",
+                                    binding_hash: None,
                                 })
                             }
                         }
@@ -109,14 +156,25 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                 continue;
             }
         };
-        res.push(HighlightedRange { range: node.range(), tag })
+        res.push(HighlightedRange { range: node.range(), tag, binding_hash })
     }
     res
 }
 
-pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId) -> String {
+pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId, rainbow: bool) -> String {
     let source_file = 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
@@ -138,16 +196,24 @@ pub(crate) fn highlight_as_html(db: &RootDatabase, file_id: FileId) -> String {
             }
         }
         let text = html_escape(&token.text());
-        let classes = could_intersect
+        let ranges = could_intersect
             .iter()
             .filter(|it| token.range().is_subrange(&it.range))
-            .map(|it| it.tag)
             .collect::<Vec<_>>();
-        if classes.is_empty() {
+        if ranges.is_empty() {
             buf.push_str(&text);
         } else {
-            let classes = classes.join(" ");
-            buf.push_str(&format!("<span class=\"{}\">{}</span>", classes, text));
+            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));
         }
     }
     buf.push_str("</code></pre>");
@@ -161,11 +227,8 @@ fn html_escape(text: &str) -> String {
 
 const STYLE: &str = "
 <style>
-pre {
-    color: #DCDCCC;
-    background-color: #3F3F3F;
-    font-size: 22px;
-}
+body       { margin: 0; }
+pre        { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padding: 0.4em; }
 
 .comment   { color: #7F9F7F; }
 .string    { color: #CC9393; }
@@ -180,7 +243,6 @@ pre {
 .keyword           { color: #F0DFAF; }
 .keyword\\.unsafe  { color: #F0DFAF; font-weight: bold; }
 .keyword\\.control { color: #DC8CC3; }
-
 </style>
 ";
 
@@ -213,12 +275,36 @@ fn main() {
     }
     unsafe { vec.set_len(0); }
 }
-"#,
+"#
+            .trim(),
         );
         let dst_file = project_dir().join("crates/ra_ide_api/src/snapshots/highlighting.html");
-        let actual_html = &analysis.highlight_as_html(file_id).unwrap();
+        let actual_html = &analysis.highlight_as_html(file_id, true).unwrap();
+        let expected_html = &read_text(&dst_file);
+        std::fs::write(dst_file, &actual_html).unwrap();
+        assert_eq_text!(expected_html, actual_html);
+    }
+
+    #[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();
+}
+"#
+            .trim(),
+        );
+        let dst_file =
+            project_dir().join("crates/ra_ide_api/src/snapshots/rainbow_highlighting.html");
+        let actual_html = &analysis.highlight_as_html(file_id, true).unwrap();
         let expected_html = &read_text(&dst_file);
-        // std::fs::write(dst_file, &actual_html).unwrap();
+        std::fs::write(dst_file, &actual_html).unwrap();
         assert_eq_text!(expected_html, actual_html);
     }
 }
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index a82ae696b..e36db12b3 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -872,7 +872,11 @@ fn highlight(world: &ServerWorld, file_id: FileId) -> Result<Vec<Decoration>> {
         .analysis()
         .highlight(file_id)?
         .into_iter()
-        .map(|h| Decoration { range: h.range.conv_with(&line_index), tag: h.tag })
+        .map(|h| Decoration {
+            range: h.range.conv_with(&line_index),
+            tag: h.tag,
+            binding_hash: h.binding_hash.map(|x| x.to_string()),
+        })
         .collect();
     Ok(res)
 }
diff --git a/crates/ra_lsp_server/src/req.rs b/crates/ra_lsp_server/src/req.rs
index 6090eb7b9..992c24eac 100644
--- a/crates/ra_lsp_server/src/req.rs
+++ b/crates/ra_lsp_server/src/req.rs
@@ -129,6 +129,7 @@ pub struct PublishDecorationsParams {
 pub struct Decoration {
     pub range: Range,
     pub tag: &'static str,
+    pub binding_hash: Option<String>,
 }
 
 pub enum ParentModule {}
diff --git a/crates/ra_syntax/src/syntax_text.rs b/crates/ra_syntax/src/syntax_text.rs
index b013164c4..c9038cd5c 100644
--- a/crates/ra_syntax/src/syntax_text.rs
+++ b/crates/ra_syntax/src/syntax_text.rs
@@ -1,6 +1,6 @@
 use std::{fmt, ops::{self, Bound}};
 
-use crate::{SyntaxNode, TextRange, TextUnit, SyntaxElement};
+use crate::{SmolStr, SyntaxNode, TextRange, TextUnit, SyntaxElement};
 
 #[derive(Clone)]
 pub struct SyntaxText<'a> {
@@ -34,6 +34,12 @@ impl<'a> SyntaxText<'a> {
         self.chunks().collect()
     }
 
+    pub fn to_smol_string(&self) -> SmolStr {
+        // FIXME: use `self.chunks().collect()` here too once
+        // https://github.com/matklad/smol_str/pull/12 is merged and published
+        self.to_string().into()
+    }
+
     pub fn contains(&self, c: char) -> bool {
         self.chunks().any(|it| it.contains(c))
     }