make various enums "inherit" from AdtDef

crates/ra_hir/src/code_model.rs

@@ -127,9 +127,7 @@ impl BuiltinType {
 pub enum ModuleDef {
     Module(Module),
     Function(Function),
-    Struct(Struct),
-    Union(Union),
-    Enum(Enum),
+    AdtDef(AdtDef),
     // Can't be directly declared, but can be imported.
     EnumVariant(EnumVariant),
     Const(Const),
@@ -141,9 +139,7 @@ pub enum ModuleDef {
 impl_froms!(
     ModuleDef: Module,
     Function,
-    Struct,
-    Union,
-    Enum,
+    AdtDef,
     EnumVariant,
     Const,
     Static,
@@ -152,6 +148,24 @@ impl_froms!(
     BuiltinType
 );
 
+impl From<Struct> for ModuleDef {
+    fn from(it: Struct) -> ModuleDef {
+        ModuleDef::AdtDef(AdtDef::Struct(it))
+    }
+}
+
+impl From<Enum> for ModuleDef {
+    fn from(it: Enum) -> ModuleDef {
+        ModuleDef::AdtDef(AdtDef::Enum(it))
+    }
+}
+
+impl From<Union> for ModuleDef {
+    fn from(it: Union) -> ModuleDef {
+        ModuleDef::AdtDef(AdtDef::Union(it))
+    }
+}
+
 pub enum ModuleSource {
     SourceFile(ast::SourceFile),
     Module(ast::Module),
@@ -500,6 +514,41 @@ impl EnumVariant {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum AdtDef {
+    Struct(Struct),
+    Union(Union),
+    Enum(Enum),
+}
+impl_froms!(AdtDef: Struct, Union, Enum);
+
+impl AdtDef {
+    pub fn ty(self, db: &impl HirDatabase) -> Ty {
+        match self {
+            AdtDef::Struct(it) => it.ty(db),
+            AdtDef::Union(it) => it.ty(db),
+            AdtDef::Enum(it) => it.ty(db),
+        }
+    }
+
+    pub(crate) fn krate(self, db: &impl HirDatabase) -> Option<Crate> {
+        match self {
+            AdtDef::Struct(s) => s.module(db),
+            AdtDef::Union(s) => s.module(db),
+            AdtDef::Enum(e) => e.module(db),
+        }
+        .krate(db)
+    }
+
+    pub(crate) fn resolver(self, db: &impl HirDatabase) -> Resolver {
+        match self {
+            AdtDef::Struct(it) => it.resolver(db),
+            AdtDef::Union(it) => it.resolver(db),
+            AdtDef::Enum(it) => it.resolver(db),
+        }
+    }
+}
+
 /// The defs which have a body.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum DefWithBody {