X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=crates%2Fhir%2Fsrc%2Fcode_model.rs;h=73ca6ba9f481e5555ea6b6534f7e72839a1a3ae6;hb=eefbae7ed4fca97281bbcd8e5738311be3a31dc6;hp=afe229c32fc8e7121c45732933ff4d0908ad7ad9;hpb=fa65d6ba855fb2da68840b987bfdec258239a59b;p=rust.git diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs index afe229c32fc..73ca6ba9f48 100644 --- a/crates/hir/src/code_model.rs +++ b/crates/hir/src/code_model.rs @@ -161,7 +161,7 @@ pub enum ModuleDef { Function(Function), Adt(Adt), // Can't be directly declared, but can be imported. - EnumVariant(EnumVariant), + Variant(Variant), Const(Const), Static(Static), Trait(Trait), @@ -172,7 +172,7 @@ pub enum ModuleDef { Module, Function, Adt(Struct, Enum, Union), - EnumVariant, + Variant, Const, Static, Trait, @@ -186,7 +186,7 @@ fn from(var: VariantDef) -> Self { match var { VariantDef::Struct(t) => Adt::from(t).into(), VariantDef::Union(t) => Adt::from(t).into(), - VariantDef::EnumVariant(t) => t.into(), + VariantDef::Variant(t) => t.into(), } } } @@ -197,7 +197,7 @@ pub fn module(self, db: &dyn HirDatabase) -> Option { ModuleDef::Module(it) => it.parent(db), ModuleDef::Function(it) => Some(it.module(db)), ModuleDef::Adt(it) => Some(it.module(db)), - ModuleDef::EnumVariant(it) => Some(it.module(db)), + ModuleDef::Variant(it) => Some(it.module(db)), ModuleDef::Const(it) => Some(it.module(db)), ModuleDef::Static(it) => Some(it.module(db)), ModuleDef::Trait(it) => Some(it.module(db)), @@ -221,7 +221,7 @@ pub fn definition_visibility(&self, db: &dyn HirDatabase) -> Option ModuleDef::Module(it) => it.parent(db)?, ModuleDef::Function(it) => return Some(it.visibility(db)), ModuleDef::Adt(it) => it.module(db), - ModuleDef::EnumVariant(it) => { + ModuleDef::Variant(it) => { let parent = it.parent_enum(db); let module = it.module(db); return module.visibility_of(db, &ModuleDef::Adt(Adt::Enum(parent))); @@ -241,7 +241,7 @@ pub fn name(self, db: &dyn HirDatabase) -> Option { ModuleDef::Adt(it) => Some(it.name(db)), ModuleDef::Trait(it) => Some(it.name(db)), ModuleDef::Function(it) => Some(it.name(db)), - ModuleDef::EnumVariant(it) => Some(it.name(db)), + ModuleDef::Variant(it) => Some(it.name(db)), ModuleDef::TypeAlias(it) => Some(it.name(db)), ModuleDef::Module(it) => it.name(db), ModuleDef::Const(it) => it.name(db), @@ -455,7 +455,7 @@ pub fn signature_ty(&self, db: &dyn HirDatabase) -> Type { let generic_def_id: GenericDefId = match self.parent { VariantDef::Struct(it) => it.id.into(), VariantDef::Union(it) => it.id.into(), - VariantDef::EnumVariant(it) => it.parent.id.into(), + VariantDef::Variant(it) => it.parent.id.into(), }; let substs = Substs::type_params(db, generic_def_id); let ty = db.field_types(var_id)[self.id].clone().subst(&substs); @@ -566,12 +566,8 @@ pub fn name(self, db: &dyn HirDatabase) -> Name { db.enum_data(self.id).name.clone() } - pub fn variants(self, db: &dyn HirDatabase) -> Vec { - db.enum_data(self.id) - .variants - .iter() - .map(|(id, _)| EnumVariant { parent: self, id }) - .collect() + pub fn variants(self, db: &dyn HirDatabase) -> Vec { + db.enum_data(self.id).variants.iter().map(|(id, _)| Variant { parent: self, id }).collect() } pub fn ty(self, db: &dyn HirDatabase) -> Type { @@ -580,12 +576,12 @@ pub fn ty(self, db: &dyn HirDatabase) -> Type { } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub struct EnumVariant { +pub struct Variant { pub(crate) parent: Enum, pub(crate) id: LocalEnumVariantId, } -impl EnumVariant { +impl Variant { pub fn module(self, db: &dyn HirDatabase) -> Module { self.parent.module(db) } @@ -662,16 +658,16 @@ pub fn name(self, db: &dyn HirDatabase) -> Name { pub enum VariantDef { Struct(Struct), Union(Union), - EnumVariant(EnumVariant), + Variant(Variant), } -impl_from!(Struct, Union, EnumVariant for VariantDef); +impl_from!(Struct, Union, Variant for VariantDef); impl VariantDef { pub fn fields(self, db: &dyn HirDatabase) -> Vec { match self { VariantDef::Struct(it) => it.fields(db), VariantDef::Union(it) => it.fields(db), - VariantDef::EnumVariant(it) => it.fields(db), + VariantDef::Variant(it) => it.fields(db), } } @@ -679,7 +675,7 @@ pub fn module(self, db: &dyn HirDatabase) -> Module { match self { VariantDef::Struct(it) => it.module(db), VariantDef::Union(it) => it.module(db), - VariantDef::EnumVariant(it) => it.module(db), + VariantDef::Variant(it) => it.module(db), } } @@ -687,7 +683,7 @@ pub fn name(&self, db: &dyn HirDatabase) -> Name { match self { VariantDef::Struct(s) => s.name(db), VariantDef::Union(u) => u.name(db), - VariantDef::EnumVariant(e) => e.name(db), + VariantDef::Variant(e) => e.name(db), } } @@ -695,7 +691,7 @@ pub(crate) fn variant_data(self, db: &dyn HirDatabase) -> Arc { match self { VariantDef::Struct(it) => it.variant_data(db), VariantDef::Union(it) => it.variant_data(db), - VariantDef::EnumVariant(it) => it.variant_data(db), + VariantDef::Variant(it) => it.variant_data(db), } } } @@ -983,6 +979,12 @@ pub fn module(self, db: &dyn HirDatabase) -> Option { /// XXX: this parses the file pub fn name(self, db: &dyn HirDatabase) -> Option { + // FIXME: Currently proc-macro do not have ast-node, + // such that it does not have source + // more discussion: https://github.com/rust-analyzer/rust-analyzer/issues/6913 + if self.is_proc_macro() { + return None; + } self.source(db).value.name().map(|it| it.as_name()) } @@ -1089,7 +1091,7 @@ pub enum GenericDef { Impl(Impl), // enum variants cannot have generics themselves, but their parent enums // can, and this makes some code easier to write - EnumVariant(EnumVariant), + Variant(Variant), // consts can have type parameters from their parents (i.e. associated consts of traits) Const(Const), } @@ -1099,7 +1101,7 @@ pub enum GenericDef { Trait, TypeAlias, Impl, - EnumVariant, + Variant, Const for GenericDef ); @@ -1283,14 +1285,12 @@ pub fn for_trait(db: &dyn HirDatabase, krate: Crate, trait_: Trait) -> Vec impls.for_trait(trait_.id).map(Self::from).collect() } + // FIXME: the return type is wrong. This should be a hir version of + // `TraitRef` (ie, resolved `TypeRef`). pub fn target_trait(self, db: &dyn HirDatabase) -> Option { db.impl_data(self.id).target_trait.clone() } - pub fn target_type(self, db: &dyn HirDatabase) -> TypeRef { - db.impl_data(self.id).target_type.clone() - } - pub fn target_ty(self, db: &dyn HirDatabase) -> Type { let impl_data = db.impl_data(self.id); let resolver = self.id.resolver(db.upcast()); @@ -1324,6 +1324,7 @@ pub fn is_builtin_derive(self, db: &dyn HirDatabase) -> Option let item = src.file_id.is_builtin_derive(db.upcast())?; let hygenic = hir_expand::hygiene::Hygiene::new(db.upcast(), item.file_id); + // FIXME: handle `cfg_attr` let attr = item .value .attrs() @@ -1841,7 +1842,7 @@ pub struct Callable { pub enum CallableKind { Function(Function), TupleStruct(Struct), - TupleEnumVariant(EnumVariant), + TupleEnumVariant(Variant), Closure, }