references::{rename::RenameError, Declaration, ReferenceSearchResult},
runnables::{Runnable, RunnableKind, TestId},
syntax_highlighting::{
- tags::{Highlight, HighlightModifier, HighlightModifiers, HighlightTag},
+ tags::{Highlight, HlMod, HlMods, HlTag},
HighlightedRange,
},
};
syntax_highlighting::{
format::FormatStringHighlighter, macro_rules::MacroRulesHighlighter, tags::Highlight,
},
- FileId, HighlightModifier, HighlightTag, SymbolKind,
+ FileId, HlMod, HlTag, SymbolKind,
};
pub(crate) use html::highlight_as_html;
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,
});
}
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() {
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,
});
}
};
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,
}
}
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) {
if let Definition::Local(local) = &def {
if is_consumed_lvalue(name_ref.syntax().clone().into(), local, db) {
- h |= HighlightModifier::Consuming;
+ h |= HlMod::Consuming;
}
}
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;
}
}
}
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(),
}
})
}
// 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)?;
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() => {
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()
- }
- _ 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()
+ HlTag::Operator.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]
| 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()
.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))
&& (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;
}
}
.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
}
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
}
}
}
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,
};
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,
};
}
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,
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)?;
})
.unwrap_or(false);
if is_union {
- h | HighlightModifier::Unsafe
+ h | HlMod::Unsafe
} else {
h.into()
}
_ => {
// 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();
}
};
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(),
}
AstNode, AstToken, SyntaxElement, SyntaxKind, SyntaxNode, TextRange,
};
-use crate::{HighlightTag, HighlightedRange, SymbolKind};
+use crate::{HighlightedRange, HlTag, SymbolKind};
use super::highlights::Highlights;
}
}
-fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HighlightTag> {
+fn highlight_format_specifier(kind: FormatSpecifier) -> Option<HlTag> {
Some(match kind {
FormatSpecifier::Open
| FormatSpecifier::Close
| 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),
})
}
use stdx::equal_range_by;
use syntax::TextRange;
-use crate::{HighlightTag, HighlightedRange};
+use crate::{HighlightedRange, HlTag};
pub(super) struct Highlights {
root: Node,
Highlights {
root: Node::new(HighlightedRange {
range,
- highlight: HighlightTag::None.into(),
+ highlight: HlTag::None.into(),
binding_hash: None,
}),
}
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};
if let Some(range) = literal.open_quote_text_range() {
acc.add(HighlightedRange {
range,
- highlight: HighlightTag::StringLiteral.into(),
+ highlight: HlTag::StringLiteral.into(),
binding_hash: None,
})
}
if let Some(range) = literal.close_quote_text_range() {
acc.add(HighlightedRange {
range,
- highlight: HighlightTag::StringLiteral.into(),
+ highlight: HlTag::StringLiteral.into(),
binding_hash: None,
})
}
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();
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,
});
}
//! 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 {
if let Some(range) = is_metavariable(element) {
return Some(HighlightedRange {
range,
- highlight: HighlightTag::UnresolvedReference.into(),
+ highlight: HlTag::UnresolvedReference.into(),
binding_hash: None,
});
}
#[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,
#[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`.
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",
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",
}
}
}
}
-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)
}
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())
}
}
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;
) -> (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,
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
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;
}
projects / rust.git / commitdiff