Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-27 05:23:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

Shorten frequent names

Browse source
This commit is contained in:
Aleksey Kladov 2021-01-09 14:44:01 +03:00
parent 6fb52af521
commit 64a6ee4535
8 changed files with 222 additions and 246 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -76,7 +76,7 @@ pub use crate::{
references::{rename::RenameError, Declaration, ReferenceSearchResult}, references::{rename::RenameError, Declaration, ReferenceSearchResult},
runnables::{Runnable, RunnableKind, TestId}, runnables::{Runnable, RunnableKind, TestId},
syntax_highlighting::{ syntax_highlighting::{
tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag}, tags::{Highlight, HlMod, HlMods, HlTag},
HighlightedRange, HighlightedRange,
}, },
}; };

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

@ -26,7 +26,7 @@ use crate::{
syntax_highlighting::{ syntax_highlighting::{
format::FormatStringHighlighter, macro_rules::MacroRulesHighlighter, tags::Highlight, format::FormatStringHighlighter, macro_rules::MacroRulesHighlighter, tags::Highlight,
}, },
FileId, HighlightModifier, HighlightTag, SymbolKind, FileId, HlMod, HlTag, SymbolKind,
}; };
pub(crate) use html::highlight_as_html; pub(crate) use html::highlight_as_html;
@ -98,7 +98,7 @@ pub(crate) fn highlight(
if let Some(range) = macro_call_range(&mc) { if let Some(range) = macro_call_range(&mc) {
stack.add(HighlightedRange { stack.add(HighlightedRange {
range, range,
highlight: HighlightTag::Symbol(SymbolKind::Macro).into(), highlight: HlTag::Symbol(SymbolKind::Macro).into(),
binding_hash: None, binding_hash: None,
}); });
} }
@ -192,7 +192,7 @@ pub(crate) fn highlight(
element_to_highlight.clone(), element_to_highlight.clone(),
) { ) {
if inside_attribute { if inside_attribute {
highlight = highlight | HighlightModifier::Attribute; highlight = highlight | HlMod::Attribute;
} }
if macro_rules_highlighter.highlight(element_to_highlight.clone()).is_none() { if macro_rules_highlighter.highlight(element_to_highlight.clone()).is_none() {
@ -209,7 +209,7 @@ pub(crate) fn highlight(
if string.text()[piece_range.start().into()..].starts_with('\\') { if string.text()[piece_range.start().into()..].starts_with('\\') {
stack.add(HighlightedRange { stack.add(HighlightedRange {
range: piece_range + range.start(), range: piece_range + range.start(),
highlight: HighlightTag::EscapeSequence.into(), highlight: HlTag::EscapeSequence.into(),
binding_hash: None, binding_hash: None,
}); });
} }
@ -292,22 +292,20 @@ fn highlight_element(
}; };
match name_kind { match name_kind {
Some(NameClass::ExternCrate(_)) => HighlightTag::Symbol(SymbolKind::Module).into(), Some(NameClass::ExternCrate(_)) => HlTag::Symbol(SymbolKind::Module).into(),
Some(NameClass::Definition(def)) => { Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
highlight_def(db, def) | HighlightModifier::Definition
}
Some(NameClass::ConstReference(def)) => highlight_def(db, def), Some(NameClass::ConstReference(def)) => highlight_def(db, def),
Some(NameClass::PatFieldShorthand { field_ref, .. }) => { 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 Definition::Field(field) = field_ref {
if let VariantDef::Union(_) = field.parent_def(db) { if let VariantDef::Union(_) = field.parent_def(db) {
h |= HighlightModifier::Unsafe; h |= HlMod::Unsafe;
} }
} }
h h
} }
None => highlight_name_by_syntax(name) | HighlightModifier::Definition, None => highlight_name_by_syntax(name) | HlMod::Definition,
} }
} }
@ -315,16 +313,14 @@ fn highlight_element(
NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => { 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 // 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 // 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 => { NAME_REF => {
let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap(); let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
highlight_func_by_name_ref(sema, &name_ref).unwrap_or_else(|| { highlight_func_by_name_ref(sema, &name_ref).unwrap_or_else(|| {
match NameRefClass::classify(sema, &name_ref) { match NameRefClass::classify(sema, &name_ref) {
Some(name_kind) => match name_kind { Some(name_kind) => match name_kind {
NameRefClass::ExternCrate(_) => { NameRefClass::ExternCrate(_) => HlTag::Symbol(SymbolKind::Module).into(),
HighlightTag::Symbol(SymbolKind::Module).into()
}
NameRefClass::Definition(def) => { NameRefClass::Definition(def) => {
if let Definition::Local(local) = &def { if let Definition::Local(local) = &def {
if let Some(name) = local.name(db) { if let Some(name) = local.name(db) {
@ -338,7 +334,7 @@ fn highlight_element(
if let Definition::Local(local) = &def { if let Definition::Local(local) = &def {
if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) { if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) {
h |= HighlightModifier::Consuming; h |= HlMod::Consuming;
} }
} }
@ -346,7 +342,7 @@ fn highlight_element(
if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) { if matches!(parent.kind(), FIELD_EXPR | RECORD_PAT_FIELD) {
if let Definition::Field(field) = def { if let Definition::Field(field) = def {
if let VariantDef::Union(_) = field.parent_def(db) { if let VariantDef::Union(_) = field.parent_def(db) {
h |= HighlightModifier::Unsafe; h |= HlMod::Unsafe;
} }
} }
} }
@ -355,13 +351,13 @@ fn highlight_element(
h h
} }
NameRefClass::FieldShorthand { .. } => { NameRefClass::FieldShorthand { .. } => {
HighlightTag::Symbol(SymbolKind::Field).into() HlTag::Symbol(SymbolKind::Field).into()
} }
}, },
None if syntactic_name_ref_highlighting => { None if syntactic_name_ref_highlighting => {
highlight_name_ref_by_syntax(name_ref, sema) highlight_name_ref_by_syntax(name_ref, sema)
} }
None => HighlightTag::UnresolvedReference.into(), None => HlTag::UnresolvedReference.into(),
} }
}) })
} }
@ -369,60 +365,53 @@ fn highlight_element(
// Simple token-based highlighting // Simple token-based highlighting
COMMENT => { COMMENT => {
let comment = element.into_token().and_then(ast::Comment::cast)?; let comment = element.into_token().and_then(ast::Comment::cast)?;
let h = HighlightTag::Comment; let h = HlTag::Comment;
match comment.kind().doc { match comment.kind().doc {
Some(_) => h | HighlightModifier::Documentation, Some(_) => h | HlMod::Documentation,
None => h.into(), None => h.into(),
} }
} }
STRING | BYTE_STRING => HighlightTag::StringLiteral.into(), STRING | BYTE_STRING => HlTag::StringLiteral.into(),
ATTR => HighlightTag::Attribute.into(), ATTR => HlTag::Attribute.into(),
INT_NUMBER | FLOAT_NUMBER => HighlightTag::NumericLiteral.into(), INT_NUMBER | FLOAT_NUMBER => HlTag::NumericLiteral.into(),
BYTE => HighlightTag::ByteLiteral.into(), BYTE => HlTag::ByteLiteral.into(),
CHAR => HighlightTag::CharLiteral.into(), CHAR => HlTag::CharLiteral.into(),
QUESTION => Highlight::new(HighlightTag::Operator) | HighlightModifier::ControlFlow, QUESTION => Highlight::new(HlTag::Operator) | HlMod::ControlFlow,
LIFETIME => { LIFETIME => {
let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap(); let lifetime = element.into_node().and_then(ast::Lifetime::cast).unwrap();
match NameClass::classify_lifetime(sema, &lifetime) { match NameClass::classify_lifetime(sema, &lifetime) {
Some(NameClass::Definition(def)) => { Some(NameClass::Definition(def)) => highlight_def(db, def) | HlMod::Definition,
highlight_def(db, def) | HighlightModifier::Definition
}
None => match NameRefClass::classify_lifetime(sema, &lifetime) { None => match NameRefClass::classify_lifetime(sema, &lifetime) {
Some(NameRefClass::Definition(def)) => highlight_def(db, def), Some(NameRefClass::Definition(def)) => highlight_def(db, def),
_ => Highlight::new(HighlightTag::Symbol(SymbolKind::LifetimeParam)), _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)),
}, },
_ => { _ => Highlight::new(HlTag::Symbol(SymbolKind::LifetimeParam)) | HlMod::Definition,
Highlight::new(HighlightTag::Symbol(SymbolKind::LifetimeParam))
| HighlightModifier::Definition
}
} }
} }
p if p.is_punct() => match p { p if p.is_punct() => match p {
T![&] => { T![&] => {
let h = HighlightTag::Operator.into(); let h = HlTag::Operator.into();
let is_unsafe = element let is_unsafe = element
.parent() .parent()
.and_then(ast::RefExpr::cast) .and_then(ast::RefExpr::cast)
.map(|ref_expr| sema.is_unsafe_ref_expr(&ref_expr)) .map(|ref_expr| sema.is_unsafe_ref_expr(&ref_expr))
.unwrap_or(false); .unwrap_or(false);
if is_unsafe { if is_unsafe {
h | HighlightModifier::Unsafe h | HlMod::Unsafe
} else { } else {
h h
} }
} }
T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => { T![::] | T![->] | T![=>] | T![..] | T![=] | T![@] | T![.] => HlTag::Operator.into(),
HighlightTag::Operator.into()
}
T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => { 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() => { 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() => { 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() => { T![*] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?; let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
@ -430,11 +419,11 @@ fn highlight_element(
let expr = prefix_expr.expr()?; let expr = prefix_expr.expr()?;
let ty = sema.type_of_expr(&expr)?; let ty = sema.type_of_expr(&expr)?;
if ty.is_raw_ptr() { if ty.is_raw_ptr() {
HighlightTag::Operator | HighlightModifier::Unsafe HlTag::Operator | HlMod::Unsafe
} else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() { } else if let Some(ast::PrefixOp::Deref) = prefix_expr.op_kind() {
HighlightTag::Operator.into() HlTag::Operator.into()
} else { } else {
HighlightTag::Punctuation.into() HlTag::Punctuation.into()
} }
} }
T![-] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => { T![-] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
@ -442,34 +431,26 @@ fn highlight_element(
let expr = prefix_expr.expr()?; let expr = prefix_expr.expr()?;
match expr { match expr {
ast::Expr::Literal(_) => HighlightTag::NumericLiteral, ast::Expr::Literal(_) => HlTag::NumericLiteral,
_ => HighlightTag::Operator, _ => HlTag::Operator,
} }
.into() .into()
} }
_ if element.parent().and_then(ast::PrefixExpr::cast).is_some() => { _ if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
HighlightTag::Operator.into() HlTag::Operator.into()
}
_ if element.parent().and_then(ast::BinExpr::cast).is_some() => {
HighlightTag::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() => { _ 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() => { _ if element.parent().and_then(ast::RangePat::cast).is_some() => HlTag::Operator.into(),
HighlightTag::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(),
_ if element.parent().and_then(ast::RestPat::cast).is_some() => { _ => HlTag::Punctuation.into(),
HighlightTag::Operator.into()
}
_ if element.parent().and_then(ast::Attr::cast).is_some() => {
HighlightTag::Attribute.into()
}
_ => HighlightTag::Punctuation.into(),
}, },
k if k.is_keyword() => { k if k.is_keyword() => {
let h = Highlight::new(HighlightTag::Keyword); let h = Highlight::new(HlTag::Keyword);
match k { match k {
T![break] T![break]
| T![continue] | T![continue]
@ -479,10 +460,10 @@ fn highlight_element(
| T![match] | T![match]
| T![return] | T![return]
| T![while] | T![while]
| T![in] => h | HighlightModifier::ControlFlow, | T![in] => h | HlMod::ControlFlow,
T![for] if !is_child_of_impl(&element) => h | HighlightModifier::ControlFlow, T![for] if !is_child_of_impl(&element) => h | HlMod::ControlFlow,
T![unsafe] => h | HighlightModifier::Unsafe, T![unsafe] => h | HlMod::Unsafe,
T![true] | T![false] => HighlightTag::BoolLiteral.into(), T![true] | T![false] => HlTag::BoolLiteral.into(),
T![self] => { T![self] => {
let self_param_is_mut = element let self_param_is_mut = element
.parent() .parent()
@ -495,7 +476,7 @@ fn highlight_element(
.and_then(SyntaxNode::parent) .and_then(SyntaxNode::parent)
.and_then(ast::Path::cast) .and_then(ast::Path::cast)
.and_then(|p| sema.resolve_path(&p)); .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 if self_param_is_mut
|| matches!(self_path, || matches!(self_path,
Some(hir::PathResolution::Local(local)) Some(hir::PathResolution::Local(local))
@ -503,12 +484,12 @@ fn highlight_element(
&& (local.is_mut(db) || local.ty(db).is_mutable_reference()) && (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 let Some(hir::PathResolution::Local(local)) = self_path {
if is_consumed_lvalue(element, &local, db) { if is_consumed_lvalue(element, &local, db) {
h |= HighlightModifier::Consuming; h |= HlMod::Consuming;
} }
} }
@ -519,7 +500,7 @@ fn highlight_element(
.and_then(ast::IdentPat::cast) .and_then(ast::IdentPat::cast)
.and_then(|ident_pat| { .and_then(|ident_pat| {
if sema.is_unsafe_ident_pat(&ident_pat) { if sema.is_unsafe_ident_pat(&ident_pat) {
Some(HighlightModifier::Unsafe) Some(HlMod::Unsafe)
} else { } else {
None None
} }
@ -568,21 +549,21 @@ fn highlight_method_call(
method_call: &ast::MethodCallExpr, method_call: &ast::MethodCallExpr,
) -> Option<Highlight> { ) -> Option<Highlight> {
let func = sema.resolve_method_call(&method_call)?; let func = sema.resolve_method_call(&method_call)?;
let mut h = HighlightTag::Symbol(SymbolKind::Function).into(); let mut h = HlTag::Symbol(SymbolKind::Function).into();
h |= HighlightModifier::Associated; h |= HlMod::Associated;
if func.is_unsafe(sema.db) || sema.is_unsafe_method_call(&method_call) { 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) { if let Some(self_param) = func.self_param(sema.db) {
match self_param.access(sema.db) { match self_param.access(sema.db) {
hir::Access::Shared => (), hir::Access::Shared => (),
hir::Access::Exclusive => h |= HighlightModifier::Mutable, hir::Access::Exclusive => h |= HlMod::Mutable,
hir::Access::Owned => { hir::Access::Owned => {
if let Some(receiver_ty) = if let Some(receiver_ty) =
method_call.receiver().and_then(|it| sema.type_of_expr(&it)) method_call.receiver().and_then(|it| sema.type_of_expr(&it))
{ {
if !receiver_ty.is_copy(sema.db) { if !receiver_ty.is_copy(sema.db) {
h |= HighlightModifier::Consuming h |= HlMod::Consuming
} }
} }
} }
@ -593,78 +574,78 @@ fn highlight_method_call(
fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight { fn highlight_def(db: &RootDatabase, def: Definition) -> Highlight {
match def { match def {
Definition::Macro(_) => HighlightTag::Symbol(SymbolKind::Macro), Definition::Macro(_) => HlTag::Symbol(SymbolKind::Macro),
Definition::Field(_) => HighlightTag::Symbol(SymbolKind::Field), Definition::Field(_) => HlTag::Symbol(SymbolKind::Field),
Definition::ModuleDef(def) => match def { Definition::ModuleDef(def) => match def {
hir::ModuleDef::Module(_) => HighlightTag::Symbol(SymbolKind::Module), hir::ModuleDef::Module(_) => HlTag::Symbol(SymbolKind::Module),
hir::ModuleDef::Function(func) => { 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() { if func.as_assoc_item(db).is_some() {
h |= HighlightModifier::Associated; h |= HlMod::Associated;
if func.self_param(db).is_none() { if func.self_param(db).is_none() {
h |= HighlightModifier::Static h |= HlMod::Static
} }
} }
if func.is_unsafe(db) { if func.is_unsafe(db) {
h |= HighlightModifier::Unsafe; h |= HlMod::Unsafe;
} }
return h; return h;
} }
hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HighlightTag::Symbol(SymbolKind::Struct), hir::ModuleDef::Adt(hir::Adt::Struct(_)) => HlTag::Symbol(SymbolKind::Struct),
hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HighlightTag::Symbol(SymbolKind::Enum), hir::ModuleDef::Adt(hir::Adt::Enum(_)) => HlTag::Symbol(SymbolKind::Enum),
hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Symbol(SymbolKind::Union), hir::ModuleDef::Adt(hir::Adt::Union(_)) => HlTag::Symbol(SymbolKind::Union),
hir::ModuleDef::Variant(_) => HighlightTag::Symbol(SymbolKind::Variant), hir::ModuleDef::Variant(_) => HlTag::Symbol(SymbolKind::Variant),
hir::ModuleDef::Const(konst) => { 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() { if konst.as_assoc_item(db).is_some() {
h |= HighlightModifier::Associated h |= HlMod::Associated
} }
return h; return h;
} }
hir::ModuleDef::Trait(_) => HighlightTag::Symbol(SymbolKind::Trait), hir::ModuleDef::Trait(_) => HlTag::Symbol(SymbolKind::Trait),
hir::ModuleDef::TypeAlias(type_) => { 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() { if type_.as_assoc_item(db).is_some() {
h |= HighlightModifier::Associated h |= HlMod::Associated
} }
return h; return h;
} }
hir::ModuleDef::BuiltinType(_) => HighlightTag::BuiltinType, hir::ModuleDef::BuiltinType(_) => HlTag::BuiltinType,
hir::ModuleDef::Static(s) => { 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) { if s.is_mut(db) {
h |= HighlightModifier::Mutable; h |= HlMod::Mutable;
h |= HighlightModifier::Unsafe; h |= HlMod::Unsafe;
} }
return h; return h;
} }
}, },
Definition::SelfType(_) => HighlightTag::Symbol(SymbolKind::Impl), Definition::SelfType(_) => HlTag::Symbol(SymbolKind::Impl),
Definition::TypeParam(_) => HighlightTag::Symbol(SymbolKind::TypeParam), Definition::TypeParam(_) => HlTag::Symbol(SymbolKind::TypeParam),
Definition::ConstParam(_) => HighlightTag::Symbol(SymbolKind::ConstParam), Definition::ConstParam(_) => HlTag::Symbol(SymbolKind::ConstParam),
Definition::Local(local) => { Definition::Local(local) => {
let tag = if local.is_param(db) { let tag = if local.is_param(db) {
HighlightTag::Symbol(SymbolKind::ValueParam) HlTag::Symbol(SymbolKind::ValueParam)
} else { } else {
HighlightTag::Symbol(SymbolKind::Local) HlTag::Symbol(SymbolKind::Local)
}; };
let mut h = Highlight::new(tag); let mut h = Highlight::new(tag);
if local.is_mut(db) || local.ty(db).is_mutable_reference() { 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) { if local.ty(db).as_callable(db).is_some() || local.ty(db).impls_fnonce(db) {
h |= HighlightModifier::Callable; h |= HlMod::Callable;
} }
return h; return h;
} }
Definition::LifetimeParam(_) => HighlightTag::Symbol(SymbolKind::LifetimeParam), Definition::LifetimeParam(_) => HlTag::Symbol(SymbolKind::LifetimeParam),
Definition::Label(_) => HighlightTag::Symbol(SymbolKind::Label), Definition::Label(_) => HlTag::Symbol(SymbolKind::Label),
} }
.into() .into()
} }
fn highlight_name_by_syntax(name: ast::Name) -> Highlight { fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
let default = HighlightTag::UnresolvedReference; let default = HlTag::UnresolvedReference;
let parent = match name.syntax().parent() { let parent = match name.syntax().parent() {
Some(it) => it, Some(it) => it,
@ -672,19 +653,19 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
}; };
let tag = match parent.kind() { let tag = match parent.kind() {
STRUCT => HighlightTag::Symbol(SymbolKind::Struct), STRUCT => HlTag::Symbol(SymbolKind::Struct),
ENUM => HighlightTag::Symbol(SymbolKind::Enum), ENUM => HlTag::Symbol(SymbolKind::Enum),
VARIANT => HighlightTag::Symbol(SymbolKind::Variant), VARIANT => HlTag::Symbol(SymbolKind::Variant),
UNION => HighlightTag::Symbol(SymbolKind::Union), UNION => HlTag::Symbol(SymbolKind::Union),
TRAIT => HighlightTag::Symbol(SymbolKind::Trait), TRAIT => HlTag::Symbol(SymbolKind::Trait),
TYPE_ALIAS => HighlightTag::Symbol(SymbolKind::TypeAlias), TYPE_ALIAS => HlTag::Symbol(SymbolKind::TypeAlias),
TYPE_PARAM => HighlightTag::Symbol(SymbolKind::TypeParam), TYPE_PARAM => HlTag::Symbol(SymbolKind::TypeParam),
RECORD_FIELD => HighlightTag::Symbol(SymbolKind::Field), RECORD_FIELD => HlTag::Symbol(SymbolKind::Field),
MODULE => HighlightTag::Symbol(SymbolKind::Module), MODULE => HlTag::Symbol(SymbolKind::Module),
FN => HighlightTag::Symbol(SymbolKind::Function), FN => HlTag::Symbol(SymbolKind::Function),
CONST => HighlightTag::Symbol(SymbolKind::Const), CONST => HlTag::Symbol(SymbolKind::Const),
STATIC => HighlightTag::Symbol(SymbolKind::Static), STATIC => HlTag::Symbol(SymbolKind::Static),
IDENT_PAT => HighlightTag::Symbol(SymbolKind::Local), IDENT_PAT => HlTag::Symbol(SymbolKind::Local),
_ => default, _ => default,
}; };
@ -692,7 +673,7 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
} }
fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabase>) -> 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() { let parent = match name.syntax().parent() {
Some(it) => it, Some(it) => it,
@ -703,10 +684,10 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
METHOD_CALL_EXPR => { METHOD_CALL_EXPR => {
return ast::MethodCallExpr::cast(parent) return ast::MethodCallExpr::cast(parent)
.and_then(|method_call| highlight_method_call(sema, &method_call)) .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 => { FIELD_EXPR => {
let h = HighlightTag::Symbol(SymbolKind::Field); let h = HlTag::Symbol(SymbolKind::Field);
let is_union = ast::FieldExpr::cast(parent) let is_union = ast::FieldExpr::cast(parent)
.and_then(|field_expr| { .and_then(|field_expr| {
let field = sema.resolve_field(&field_expr)?; let field = sema.resolve_field(&field_expr)?;
@ -718,7 +699,7 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
}) })
.unwrap_or(false); .unwrap_or(false);
if is_union { if is_union {
h | HighlightModifier::Unsafe h | HlMod::Unsafe
} else { } else {
h.into() h.into()
} }
@ -733,9 +714,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 // 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() { return if name.text().chars().next().unwrap_or_default().is_uppercase() {
HighlightTag::Symbol(SymbolKind::Struct) HlTag::Symbol(SymbolKind::Struct)
} else { } else {
HighlightTag::Symbol(SymbolKind::Module) HlTag::Symbol(SymbolKind::Module)
} }
.into(); .into();
} }
@ -746,11 +727,11 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
}; };
match parent.kind() { 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() { _ => if name.text().chars().next().unwrap_or_default().is_uppercase() {
HighlightTag::Symbol(SymbolKind::Struct) HlTag::Symbol(SymbolKind::Struct)
} else { } else {
HighlightTag::Symbol(SymbolKind::Const) HlTag::Symbol(SymbolKind::Const)
} }
.into(), .into(),
} }

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

@ -4,7 +4,7 @@ use syntax::{
AstNode, AstToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange, AstNode, AstToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange,
}; };
use crate::{HighlightTag, HighlightedRange, SymbolKind}; use crate::{HighlightedRange, HlTag, SymbolKind};
use super::highlights::Highlights; use super::highlights::Highlights;
@ -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 { Some(match kind {
FormatSpecifier::Open FormatSpecifier::Open
| FormatSpecifier::Close | FormatSpecifier::Close
@ -69,8 +69,8 @@ fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HighlightTag> {
| FormatSpecifier::DollarSign | FormatSpecifier::DollarSign
| FormatSpecifier::Dot | FormatSpecifier::Dot
| FormatSpecifier::Asterisk | FormatSpecifier::Asterisk
| FormatSpecifier::QuestionMark => HighlightTag::FormatSpecifier, | FormatSpecifier::QuestionMark => HlTag::FormatSpecifier,
FormatSpecifier::Integer | FormatSpecifier::Zero => HighlightTag::NumericLiteral, FormatSpecifier::Integer | FormatSpecifier::Zero => HlTag::NumericLiteral,
FormatSpecifier::Identifier => HighlightTag::Symbol(SymbolKind::Local), FormatSpecifier::Identifier => HlTag::Symbol(SymbolKind::Local),
}) })
} }

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

@ -4,7 +4,7 @@ use std::{cmp::Ordering, iter};
use stdx::equal_range_by; use stdx::equal_range_by;
use syntax::TextRange; use syntax::TextRange;
use crate::{HighlightTag, HighlightedRange}; use crate::{HighlightedRange, HlTag};
pub(super) struct Highlights { pub(super) struct Highlights {
root: Node, root: Node,
@ -20,7 +20,7 @@ impl Highlights {
Highlights { Highlights {
root: Node::new(HighlightedRange { root: Node::new(HighlightedRange {
range, range,
highlight: HighlightTag::None.into(), highlight: HlTag::None.into(),
binding_hash: None, binding_hash: None,
}), }),
} }

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

@ -7,7 +7,7 @@ use ide_db::call_info::ActiveParameter;
use itertools::Itertools; use itertools::Itertools;
use syntax::{ast, AstToken, SyntaxNode, SyntaxToken, TextRange, TextSize}; use syntax::{ast, AstToken, SyntaxNode, SyntaxToken, TextRange, TextSize};
use crate::{Analysis, HighlightModifier, HighlightTag, HighlightedRange, RootDatabase}; use crate::{Analysis, HighlightedRange, HlMod, HlTag, RootDatabase};
use super::{highlights::Highlights, injector::Injector}; use super::{highlights::Highlights, injector::Injector};
@ -28,7 +28,7 @@ pub(super) fn highlight_injection(
if let Some(range) = literal.open_quote_text_range() { if let Some(range) = literal.open_quote_text_range() {
acc.add(HighlightedRange { acc.add(HighlightedRange {
range, range,
highlight: HighlightTag::StringLiteral.into(), highlight: HlTag::StringLiteral.into(),
binding_hash: None, binding_hash: None,
}) })
} }
@ -44,7 +44,7 @@ pub(super) fn highlight_injection(
if let Some(range) = literal.close_quote_text_range() { if let Some(range) = literal.close_quote_text_range() {
acc.add(HighlightedRange { acc.add(HighlightedRange {
range, range,
highlight: HighlightTag::StringLiteral.into(), highlight: HlTag::StringLiteral.into(),
binding_hash: None, binding_hash: None,
}) })
} }
@ -171,7 +171,7 @@ pub(super) fn extract_doc_comments(node: &SyntaxNode) -> Option<(Vec<Highlighted
range.start(), range.start(),
range.start() + TextSize::try_from(pos).unwrap(), range.start() + TextSize::try_from(pos).unwrap(),
), ),
highlight: HighlightTag::Comment | HighlightModifier::Documentation, highlight: HlTag::Comment | HlMod::Documentation,
binding_hash: None, binding_hash: None,
}); });
line_start += range.len() - TextSize::try_from(pos).unwrap(); line_start += range.len() - TextSize::try_from(pos).unwrap();
@ -209,7 +209,7 @@ pub(super) fn highlight_doc_comment(
for r in inj.map_range_up(h.range) { for r in inj.map_range_up(h.range) {
stack.add(HighlightedRange { stack.add(HighlightedRange {
range: r, range: r,
highlight: h.highlight | HighlightModifier::Injected, highlight: h.highlight | HlMod::Injected,
binding_hash: h.binding_hash, binding_hash: h.binding_hash,
}); });
} }

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

@ -1,7 +1,7 @@
//! Syntax highlighting for macro_rules!. //! Syntax highlighting for macro_rules!.
use syntax::{SyntaxElement, SyntaxKind, SyntaxToken, TextRange, T}; use syntax::{SyntaxElement, SyntaxKind, SyntaxToken, TextRange, T};
use crate::{HighlightTag, HighlightedRange}; use crate::{HighlightedRange, HlTag};
#[derive(Default)] #[derive(Default)]
pub(super) struct MacroRulesHighlighter { pub(super) struct MacroRulesHighlighter {
@ -25,7 +25,7 @@ impl MacroRulesHighlighter {
if let Some(range) = is_metavariable(element) { if let Some(range) = is_metavariable(element) {
return Some(HighlightedRange { return Some(HighlightedRange {
range, range,
highlight: HighlightTag::UnresolvedReference.into(), highlight: HlTag::UnresolvedReference.into(),
binding_hash: None, binding_hash: None,
}); });
} }

134
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)] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Highlight { pub struct Highlight {
pub tag: HighlightTag, pub tag: HlTag,
pub modifiers: HighlightModifiers, pub mods: HlMods,
} }
#[derive(Default, Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] #[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)] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum HighlightTag { pub enum HlTag {
Symbol(SymbolKind), Symbol(SymbolKind),
BoolLiteral, BoolLiteral,
@ -39,7 +39,7 @@ pub enum HighlightTag {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[repr(u8)] #[repr(u8)]
pub enum HighlightModifier { pub enum HlMod {
/// Used to differentiate individual elements within attributes. /// Used to differentiate individual elements within attributes.
Attribute = 0, Attribute = 0,
/// Used with keywords like `if` and `break`. /// Used with keywords like `if` and `break`.
@ -61,10 +61,10 @@ pub enum HighlightModifier {
Unsafe, Unsafe,
} }
impl HighlightTag { impl HlTag {
fn as_str(self) -> &'static str { fn as_str(self) -> &'static str {
match self { match self {
HighlightTag::Symbol(symbol) => match symbol { HlTag::Symbol(symbol) => match symbol {
SymbolKind::Const => "constant", SymbolKind::Const => "constant",
SymbolKind::Static => "static", SymbolKind::Static => "static",
SymbolKind::Enum => "enum", SymbolKind::Enum => "enum",
@ -86,59 +86,59 @@ impl HighlightTag {
SymbolKind::SelfParam => "self_keyword", SymbolKind::SelfParam => "self_keyword",
SymbolKind::Impl => "self_type", SymbolKind::Impl => "self_type",
}, },
HighlightTag::Attribute => "attribute", HlTag::Attribute => "attribute",
HighlightTag::BoolLiteral => "bool_literal", HlTag::BoolLiteral => "bool_literal",
HighlightTag::BuiltinType => "builtin_type", HlTag::BuiltinType => "builtin_type",
HighlightTag::ByteLiteral => "byte_literal", HlTag::ByteLiteral => "byte_literal",
HighlightTag::CharLiteral => "char_literal", HlTag::CharLiteral => "char_literal",
HighlightTag::Comment => "comment", HlTag::Comment => "comment",
HighlightTag::EscapeSequence => "escape_sequence", HlTag::EscapeSequence => "escape_sequence",
HighlightTag::FormatSpecifier => "format_specifier", HlTag::FormatSpecifier => "format_specifier",
HighlightTag::Keyword => "keyword", HlTag::Keyword => "keyword",
HighlightTag::Punctuation => "punctuation", HlTag::Punctuation => "punctuation",
HighlightTag::NumericLiteral => "numeric_literal", HlTag::NumericLiteral => "numeric_literal",
HighlightTag::Operator => "operator", HlTag::Operator => "operator",
HighlightTag::StringLiteral => "string_literal", HlTag::StringLiteral => "string_literal",
HighlightTag::UnresolvedReference => "unresolved_reference", HlTag::UnresolvedReference => "unresolved_reference",
HighlightTag::None => "none", HlTag::None => "none",
} }
} }
} }
impl fmt::Display for HighlightTag { impl fmt::Display for HlTag {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(self.as_str(), f) fmt::Display::fmt(self.as_str(), f)
} }
} }
impl HighlightModifier { impl HlMod {
const ALL: &'static [HighlightModifier; HighlightModifier::Unsafe as u8 as usize + 1] = &[ const ALL: &'static [HlMod; HlMod::Unsafe as u8 as usize + 1] = &[
HighlightModifier::Attribute, HlMod::Attribute,
HighlightModifier::ControlFlow, HlMod::ControlFlow,
HighlightModifier::Definition, HlMod::Definition,
HighlightModifier::Documentation, HlMod::Documentation,
HighlightModifier::Injected, HlMod::Injected,
HighlightModifier::Mutable, HlMod::Mutable,
HighlightModifier::Consuming, HlMod::Consuming,
HighlightModifier::Callable, HlMod::Callable,
HighlightModifier::Static, HlMod::Static,
HighlightModifier::Associated, HlMod::Associated,
HighlightModifier::Unsafe, HlMod::Unsafe,
]; ];
fn as_str(self) -> &'static str { fn as_str(self) -> &'static str {
match self { match self {
HighlightModifier::Attribute => "attribute", HlMod::Attribute => "attribute",
HighlightModifier::ControlFlow => "control", HlMod::ControlFlow => "control",
HighlightModifier::Definition => "declaration", HlMod::Definition => "declaration",
HighlightModifier::Documentation => "documentation", HlMod::Documentation => "documentation",
HighlightModifier::Injected => "injected", HlMod::Injected => "injected",
HighlightModifier::Mutable => "mutable", HlMod::Mutable => "mutable",
HighlightModifier::Consuming => "consuming", HlMod::Consuming => "consuming",
HighlightModifier::Unsafe => "unsafe", HlMod::Unsafe => "unsafe",
HighlightModifier::Callable => "callable", HlMod::Callable => "callable",
HighlightModifier::Static => "static", HlMod::Static => "static",
HighlightModifier::Associated => "associated", 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 { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(self.as_str(), f) fmt::Display::fmt(self.as_str(), f)
} }
@ -156,63 +156,63 @@ impl fmt::Display for HighlightModifier {
impl fmt::Display for Highlight { impl fmt::Display for Highlight {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.tag)?; write!(f, "{}", self.tag)?;
for modifier in self.modifiers.iter() { for modifier in self.mods.iter() {
write!(f, ".{}", modifier)? write!(f, ".{}", modifier)?
} }
Ok(()) Ok(())
} }
} }
impl From<HighlightTag> for Highlight { impl From<HlTag> for Highlight {
fn from(tag: HighlightTag) -> Highlight { fn from(tag: HlTag) -> Highlight {
Highlight::new(tag) Highlight::new(tag)
} }
} }
impl Highlight { impl Highlight {
pub(crate) fn new(tag: HighlightTag) -> Highlight { pub(crate) fn new(tag: HlTag) -> Highlight {
Highlight { tag, modifiers: HighlightModifiers::default() } Highlight { tag, mods: HlMods::default() }
} }
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
self.tag == HighlightTag::None && 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; type Output = Highlight;
fn bitor(self, rhs: HighlightModifier) -> Highlight { fn bitor(self, rhs: HlMod) -> Highlight {
Highlight::new(self) | rhs Highlight::new(self) | rhs
} }
} }
impl ops::BitOrAssign<HighlightModifier> for HighlightModifiers { impl ops::BitOrAssign<HlMod> for HlMods {
fn bitor_assign(&mut self, rhs: HighlightModifier) { fn bitor_assign(&mut self, rhs: HlMod) {
self.0 |= rhs.mask(); self.0 |= rhs.mask();
} }
} }
impl ops::BitOrAssign<HighlightModifier> for Highlight { impl ops::BitOrAssign<HlMod> for Highlight {
fn bitor_assign(&mut self, rhs: HighlightModifier) { fn bitor_assign(&mut self, rhs: HlMod) {
self.modifiers |= rhs; self.mods |= rhs;
} }
} }
impl ops::BitOr<HighlightModifier> for Highlight { impl ops::BitOr<HlMod> for Highlight {
type Output = Highlight; type Output = Highlight;
fn bitor(mut self, rhs: HighlightModifier) -> Highlight { fn bitor(mut self, rhs: HlMod) -> Highlight {
self |= rhs; self |= rhs;
self self
} }
} }
impl HighlightModifiers { impl HlMods {
pub fn contains(self, m: HighlightModifier) -> bool { pub fn contains(self, m: HlMod) -> bool {
self.0 & m.mask() == m.mask() self.0 & m.mask() == m.mask()
} }
pub fn iter(self) -> impl Iterator<Item = HighlightModifier> { pub fn iter(self) -> impl Iterator<Item = HlMod> {
HighlightModifier::ALL.iter().copied().filter(move |it| self.0 & it.mask() == it.mask()) HlMod::ALL.iter().copied().filter(move |it| self.0 & it.mask() == it.mask())
} }
} }

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

@ -6,10 +6,9 @@ use std::{
use ide::{ use ide::{
Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind, Documentation, FileId, Assist, AssistKind, CallInfo, CompletionItem, CompletionItemKind, Documentation, FileId,
FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HighlightModifier, HighlightTag, FileRange, FileSystemEdit, Fold, FoldKind, Highlight, HighlightedRange, HlMod, HlTag, Indel,
HighlightedRange, Indel, InlayHint, InlayKind, InsertTextFormat, LineIndex, Markup, InlayHint, InlayKind, InsertTextFormat, LineIndex, Markup, NavigationTarget, ReferenceAccess,
NavigationTarget, ReferenceAccess, Runnable, Severity, SourceChange, SourceFileEdit, Runnable, Severity, SourceChange, SourceFileEdit, SymbolKind, TextEdit, TextRange, TextSize,
SymbolKind, TextEdit, TextRange, TextSize,
}; };
use itertools::Itertools; use itertools::Itertools;
@ -377,7 +376,7 @@ fn semantic_token_type_and_modifiers(
) -> (lsp_types::SemanticTokenType, semantic_tokens::ModifierSet) { ) -> (lsp_types::SemanticTokenType, semantic_tokens::ModifierSet) {
let mut mods = semantic_tokens::ModifierSet::default(); let mut mods = semantic_tokens::ModifierSet::default();
let type_ = match highlight.tag { let type_ = match highlight.tag {
HighlightTag::Symbol(symbol) => match symbol { HlTag::Symbol(symbol) => match symbol {
SymbolKind::Module => lsp_types::SemanticTokenType::NAMESPACE, SymbolKind::Module => lsp_types::SemanticTokenType::NAMESPACE,
SymbolKind::Impl => lsp_types::SemanticTokenType::TYPE, SymbolKind::Impl => lsp_types::SemanticTokenType::TYPE,
SymbolKind::Field => lsp_types::SemanticTokenType::PROPERTY, SymbolKind::Field => lsp_types::SemanticTokenType::PROPERTY,
@ -389,7 +388,7 @@ fn semantic_token_type_and_modifiers(
SymbolKind::SelfParam => semantic_tokens::SELF_KEYWORD, SymbolKind::SelfParam => semantic_tokens::SELF_KEYWORD,
SymbolKind::Local => lsp_types::SemanticTokenType::VARIABLE, SymbolKind::Local => lsp_types::SemanticTokenType::VARIABLE,
SymbolKind::Function => { SymbolKind::Function => {
if highlight.modifiers.contains(HighlightModifier::Associated) { if highlight.mods.contains(HlMod::Associated) {
lsp_types::SemanticTokenType::METHOD lsp_types::SemanticTokenType::METHOD
} else { } else {
lsp_types::SemanticTokenType::FUNCTION lsp_types::SemanticTokenType::FUNCTION
@ -412,38 +411,34 @@ fn semantic_token_type_and_modifiers(
SymbolKind::Trait => lsp_types::SemanticTokenType::INTERFACE, SymbolKind::Trait => lsp_types::SemanticTokenType::INTERFACE,
SymbolKind::Macro => lsp_types::SemanticTokenType::MACRO, SymbolKind::Macro => lsp_types::SemanticTokenType::MACRO,
}, },
HighlightTag::BuiltinType => semantic_tokens::BUILTIN_TYPE, HlTag::BuiltinType => semantic_tokens::BUILTIN_TYPE,
HighlightTag::None => semantic_tokens::GENERIC, HlTag::None => semantic_tokens::GENERIC,
HighlightTag::ByteLiteral | HighlightTag::NumericLiteral => { HlTag::ByteLiteral | HlTag::NumericLiteral => lsp_types::SemanticTokenType::NUMBER,
lsp_types::SemanticTokenType::NUMBER HlTag::BoolLiteral => semantic_tokens::BOOLEAN,
} HlTag::CharLiteral | HlTag::StringLiteral => lsp_types::SemanticTokenType::STRING,
HighlightTag::BoolLiteral => semantic_tokens::BOOLEAN, HlTag::Comment => lsp_types::SemanticTokenType::COMMENT,
HighlightTag::CharLiteral | HighlightTag::StringLiteral => { HlTag::Attribute => semantic_tokens::ATTRIBUTE,
lsp_types::SemanticTokenType::STRING HlTag::Keyword => lsp_types::SemanticTokenType::KEYWORD,
} HlTag::UnresolvedReference => semantic_tokens::UNRESOLVED_REFERENCE,
HighlightTag::Comment => lsp_types::SemanticTokenType::COMMENT, HlTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
HighlightTag::Attribute => semantic_tokens::ATTRIBUTE, HlTag::Operator => lsp_types::SemanticTokenType::OPERATOR,
HighlightTag::Keyword => lsp_types::SemanticTokenType::KEYWORD, HlTag::EscapeSequence => semantic_tokens::ESCAPE_SEQUENCE,
HighlightTag::UnresolvedReference => semantic_tokens::UNRESOLVED_REFERENCE, HlTag::Punctuation => semantic_tokens::PUNCTUATION,
HighlightTag::FormatSpecifier => semantic_tokens::FORMAT_SPECIFIER,
HighlightTag::Operator => lsp_types::SemanticTokenType::OPERATOR,
HighlightTag::EscapeSequence => semantic_tokens::ESCAPE_SEQUENCE,
HighlightTag::Punctuation => semantic_tokens::PUNCTUATION,
}; };
for modifier in highlight.modifiers.iter() { for modifier in highlight.mods.iter() {
let modifier = match modifier { let modifier = match modifier {
HighlightModifier::Attribute => semantic_tokens::ATTRIBUTE_MODIFIER, HlMod::Attribute => semantic_tokens::ATTRIBUTE_MODIFIER,
HighlightModifier::Definition => lsp_types::SemanticTokenModifier::DECLARATION, HlMod::Definition => lsp_types::SemanticTokenModifier::DECLARATION,
HighlightModifier::Documentation => lsp_types::SemanticTokenModifier::DOCUMENTATION, HlMod::Documentation => lsp_types::SemanticTokenModifier::DOCUMENTATION,
HighlightModifier::Injected => semantic_tokens::INJECTED, HlMod::Injected => semantic_tokens::INJECTED,
HighlightModifier::ControlFlow => semantic_tokens::CONTROL_FLOW, HlMod::ControlFlow => semantic_tokens::CONTROL_FLOW,
HighlightModifier::Mutable => semantic_tokens::MUTABLE, HlMod::Mutable => semantic_tokens::MUTABLE,
HighlightModifier::Consuming => semantic_tokens::CONSUMING, HlMod::Consuming => semantic_tokens::CONSUMING,
HighlightModifier::Unsafe => semantic_tokens::UNSAFE, HlMod::Unsafe => semantic_tokens::UNSAFE,
HighlightModifier::Callable => semantic_tokens::CALLABLE, HlMod::Callable => semantic_tokens::CALLABLE,
HighlightModifier::Static => lsp_types::SemanticTokenModifier::STATIC, HlMod::Static => lsp_types::SemanticTokenModifier::STATIC,
HighlightModifier::Associated => continue, HlMod::Associated => continue,
}; };
mods |= modifier; mods |= modifier;
} }