mirror of
https://github.com/rust-lang/rust-analyzer.git
synced 2025-09-27 20:42:04 +00:00
More clever highlighting, incl draft for structs
This commit is contained in:
Pascal Hertleif
parent
ed89b0638b
commit
43d5a49653
10 changed files with 159 additions and 414 deletions
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue