#[cfg(test)]
mod tests;
-use hir::{Name, Semantics};
+use hir::{Name, Semantics, VariantDef};
use ra_ide_db::{
defs::{classify_name, classify_name_ref, Definition, NameClass, NameRefClass},
RootDatabase,
Some(TextRange::new(range_start, range_end))
}
+fn is_possibly_unsafe(name_ref: &ast::NameRef) -> bool {
+ name_ref
+ .syntax()
+ .parent()
+ .and_then(|parent| {
+ ast::FieldExpr::cast(parent.clone())
+ .map(|_| true)
+ .or_else(|| ast::RecordPatField::cast(parent).map(|_| true))
+ })
+ .unwrap_or(false)
+}
+
fn highlight_element(
sema: &Semantics<RootDatabase>,
bindings_shadow_count: &mut FxHashMap<Name, u32>,
let db = sema.db;
let mut binding_hash = None;
let highlight: Highlight = match element.kind() {
- FN_DEF => {
+ FN => {
bindings_shadow_count.clear();
return None;
}
};
match name_kind {
+ Some(NameClass::ExternCrate(_)) => HighlightTag::Module.into(),
Some(NameClass::Definition(def)) => {
- highlight_name(db, def) | HighlightModifier::Definition
+ highlight_name(db, def, false) | HighlightModifier::Definition
+ }
+ Some(NameClass::ConstReference(def)) => highlight_name(db, def, false),
+ Some(NameClass::FieldShorthand { field, .. }) => {
+ let mut h = HighlightTag::Field.into();
+ if let Definition::Field(field) = field {
+ if let VariantDef::Union(_) = field.parent_def(db) {
+ h |= HighlightModifier::Unsafe;
+ }
+ }
+
+ h
}
- Some(NameClass::ConstReference(def)) => highlight_name(db, def),
- Some(NameClass::FieldShorthand { .. }) => HighlightTag::Field.into(),
None => highlight_name_by_syntax(name) | HighlightModifier::Definition,
}
}
}
NAME_REF => {
let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
+ let possibly_unsafe = is_possibly_unsafe(&name_ref);
match classify_name_ref(sema, &name_ref) {
Some(name_kind) => match name_kind {
+ NameRefClass::ExternCrate(_) => HighlightTag::Module.into(),
NameRefClass::Definition(def) => {
if let Definition::Local(local) = &def {
if let Some(name) = local.name(db) {
binding_hash = Some(calc_binding_hash(&name, *shadow_count))
}
};
- highlight_name(db, def)
+ highlight_name(db, def, possibly_unsafe)
}
NameRefClass::FieldShorthand { .. } => HighlightTag::Field.into(),
},
- None if syntactic_name_ref_highlighting => highlight_name_ref_by_syntax(name_ref),
+ None if syntactic_name_ref_highlighting => {
+ highlight_name_ref_by_syntax(name_ref, sema)
+ }
None => HighlightTag::UnresolvedReference.into(),
}
}
_ => h,
}
}
+ REF_EXPR => {
+ let ref_expr = element.into_node().and_then(ast::RefExpr::cast)?;
+ let expr = ref_expr.expr()?;
+ let field_expr = match expr {
+ ast::Expr::FieldExpr(fe) => fe,
+ _ => return None,
+ };
+
+ let expr = field_expr.expr()?;
+ let ty = sema.type_of_expr(&expr)?;
+ if !ty.is_packed(db) {
+ return None;
+ }
+
+ // FIXME account for alignment... somehow
+
+ Highlight::new(HighlightTag::Operator) | HighlightModifier::Unsafe
+ }
p if p.is_punct() => match p {
- T![::] | T![->] | T![=>] | T![&] => HighlightTag::Operator.into(),
- T![@] => HighlightTag::Operator | HighlightModifier::ControlFlow,
+ T![::] | T![->] | T![=>] | T![&] | T![..] | T![=] | T![@] => {
+ HighlightTag::Operator.into()
+ }
T![!] if element.parent().and_then(ast::MacroCall::cast).is_some() => {
- Highlight::new(HighlightTag::Macro)
+ HighlightTag::Macro.into()
+ }
+ T![*] if element.parent().and_then(ast::PtrType::cast).is_some() => {
+ HighlightTag::Keyword.into()
}
T![*] if element.parent().and_then(ast::PrefixExpr::cast).is_some() => {
let prefix_expr = element.parent().and_then(ast::PrefixExpr::cast)?;
_ 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()
+ }
_ => HighlightTag::Punctuation.into(),
},
fn is_child_of_impl(element: &SyntaxElement) -> bool {
match element.parent() {
- Some(e) => e.kind() == IMPL_DEF,
+ Some(e) => e.kind() == IMPL,
_ => false,
}
}
-fn highlight_name(db: &RootDatabase, def: Definition) -> Highlight {
+fn highlight_name(db: &RootDatabase, def: Definition, possibly_unsafe: bool) -> Highlight {
match def {
Definition::Macro(_) => HighlightTag::Macro,
- Definition::Field(_) => HighlightTag::Field,
+ Definition::Field(field) => {
+ let mut h = HighlightTag::Field.into();
+ if possibly_unsafe {
+ if let VariantDef::Union(_) = field.parent_def(db) {
+ h |= HighlightModifier::Unsafe;
+ }
+ }
+
+ return h;
+ }
Definition::ModuleDef(def) => match def {
hir::ModuleDef::Module(_) => HighlightTag::Module,
hir::ModuleDef::Function(func) => {
let mut h = Highlight::new(HighlightTag::Static);
if s.is_mut(db) {
h |= HighlightModifier::Mutable;
+ h |= HighlightModifier::Unsafe;
}
return h;
}
};
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,
+ STRUCT => HighlightTag::Struct,
+ ENUM => HighlightTag::Enum,
+ UNION => HighlightTag::Union,
+ TRAIT => HighlightTag::Trait,
+ TYPE_ALIAS => HighlightTag::TypeAlias,
TYPE_PARAM => HighlightTag::TypeParam,
- RECORD_FIELD_DEF => HighlightTag::Field,
+ RECORD_FIELD => 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,
+ FN => HighlightTag::Function,
+ CONST => HighlightTag::Constant,
+ STATIC => HighlightTag::Static,
+ VARIANT => HighlightTag::EnumVariant,
+ IDENT_PAT => HighlightTag::Local,
_ => default,
};
tag.into()
}
-fn highlight_name_ref_by_syntax(name: ast::NameRef) -> Highlight {
+fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabase>) -> Highlight {
let default = HighlightTag::UnresolvedReference;
let parent = match name.syntax().parent() {
let tag = match parent.kind() {
METHOD_CALL_EXPR => HighlightTag::Function,
- FIELD_EXPR => HighlightTag::Field,
+ FIELD_EXPR => {
+ let h = HighlightTag::Field;
+ let is_union = ast::FieldExpr::cast(parent)
+ .and_then(|field_expr| {
+ let field = sema.resolve_field(&field_expr)?;
+ Some(if let VariantDef::Union(_) = field.parent_def(sema.db) {
+ true
+ } else {
+ false
+ })
+ })
+ .unwrap_or(false);
+ return if is_union { h | HighlightModifier::Unsafe } else { h.into() };
+ }
PATH_SEGMENT => {
let path = match parent.parent().and_then(ast::Path::cast) {
Some(it) => it,
projects / rust.git / blobdiff