binding_hash: None,
});
}
+ if let Some(name) = mc.is_macro_rules() {
+ if let Some((highlight, binding_hash)) = highlight_element(
+ &sema,
+ &mut bindings_shadow_count,
+ name.syntax().clone().into(),
+ ) {
+ stack.add(HighlightedRange {
+ range: name.syntax().text_range(),
+ highlight,
+ binding_hash,
+ });
+ }
+ }
continue;
}
WalkEvent::Leave(Some(mc)) => {
| FormatSpecifier::DollarSign
| FormatSpecifier::Dot
| FormatSpecifier::Asterisk
- | FormatSpecifier::QuestionMark => HighlightTag::Attribute,
+ | FormatSpecifier::QuestionMark => HighlightTag::FormatSpecifier,
FormatSpecifier::Integer | FormatSpecifier::Zero => HighlightTag::NumericLiteral,
FormatSpecifier::Identifier => HighlightTag::Local,
})
}
// Highlight references like the definitions they resolve to
- NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => return None,
+ NAME_REF if element.ancestors().any(|it| it.kind() == ATTR) => {
+ Highlight::from(HighlightTag::Function) | HighlightModifier::Attribute
+ }
NAME_REF => {
let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
match classify_name_ref(sema, &name_ref) {
T![break]
| T![continue]
| T![else]
- | T![for]
| T![if]
| T![loop]
| T![match]
| T![return]
- | T![while] => h | HighlightModifier::ControlFlow,
+ | 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![self] => HighlightTag::SelfKeyword.into(),
_ => h,
}
}
}
}
+fn is_child_of_impl(element: SyntaxElement) -> bool {
+ match element.parent() {
+ Some(e) => e.kind() == IMPL_DEF,
+ _ => false,
+ }
+}
+
fn highlight_name(db: &RootDatabase, def: Definition) -> Highlight {
match def {
Definition::Macro(_) => HighlightTag::Macro,
hir::ModuleDef::Adt(hir::Adt::Union(_)) => HighlightTag::Union,
hir::ModuleDef::EnumVariant(_) => HighlightTag::EnumVariant,
hir::ModuleDef::Const(_) => HighlightTag::Constant,
- hir::ModuleDef::Static(_) => HighlightTag::Static,
hir::ModuleDef::Trait(_) => HighlightTag::Trait,
hir::ModuleDef::TypeAlias(_) => HighlightTag::TypeAlias,
hir::ModuleDef::BuiltinType(_) => HighlightTag::BuiltinType,
+ hir::ModuleDef::Static(s) => {
+ let mut h = Highlight::new(HighlightTag::Static);
+ if s.is_mut(db) {
+ h |= HighlightModifier::Mutable;
+ }
+ return h;
+ }
},
Definition::SelfType(_) => HighlightTag::SelfType,
Definition::TypeParam(_) => HighlightTag::TypeParam,
}
fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
- let default = HighlightTag::Function.into();
+ let default = HighlightTag::UnresolvedReference;
let parent = match name.syntax().parent() {
Some(it) => it,
- _ => return default,
+ _ => return default.into(),
};
- match parent.kind() {
- STRUCT_DEF => HighlightTag::Struct.into(),
- ENUM_DEF => HighlightTag::Enum.into(),
- UNION_DEF => HighlightTag::Union.into(),
- TRAIT_DEF => HighlightTag::Trait.into(),
- TYPE_ALIAS_DEF => HighlightTag::TypeAlias.into(),
- TYPE_PARAM => HighlightTag::TypeParam.into(),
- RECORD_FIELD_DEF => HighlightTag::Field.into(),
+ let tag = match parent.kind() {
+ STRUCT_DEF => HighlightTag::Struct,
+ ENUM_DEF => HighlightTag::Enum,
+ UNION_DEF => HighlightTag::Union,
+ TRAIT_DEF => HighlightTag::Trait,
+ TYPE_ALIAS_DEF => HighlightTag::TypeAlias,
+ TYPE_PARAM => HighlightTag::TypeParam,
+ RECORD_FIELD_DEF => HighlightTag::Field,
+ MODULE => HighlightTag::Module,
+ FN_DEF => HighlightTag::Function,
+ CONST_DEF => HighlightTag::Constant,
+ STATIC_DEF => HighlightTag::Static,
+ ENUM_VARIANT => HighlightTag::EnumVariant,
+ BIND_PAT => HighlightTag::Local,
_ => default,
- }
+ };
+
+ tag.into()
}
fn highlight_injection(