Merge #6921

[rust.git] / crates / hir / src / code_model.rs

diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index afe229c32fc8e7121c45732933ff4d0908ad7ad9..73ca6ba9f481e5555ea6b6534f7e72839a1a3ae6 100644 (file)
--- 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<Module> {
             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<Visibility>
             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<Name> {
             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<EnumVariant> {
-        db.enum_data(self.id)
-            .variants
-            .iter()
-            .map(|(id, _)| EnumVariant { parent: self, id })
-            .collect()
+    pub fn variants(self, db: &dyn HirDatabase) -> Vec<Variant> {
+        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<Field> {
         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<VariantData> {
         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<Module> {
 
     /// XXX: this parses the file
     pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
+        // 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<Impl>
         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<TypeRef> {
         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<InFile<ast::Attr>
         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,
 }