Function(Function),
Adt(Adt),
// Can't be directly declared, but can be imported.
- EnumVariant(EnumVariant),
+ Variant(Variant),
Const(Const),
Static(Static),
Trait(Trait),
Module,
Function,
Adt(Struct, Enum, Union),
- EnumVariant,
+ Variant,
Const,
Static,
Trait,
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(),
}
}
}
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)),
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)));
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),
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);
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 {
}
#[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)
}
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),
}
}
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),
}
}
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),
}
}
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),
}
}
}
/// 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())
}
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),
}
Trait,
TypeAlias,
Impl,
- EnumVariant,
+ Variant,
Const
for GenericDef
);
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());
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()
pub enum CallableKind {
Function(Function),
TupleStruct(Struct),
- TupleEnumVariant(EnumVariant),
+ TupleEnumVariant(Variant),
Closure,
}