From 45117c63884366ee82102a782a62a09fefff746b Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Fri, 13 Sep 2019 00:10:16 +0300 Subject: make various enums "inherit" from AdtDef --- crates/ra_hir/src/ty/infer.rs | 6 ++--- crates/ra_hir/src/ty/lower.rs | 58 +++++++++++++++++++++---------------------- 2 files changed, 32 insertions(+), 32 deletions(-) (limited to 'crates/ra_hir/src/ty') diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs index 3970c49e3..725eec834 100644 --- a/crates/ra_hir/src/ty/infer.rs +++ b/crates/ra_hir/src/ty/infer.rs @@ -668,7 +668,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { // FIXME remove the duplication between here and `Ty::from_path`? let substs = Ty::substs_from_path(self.db, resolver, path, def); match def { - TypableDef::Struct(s) => { + TypableDef::AdtDef(AdtDef::Struct(s)) => { let ty = s.ty(self.db); let ty = self.insert_type_vars(ty.apply_substs(substs)); (ty, Some(s.into())) @@ -678,10 +678,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> { let ty = self.insert_type_vars(ty.apply_substs(substs)); (ty, Some(var.into())) } - TypableDef::Union(_) + TypableDef::AdtDef(AdtDef::Enum(_)) + | TypableDef::AdtDef(AdtDef::Union(_)) | TypableDef::TypeAlias(_) | TypableDef::Function(_) - | TypableDef::Enum(_) | TypableDef::Const(_) | TypableDef::Static(_) | TypableDef::BuiltinType(_) => (Ty::Unknown, None), diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs index e67525a74..587dc12ee 100644 --- a/crates/ra_hir/src/ty/lower.rs +++ b/crates/ra_hir/src/ty/lower.rs @@ -172,9 +172,7 @@ impl Ty { ) -> Substs { let def_generic: Option = match resolved { TypableDef::Function(func) => Some(func.into()), - TypableDef::Struct(s) => Some(s.into()), - TypableDef::Union(u) => Some(u.into()), - TypableDef::Enum(e) => Some(e.into()), + TypableDef::AdtDef(adt) => Some(adt.into()), TypableDef::EnumVariant(var) => Some(var.parent_enum(db).into()), TypableDef::TypeAlias(t) => Some(t.into()), TypableDef::Const(_) | TypableDef::Static(_) | TypableDef::BuiltinType(_) => None, @@ -193,9 +191,7 @@ impl Ty { let last = path.segments.last().expect("path should have at least one segment"); let segment = match resolved { TypableDef::Function(_) - | TypableDef::Struct(_) - | TypableDef::Union(_) - | TypableDef::Enum(_) + | TypableDef::AdtDef(_) | TypableDef::Const(_) | TypableDef::Static(_) | TypableDef::TypeAlias(_) @@ -410,11 +406,11 @@ fn assoc_type_bindings_from_type_bound<'a>( pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace) -> Ty { match (def, ns) { (TypableDef::Function(f), Namespace::Values) => type_for_fn(db, f), - (TypableDef::Struct(s), Namespace::Types) => type_for_adt(db, s), - (TypableDef::Struct(s), Namespace::Values) => type_for_struct_constructor(db, s), - (TypableDef::Enum(e), Namespace::Types) => type_for_adt(db, e), + (TypableDef::AdtDef(AdtDef::Struct(s)), Namespace::Values) => { + type_for_struct_constructor(db, s) + } + (TypableDef::AdtDef(adt), Namespace::Types) => type_for_adt(db, adt), (TypableDef::EnumVariant(v), Namespace::Values) => type_for_enum_variant_constructor(db, v), - (TypableDef::Union(u), Namespace::Types) => type_for_adt(db, u), (TypableDef::TypeAlias(t), Namespace::Types) => type_for_type_alias(db, t), (TypableDef::Const(c), Namespace::Values) => type_for_const(db, c), (TypableDef::Static(c), Namespace::Values) => type_for_static(db, c), @@ -422,8 +418,8 @@ pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace // 'error' cases: (TypableDef::Function(_), Namespace::Types) => Ty::Unknown, - (TypableDef::Union(_), Namespace::Values) => Ty::Unknown, - (TypableDef::Enum(_), Namespace::Values) => Ty::Unknown, + (TypableDef::AdtDef(AdtDef::Union(_)), Namespace::Values) => Ty::Unknown, + (TypableDef::AdtDef(AdtDef::Enum(_)), Namespace::Values) => Ty::Unknown, (TypableDef::EnumVariant(_), Namespace::Types) => Ty::Unknown, (TypableDef::TypeAlias(_), Namespace::Values) => Ty::Unknown, (TypableDef::Const(_), Namespace::Types) => Ty::Unknown, @@ -608,34 +604,38 @@ fn type_for_type_alias(db: &impl HirDatabase, t: TypeAlias) -> Ty { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum TypableDef { Function(Function), - Struct(Struct), - Union(Union), - Enum(Enum), + AdtDef(AdtDef), EnumVariant(EnumVariant), TypeAlias(TypeAlias), Const(Const), Static(Static), BuiltinType(BuiltinType), } -impl_froms!( - TypableDef: Function, - Struct, - Union, - Enum, - EnumVariant, - TypeAlias, - Const, - Static, - BuiltinType -); +impl_froms!(TypableDef: Function, AdtDef, EnumVariant, TypeAlias, Const, Static, BuiltinType); + +impl From for TypableDef { + fn from(it: Struct) -> TypableDef { + TypableDef::AdtDef(AdtDef::Struct(it)) + } +} + +impl From for TypableDef { + fn from(it: Enum) -> TypableDef { + TypableDef::AdtDef(AdtDef::Enum(it)) + } +} + +impl From for TypableDef { + fn from(it: Union) -> TypableDef { + TypableDef::AdtDef(AdtDef::Union(it)) + } +} impl From for Option { fn from(def: ModuleDef) -> Option { let res = match def { ModuleDef::Function(f) => f.into(), - ModuleDef::Struct(s) => s.into(), - ModuleDef::Union(u) => u.into(), - ModuleDef::Enum(e) => e.into(), + ModuleDef::AdtDef(adt) => adt.into(), ModuleDef::EnumVariant(v) => v.into(), ModuleDef::TypeAlias(t) => t.into(), ModuleDef::Const(v) => v.into(), -- cgit v1.2.3