Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2025-01-12 21:28:51 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge #7216

Browse source 
7216: Highlighting improvements r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>
This commit is contained in:
bors[bot] 2021-01-09 13:09:15 +00:00 committed by GitHub
commit 939ca83b34
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 334 additions and 394 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
crates/ide/src/lib.rs
View file

@ -76,8 +76,8 @@ pub use crate::{
references::{rename::RenameError, Declaration, ReferenceSearchResult},
runnables::{Runnable, RunnableKind, TestId},
syntax_highlighting::{
tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag},
HighlightedRange,
tags::{Highlight, HlMod, HlMods, HlTag},
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<Vec<HighlightedRange>> {
pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HlRange>> {
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<Vec<HighlightedRange>> {
pub fn highlight_range(&self, frange: FileRange) -> Cancelable<Vec<HlRange>> {
self.with_db(|db| {
syntax_highlighting::highlight(db, frange.file_id, Some(frange.range), false)
})

267
crates/ide/src/syntax_highlighting.rs
View file

@ -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;
@ -26,13 +28,13 @@ 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;
#[derive(Debug, Clone)]
pub struct HighlightedRange {
#[derive(Debug, Clone, Copy)]
pub struct HlRange {
pub range: TextRange,
pub highlight: Highlight,
pub binding_hash: Option<u64>,
@ -52,7 +54,7 @@ pub(crate) fn highlight(
file_id: FileId,
range_to_highlight: Option<TextRange>,
syntactic_name_ref_highlighting: bool,
) -> Vec<HighlightedRange> {
) -> Vec<HlRange> {
let _p = profile::span("highlight");
let sema = Semantics::new(db);
@ -72,7 +74,7 @@ pub(crate) fn highlight(
};
let mut bindings_shadow_count: FxHashMap<Name, u32> = 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<ast::MacroCall> = None;
let mut current_macro_rules: Option<ast::MacroRules> = None;
@ -96,9 +98,9 @@ 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 {
hl.add(HlRange {
range,
highlight: HighlightTag::Symbol(SymbolKind::Macro).into(),
highlight: HlTag::Symbol(SymbolKind::Macro).into(),
binding_hash: None,
});
}
@ -134,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()) => {
@ -179,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;
}
}
@ -192,24 +194,24 @@ 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() {
stack.add(HighlightedRange { 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(HighlightedRange {
hl.add(HlRange {
range: piece_range + range.start(),
highlight: HighlightTag::EscapeSequence.into(),
highlight: HlTag::EscapeSequence.into(),
binding_hash: None,
});
}
@ -219,7 +221,7 @@ pub(crate) fn highlight(
}
}
stack.to_vec()
hl.to_vec()
}
fn macro_call_range(macro_call: &ast::MacroCall) -> Option<TextRange> {
@ -292,22 +294,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 +315,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 +336,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 +344,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 +353,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 +367,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 +421,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 +433,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()
HlTag::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()
}
_ => 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 +462,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 +478,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 +486,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 +502,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 +551,21 @@ fn highlight_method_call(
method_call: &ast::MethodCallExpr,
) -> Option<Highlight> {
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 +576,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 +655,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 +675,7 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
}
fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabase>) -> Highlight {
let default = HighlightTag::UnresolvedReference;
let default = HlTag::UnresolvedReference;
let parent = match name.syntax().parent() {
Some(it) => it,
@ -703,10 +686,10 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
METHOD_CALL_EXPR => {
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 +701,7 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
})
.unwrap_or(false);
if is_union {
h | HighlightModifier::Unsafe
h | HlMod::Unsafe
} else {
h.into()
}
@ -733,9 +716,9 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
_ => {
// 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 +729,11 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
};
match parent.kind() {
CALL_EXPR => 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(),
}

12
crates/ide/src/syntax_highlighting/format.rs
View file

@ -4,7 +4,7 @@ use syntax::{
AstNode, AstToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange,
};
use crate::{HighlightTag, HighlightedRange, 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,
@ -57,7 +57,7 @@ impl FormatStringHighlighter {
}
}
fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HighlightTag> {
fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HlTag> {
Some(match kind {
FormatSpecifier::Open
| FormatSpecifier::Close
@ -69,8 +69,8 @@ fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HighlightTag> {
| 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),
})
}

61
crates/ide/src/syntax_highlighting/highlights.rs
View file

@ -4,33 +4,29 @@ use std::{cmp::Ordering, iter};
use stdx::equal_range_by;
use syntax::TextRange;
use crate::{HighlightTag, HighlightedRange};
use crate::{HlRange, HlTag};
pub(super) struct Highlights {
root: Node,
}
struct Node {
highlighted_range: HighlightedRange,
hl_range: HlRange,
nested: Vec<Node>,
}
impl Highlights {
pub(super) fn new(range: TextRange) -> Highlights {
Highlights {
root: Node::new(HighlightedRange {
range,
highlight: HighlightTag::Dummy.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<HighlightedRange> {
pub(super) fn to_vec(self) -> Vec<HlRange> {
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::<Vec<_>>();
self.nested[start].nested = nested;
}
fn flatten(&self, acc: &mut Vec<HighlightedRange>) {
let mut start = self.highlighted_range.range.start();
fn flatten(&self, acc: &mut Vec<HlRange>) {
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,
}

16
crates/ide/src/syntax_highlighting/html.rs
View file

@ -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("<pre><code>");
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, "<span class=\"{}\"{}>{}</span>", class, color, html_escape(curr));
format_to!(buf, "<span class=\"{}\"{}>{}</span>", class, color, chunk);
}
buf.push_str("</code></pre>");
buf

115
crates/ide/src/syntax_highlighting/injection.rs
View file

@ -7,12 +7,12 @@ 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, HlMod, HlRange, HlTag, RootDatabase};
use super::{highlights::Highlights, injector::Injector};
pub(super) fn highlight_injection(
acc: &mut Highlights,
hl: &mut Highlights,
sema: &Semantics<RootDatabase>,
literal: ast::String,
expanded: SyntaxToken,
@ -22,82 +22,55 @@ pub(super) fn highlight_injection(
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(HighlightedRange {
range,
highlight: HighlightTag::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);
if let Some(range) = literal.map_range_up(range) {
h.range = range;
acc.add(h);
let mut inj = Injector::default();
let mut text = &*value;
let mut offset: TextSize = 0.into();
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)));
text = next;
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);
offset += marker_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());
}
}
}
if let Some(range) = literal.close_quote_text_range() {
acc.add(HighlightedRange {
range,
highlight: HighlightTag::StringLiteral.into(),
binding_hash: None,
})
hl.add(HlRange { range, highlight: HlTag::StringLiteral.into(), binding_hash: None })
}
Some(())
}
/// Data to remove `$0` from string and map ranges
#[derive(Default, Debug)]
struct MarkerInfo {
cleaned_text: String,
markers: Vec<TextRange>,
}
impl MarkerInfo {
fn new(mut text: &str) -> Self {
let marker = "$0";
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);
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;
}
}
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()
}
}
offset
}
}
const RUSTDOC_FENCE: &'static str = "```";
const RUSTDOC_FENCE_TOKENS: &[&'static str] = &[
"",
@ -116,7 +89,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<HighlightedRange>, Injector)> {
pub(super) fn extract_doc_comments(node: &SyntaxNode) -> Option<(Vec<HlRange>, Injector)> {
let mut inj = Injector::default();
// wrap the doctest into function body to get correct syntax highlighting
let prefix = "fn doctest() {\n";
@ -166,12 +139,12 @@ pub(super) fn extract_doc_comments(node: &SyntaxNode) -> Option<(Vec<Highlighted
pos
};
new_comments.push(HighlightedRange {
new_comments.push(HlRange {
range: TextRange::new(
range.start(),
range.start() + TextSize::try_from(pos).unwrap(),
),
highlight: HighlightTag::Comment | HighlightModifier::Documentation,
highlight: HlTag::Comment | HlMod::Documentation,
binding_hash: None,
});
line_start += range.len() - TextSize::try_from(pos).unwrap();
@ -196,7 +169,7 @@ pub(super) fn extract_doc_comments(node: &SyntaxNode) -> Option<(Vec<Highlighted
/// Injection of syntax highlighting of doctests.
pub(super) fn highlight_doc_comment(
new_comments: Vec<HighlightedRange>,
new_comments: Vec<HlRange>,
inj: Injector,
stack: &mut Highlights,
) {
@ -207,9 +180,9 @@ 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 | HighlightModifier::Injected,
highlight: h.highlight | HlMod::Injected,
binding_hash: h.binding_hash,
});
}

12
crates/ide/src/syntax_highlighting/injector.rs
View file

@ -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<TextSize>) {
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);
}

8
crates/ide/src/syntax_highlighting/macro_rules.rs
View file

@ -1,7 +1,7 @@
//! Syntax highlighting for macro_rules!.
use syntax::{SyntaxElement, SyntaxKind, SyntaxToken, TextRange, T};
use crate::{HighlightTag, HighlightedRange};
use crate::{HlRange, HlTag};
#[derive(Default)]
pub(super) struct MacroRulesHighlighter {
@ -19,13 +19,13 @@ impl MacroRulesHighlighter {
}
}
pub(super) fn highlight(&self, element: SyntaxElement) -> Option<HighlightedRange> {
pub(super) fn highlight(&self, element: SyntaxElement) -> Option<HlRange> {
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: HighlightTag::UnresolvedReference.into(),
highlight: HlTag::UnresolvedReference.into(),
binding_hash: None,
});
}

138
crates/ide/src/syntax_highlighting/tags.rs
View file

@ -7,15 +7,15 @@ use crate::SymbolKind;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Highlight {
pub tag: HighlightTag,
pub modifiers: HighlightModifiers,
pub tag: HlTag,
pub mods: HlMods,
}
#[derive(Default, Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct HighlightModifiers(u32);
pub struct HlMods(u32);
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum HighlightTag {
pub enum HlTag {
Symbol(SymbolKind),
BoolLiteral,
@ -33,13 +33,13 @@ 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)]
#[repr(u8)]
pub enum HighlightModifier {
pub enum HlMod {
/// Used to differentiate individual elements within attributes.
Attribute = 0,
/// Used with keywords like `if` and `break`.
@ -61,10 +61,10 @@ pub enum HighlightModifier {
Unsafe,
}
impl HighlightTag {
impl HlTag {
fn as_str(self) -> &'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::Dummy => "dummy",
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<HighlightTag> for Highlight {
fn from(tag: HighlightTag) -> Highlight {
impl From<HlTag> 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::Dummy && self.modifiers == HighlightModifiers::default()
self.tag == HlTag::None && self.mods == HlMods::default()
}
}
impl ops::BitOr<HighlightModifier> for HighlightTag {
impl ops::BitOr<HlMod> for HlTag {
type Output = Highlight;
fn bitor(self, rhs: HighlightModifier) -> Highlight {
fn bitor(self, rhs: HlMod) -> Highlight {
Highlight::new(self) | rhs
}
}
impl ops::BitOrAssign<HighlightModifier> for HighlightModifiers {
fn bitor_assign(&mut self, rhs: HighlightModifier) {
impl ops::BitOrAssign<HlMod> for HlMods {
fn bitor_assign(&mut self, rhs: HlMod) {
self.0 |= rhs.mask();
}
}
impl ops::BitOrAssign<HighlightModifier> for Highlight {
fn bitor_assign(&mut self, rhs: HighlightModifier) {
self.modifiers |= rhs;
impl ops::BitOrAssign<HlMod> for Highlight {
fn bitor_assign(&mut self, rhs: HlMod) {
self.mods |= rhs;
}
}
impl ops::BitOr<HighlightModifier> for Highlight {
impl ops::BitOr<HlMod> 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<Item = HighlightModifier> {
HighlightModifier::ALL.iter().copied().filter(move |it| self.0 & it.mask() == it.mask())
pub fn iter(self) -> impl Iterator<Item = HlMod> {
HlMod::ALL.iter().copied().filter(move |it| self.0 & it.mask() == it.mask())
}
}

20
crates/ide/src/syntax_highlighting/test_data/highlight_doctest.html
View file

@ -37,7 +37,7 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
.unresolved_reference { color: #FC5555; text-decoration: wavy underline; }
</style>
<pre><code><span class="comment documentation">/// ```</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="punctuation injected">_</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="string_literal injected">"early doctests should not go boom"</span><span class="punctuation injected">;</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="punctuation injected">_</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="string_literal injected">"early doctests should not go boom"</span><span class="punctuation injected">;</span>
<span class="comment documentation">/// ```</span>
<span class="keyword">struct</span> <span class="struct declaration">Foo</span> <span class="punctuation">{</span>
<span class="field declaration">bar</span><span class="punctuation">:</span> <span class="builtin_type">bool</span><span class="punctuation">,</span>
@ -45,7 +45,7 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
<span class="keyword">impl</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
<span class="comment documentation">/// ```</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="punctuation injected">_</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="string_literal injected">"Call me</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="punctuation injected">_</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="string_literal injected">"Call me</span>
<span class="comment">// KILLER WHALE</span>
<span class="comment documentation">/// </span><span class="string_literal injected"> Ishmael."</span><span class="punctuation injected">;</span>
<span class="comment documentation">/// ```</span>
@ -56,8 +56,8 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
<span class="comment documentation">/// # Examples</span>
<span class="comment documentation">///</span>
<span class="comment documentation">/// ```</span>
<span class="comment documentation">/// #</span><span class="dummy injected"> </span><span class="attribute attribute injected">#</span><span class="attribute attribute injected">!</span><span class="attribute attribute injected">[</span><span class="function attribute injected">allow</span><span class="punctuation attribute injected">(</span><span class="attribute attribute injected">unused_mut</span><span class="punctuation attribute injected">)</span><span class="attribute attribute injected">]</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="keyword injected">mut</span><span class="dummy injected"> </span><span class="variable declaration injected mutable">foo</span><span class="punctuation injected">:</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
<span class="comment documentation">/// #</span><span class="none injected"> </span><span class="attribute attribute injected">#</span><span class="attribute attribute injected">!</span><span class="attribute attribute injected">[</span><span class="function attribute injected">allow</span><span class="punctuation attribute injected">(</span><span class="attribute attribute injected">unused_mut</span><span class="punctuation attribute injected">)</span><span class="attribute attribute injected">]</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="keyword injected">mut</span><span class="none injected"> </span><span class="variable declaration injected mutable">foo</span><span class="punctuation injected">:</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
<span class="comment documentation">/// ```</span>
<span class="keyword">pub</span> <span class="keyword">const</span> <span class="keyword">fn</span> <span class="function declaration static associated">new</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="operator">-&gt;</span> <span class="struct">Foo</span> <span class="punctuation">{</span>
<span class="struct">Foo</span> <span class="punctuation">{</span> <span class="field">bar</span><span class="punctuation">:</span> <span class="bool_literal">true</span> <span class="punctuation">}</span>
@ -68,26 +68,26 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
<span class="comment documentation">/// # Examples</span>
<span class="comment documentation">///</span>
<span class="comment documentation">/// ```</span>
<span class="comment documentation">/// </span><span class="keyword injected">use</span><span class="dummy injected"> </span><span class="module injected">x</span><span class="operator injected">::</span><span class="module injected">y</span><span class="punctuation injected">;</span>
<span class="comment documentation">/// </span><span class="keyword injected">use</span><span class="none injected"> </span><span class="module injected">x</span><span class="operator injected">::</span><span class="module injected">y</span><span class="punctuation injected">;</span>
<span class="comment documentation">///</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">foo</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">foo</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
<span class="comment documentation">///</span>
<span class="comment documentation">/// </span><span class="comment injected">// calls bar on foo</span>
<span class="comment documentation">/// </span><span class="macro injected">assert!</span><span class="punctuation injected">(</span><span class="dummy injected">foo</span><span class="operator injected">.</span><span class="dummy injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
<span class="comment documentation">/// </span><span class="macro injected">assert!</span><span class="punctuation injected">(</span><span class="none injected">foo</span><span class="operator injected">.</span><span class="none injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
<span class="comment documentation">///</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">bar</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="variable injected">foo</span><span class="operator injected">.</span><span class="field injected">bar</span><span class="dummy injected"> </span><span class="operator injected">||</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="constant injected">bar</span><span class="punctuation injected">;</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">bar</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="variable injected">foo</span><span class="operator injected">.</span><span class="field injected">bar</span><span class="none injected"> </span><span class="operator injected">||</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="constant injected">bar</span><span class="punctuation injected">;</span>
<span class="comment documentation">///</span>
<span class="comment documentation">/// </span><span class="comment injected">/* multi-line</span>
<span class="comment documentation">/// </span><span class="comment injected"> comment */</span>
<span class="comment documentation">///</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">multi_line_string</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="string_literal injected">"Foo</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">multi_line_string</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="string_literal injected">"Foo</span>
<span class="comment documentation">/// </span><span class="string_literal injected"> bar</span>
<span class="comment documentation">/// </span><span class="string_literal injected"> "</span><span class="punctuation injected">;</span>
<span class="comment documentation">///</span>
<span class="comment documentation">/// ```</span>
<span class="comment documentation">///</span>
<span class="comment documentation">/// ```rust,no_run</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="dummy injected"> </span><span class="variable declaration injected">foobar</span><span class="dummy injected"> </span><span class="operator injected">=</span><span class="dummy injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="operator injected">.</span><span class="function injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
<span class="comment documentation">/// </span><span class="keyword injected">let</span><span class="none injected"> </span><span class="variable declaration injected">foobar</span><span class="none injected"> </span><span class="operator injected">=</span><span class="none injected"> </span><span class="struct injected">Foo</span><span class="operator injected">::</span><span class="function injected">new</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="operator injected">.</span><span class="function injected">bar</span><span class="punctuation injected">(</span><span class="punctuation injected">)</span><span class="punctuation injected">;</span>
<span class="comment documentation">/// ```</span>
<span class="comment documentation">///</span>
<span class="comment documentation">/// ```sh</span>

4
crates/ide/src/syntax_highlighting/test_data/injection.html
View file

@ -40,9 +40,9 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
<span class="keyword">fn</span> <span class="function declaration">main</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
<span class="function">f</span><span class="punctuation">(</span><span class="string_literal">r"</span>
<span class="keyword">fn</span> <span class="function declaration">foo</span><span class="punctuation">(</span><span class="punctuation">)</span> <span class="punctuation">{</span>
<span class="function">foo</span><span class="punctuation">(</span>$0<span class="punctuation">{</span>
<span class="function">foo</span><span class="punctuation">(</span><span class="keyword">$0</span><span class="punctuation">{</span>
<span class="numeric_literal">92</span>
<span class="punctuation">}</span>$0<span class="punctuation">)</span>
<span class="punctuation">}</span><span class="keyword">$0</span><span class="punctuation">)</span>
<span class="punctuation">}</span><span class="string_literal">"</span><span class="punctuation">)</span><span class="punctuation">;</span>
<span class="punctuation">}</span>
</code></pre>

67
crates/rust-analyzer/src/to_proto.rs
View file

@ -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, HlMod, HlRange, HlTag, Indel, InlayHint,
InlayKind, InsertTextFormat, LineIndex, Markup, NavigationTarget, ReferenceAccess, Runnable,
Severity, SourceChange, SourceFileEdit, SymbolKind, TextEdit, TextRange, TextSize,
};
use itertools::Itertools;
@ -337,7 +336,7 @@ static TOKEN_RESULT_COUNTER: AtomicU32 = AtomicU32::new(1);
pub(crate) fn semantic_tokens(
text: &str,
line_index: &LineIndex,
highlights: Vec<HighlightedRange>,
highlights: Vec<HlRange>,
) -> lsp_types::SemanticTokens {
let id = TOKEN_RESULT_COUNTER.fetch_add(1, Ordering::SeqCst).to_string();
let mut builder = semantic_tokens::SemanticTokensBuilder::new(id);
@ -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::Dummy => 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;
}