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},
runnables::{Runnable, RunnableKind, TestId},
syntax_highlighting::{
tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag},
tags::{Highlight, HlMod, HlMods, HlTag},
HighlightedRange,
},
};

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

@ -26,7 +26,7 @@ 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;
@ -98,7 +98,7 @@ pub(crate) fn highlight(
if let Some(range) = macro_call_range(&mc) {
stack.add(HighlightedRange {
range,
highlight: HighlightTag::Symbol(SymbolKind::Macro).into(),
highlight: HlTag::Symbol(SymbolKind::Macro).into(),
binding_hash: None,
});
}
@ -192,7 +192,7 @@ 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() {
@ -209,7 +209,7 @@ pub(crate) fn highlight(
if string.text()[piece_range.start().into()..].starts_with('\\') {
stack.add(HighlightedRange {
range: piece_range + range.start(),
highlight: HighlightTag::EscapeSequence.into(),
highlight: HlTag::EscapeSequence.into(),
binding_hash: None,
});
}
@ -292,22 +292,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 +313,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 +334,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 +342,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 +351,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 +365,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 +419,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 +431,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 +460,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 +476,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 +484,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 +500,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 +549,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 +574,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 +653,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 +673,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 +684,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 +699,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 +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
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 +727,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(),
}

10
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::{HighlightedRange, HlTag, SymbolKind};
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 {
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),
})
}

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 syntax::TextRange;
use crate::{HighlightTag, HighlightedRange};
use crate::{HighlightedRange, HlTag};
pub(super) struct Highlights {
root: Node,
@ -20,7 +20,7 @@ impl Highlights {
Highlights {
root: Node::new(HighlightedRange {
range,
highlight: HighlightTag::None.into(),
highlight: HlTag::None.into(),
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 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};
@ -28,7 +28,7 @@ pub(super) fn highlight_injection(
if let Some(range) = literal.open_quote_text_range() {
acc.add(HighlightedRange {
range,
highlight: HighlightTag::StringLiteral.into(),
highlight: HlTag::StringLiteral.into(),
binding_hash: None,
})
}
@ -44,7 +44,7 @@ pub(super) fn highlight_injection(
if let Some(range) = literal.close_quote_text_range() {
acc.add(HighlightedRange {
range,
highlight: HighlightTag::StringLiteral.into(),
highlight: HlTag::StringLiteral.into(),
binding_hash: None,
})
}
@ -171,7 +171,7 @@ pub(super) fn extract_doc_comments(node: &SyntaxNode) -> Option<(Vec<Highlighted
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();
@ -209,7 +209,7 @@ pub(super) fn highlight_doc_comment(
for r in inj.map_range_up(h.range) {
stack.add(HighlightedRange {
range: r,
highlight: h.highlight | HighlightModifier::Injected,
highlight: h.highlight | HlMod::Injected,
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!.
use syntax::{SyntaxElement, SyntaxKind, SyntaxToken, TextRange, T};
use crate::{HighlightTag, HighlightedRange};
use crate::{HighlightedRange, HlTag};
#[derive(Default)]
pub(super) struct MacroRulesHighlighter {
@ -25,7 +25,7 @@ impl MacroRulesHighlighter {
if let Some(range) = is_metavariable(element) {
return Some(HighlightedRange {
range,
highlight: HighlightTag::UnresolvedReference.into(),
highlight: HlTag::UnresolvedReference.into(),
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)]
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,
@ -39,7 +39,7 @@ pub enum HighlightTag {
#[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::None => "none",
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::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;
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())
}
}

65
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, HighlightedRange, HlMod, HlTag, Indel,
InlayHint, InlayKind, InsertTextFormat, LineIndex, Markup, NavigationTarget, ReferenceAccess,
Runnable, Severity, SourceChange, SourceFileEdit, SymbolKind, TextEdit, TextRange, TextSize,
};
use itertools::Itertools;
@ -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::None => 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;
}