More clever highlighting, incl draft for structs

1 files changed, 114 insertions, 71 deletions

diff --git a/crates/ra_ide_api/src/syntax_highlighting.rs b/crates/ra_ide_api/src/syntax_highlighting.rs
index 407fcda4a..8981c85e6 100644
--- a/crates/ra_ide_api/src/syntax_highlighting.rs
+++ b/crates/ra_ide_api/src/syntax_highlighting.rs
@@ -10,7 +10,7 @@ use crate::{FileId, db::RootDatabase};
 pub struct HighlightedRange {
     pub range: TextRange,
     pub tag: &'static str,
-    pub id: Option<u64>,
+    pub binding_hash: Option<u64>,
 }
 
 fn is_control_keyword(kind: SyntaxKind) -> bool {
@@ -30,15 +30,18 @@ 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 hash<T: std::hash::Hash + std::fmt::Debug>(x: T) -> u64 {
-        use std::{collections::hash_map::DefaultHasher, hash::Hasher};
+    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()
+        }
 
-        let mut hasher = DefaultHasher::new();
-        x.hash(&mut hasher);
-        hasher.finish()
+        hash((file_id, text, shadow_count))
     }
 
     // Visited nodes to handle highlighting priorities
@@ -50,66 +53,92 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
         if highlighted.contains(&node) {
             continue;
         }
-        let (tag, id) = match node.kind() {
-            COMMENT => ("comment", None),
-            STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => ("string", None),
-            ATTR => ("attribute", None),
+        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_ast_node::<ast::NameRef>() {
+                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};
 
                     // FIXME: try to reuse the SourceAnalyzers
                     let analyzer = hir::SourceAnalyzer::new(db, file_id, name_ref.syntax(), None);
                     match classify_name_ref(db, &analyzer, name_ref) {
-                        Some(Method(_)) => ("function", None),
-                        Some(Macro(_)) => ("macro", None),
-                        Some(FieldAccess(_)) => ("field", None),
-                        Some(AssocItem(ImplItem::Method(_))) => ("function", None),
-                        Some(AssocItem(ImplItem::Const(_))) => ("constant", None),
-                        Some(AssocItem(ImplItem::TypeAlias(_))) => ("type", None),
-                        Some(Def(ModuleDef::Module(_))) => ("module", None),
-                        Some(Def(ModuleDef::Function(_))) => ("function", None),
-                        Some(Def(ModuleDef::Struct(_))) => ("type", None),
-                        Some(Def(ModuleDef::Union(_))) => ("type", None),
-                        Some(Def(ModuleDef::Enum(_))) => ("type", None),
-                        Some(Def(ModuleDef::EnumVariant(_))) => ("constant", None),
-                        Some(Def(ModuleDef::Const(_))) => ("constant", None),
-                        Some(Def(ModuleDef::Static(_))) => ("constant", None),
-                        Some(Def(ModuleDef::Trait(_))) => ("type", None),
-                        Some(Def(ModuleDef::TypeAlias(_))) => ("type", None),
-                        Some(SelfType(_)) => ("type", None),
-                        Some(Pat(ptr)) => ("variable", Some(hash({
-                            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();
-                            (text, shadow_count)
-                        }))),
-                        Some(SelfParam(_)) => ("type", None),
-                        Some(GenericParam(_)) => ("type", None),
-                        None => ("text", None),
+                        Some(Method(_)) => "function",
+                        Some(Macro(_)) => "macro",
+                        Some(FieldAccess(field)) => {
+                            let (hir_file_id, src) = field.source(db);
+                            if let hir::FieldSource::Named(name) = src {
+                                let text = name.syntax().text().to_smol_string();
+                                let shadow_count = 0; // potentially even from different file
+                                binding_hash = Some(calc_binding_hash(hir_file_id.original_file(db), &text, shadow_count));
+                            }
+
+                            "field"
+                        },
+                        Some(AssocItem(ImplItem::Method(_))) => "function",
+                        Some(AssocItem(ImplItem::Const(_))) => "constant",
+                        Some(AssocItem(ImplItem::TypeAlias(_))) => "type",
+                        Some(Def(ModuleDef::Module(_))) => "module",
+                        Some(Def(ModuleDef::Function(_))) => "function",
+                        Some(Def(ModuleDef::Struct(_))) => "type",
+                        Some(Def(ModuleDef::Union(_))) => "type",
+                        Some(Def(ModuleDef::Enum(_))) => "type",
+                        Some(Def(ModuleDef::EnumVariant(_))) => "constant",
+                        Some(Def(ModuleDef::Const(_))) => "constant",
+                        Some(Def(ModuleDef::Static(_))) => "constant",
+                        Some(Def(ModuleDef::Trait(_))) => "type",
+                        Some(Def(ModuleDef::TypeAlias(_))) => "type",
+                        Some(SelfType(_)) => "type",
+                        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",
                     }
                 } else {
-                    ("text", None)
+                    "text"
                 }
             }
             NAME => {
-                if let Some(name) = node.as_ast_node::<ast::Name>() {
-                    ("variable", Some(hash({
-                        let text = name.syntax().text().to_smol_string();
-                        let shadow_count = bindings_shadow_count.entry(text.clone()).or_insert(1);
-                        *shadow_count += 1;
-                        (text, shadow_count)
-                    })))
+                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 if name.syntax().ancestors().any(|x| ast::NamedFieldDef::cast(x).is_some()) {
+                        binding_hash = Some({
+                            let text = name.syntax().text().to_smol_string();
+                            let shadow_count = 0;
+                            calc_binding_hash(file_id, &text, shadow_count)
+                        });
+                        "variable"
+                    } else {
+                        "function"
+                    }
                 } else {
-                    ("text", None)
+                    "text"
                 }
             }
-            TYPE_ALIAS_DEF | TYPE_ARG | TYPE_PARAM => ("type", None),
-            INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE => ("literal", None),
-            LIFETIME => ("parameter", None),
-            T![unsafe] => ("keyword.unsafe", None),
-            k if is_control_keyword(k) => ("keyword.control", None),
-            k if k.is_keyword() => ("keyword", None),
+            TYPE_ALIAS_DEF | TYPE_ARG | TYPE_PARAM => "type",
+            INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE => "literal",
+            LIFETIME => "parameter",
+            T![unsafe] => "keyword.unsafe",
+            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) {
@@ -128,7 +157,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",
-                                    id: None,
+                                    binding_hash: None,
                                 })
                             }
                         }
@@ -137,14 +166,24 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Vec<HighlightedRa
                 continue;
             }
         };
-        res.push(HighlightedRange { range: node.range(), tag, id })
+        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
@@ -166,16 +205,20 @@ 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>");
@@ -189,11 +232,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; }
@@ -208,7 +248,6 @@ pre {
 .keyword           { color: #F0DFAF; }
 .keyword\\.unsafe  { color: #F0DFAF; font-weight: bold; }
 .keyword\\.control { color: #DC8CC3; }
-
 </style>
 ";
 
@@ -241,12 +280,12 @@ 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 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);
     }
 
@@ -261,9 +300,13 @@ fn main() {
 
     let x = "other color please!";
     let y = x.to_string();
-}"#,
+}
+"#.trim(),
         );
-        let result = analysis.highlight(file_id);
-        assert_debug_snapshot_matches!("rainbow_highlighting", result);
+        let dst_file = project_dir().join("crates/ra_ide_api/src/snapshots/rainbow_highlighting.html");
+        let actual_html = &analysis.highlight_as_html(file_id).unwrap();
+        let expected_html = &read_text(&dst_file);
+        std::fs::write(dst_file, &actual_html).unwrap();
+        assert_eq_text!(expected_html, actual_html);
     }
 }