make various enums "inherit" from AdtDef

2 files changed, 32 insertions, 32 deletions

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<GenericDef> = 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<Struct> for TypableDef {
+    fn from(it: Struct) -> TypableDef {
+        TypableDef::AdtDef(AdtDef::Struct(it))
+    }
+}
+
+impl From<Enum> for TypableDef {
+    fn from(it: Enum) -> TypableDef {
+        TypableDef::AdtDef(AdtDef::Enum(it))
+    }
+}
+
+impl From<Union> for TypableDef {
+    fn from(it: Union) -> TypableDef {
+        TypableDef::AdtDef(AdtDef::Union(it))
+    }
+}
 
 impl From<ModuleDef> for Option<TypableDef> {
     fn from(def: ModuleDef) -> Option<TypableDef> {
         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(),