1 files changed, 99 insertions, 2 deletions

diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index b7692d407..e8ed04056 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -3,9 +3,22 @@
 //! It's unclear if we need this long-term, but it's definitelly useful while we
 //! are splitting the hir.
 
-use hir_def::{AdtId, AssocItemId, DefWithBodyId, EnumVariantId, GenericDefId, ModuleDefId};
+use hir_def::{
+    AdtId, AssocItemId, ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId,
+    ModuleDefId, StaticId, StructId, TypeAliasId, UnionId,
+};
 
-use crate::{Adt, AssocItem, DefWithBody, EnumVariant, GenericDef, ModuleDef};
+use crate::{
+    ty::{CallableDef, TypableDef},
+    Adt, AssocItem, Const, Crate, DefWithBody, EnumVariant, Function, GenericDef, ModuleDef,
+    Static, TypeAlias,
+};
+
+impl From<ra_db::CrateId> for Crate {
+    fn from(crate_id: ra_db::CrateId) -> Self {
+        Crate { crate_id }
+    }
+}
 
 macro_rules! from_id {
     ($(($id:path, $ty:path)),*) => {$(
@@ -83,6 +96,16 @@ impl From<DefWithBody> for DefWithBodyId {
     }
 }
 
+impl From<DefWithBodyId> for DefWithBody {
+    fn from(def: DefWithBodyId) -> Self {
+        match def {
+            DefWithBodyId::FunctionId(it) => DefWithBody::Function(it.into()),
+            DefWithBodyId::StaticId(it) => DefWithBody::Static(it.into()),
+            DefWithBodyId::ConstId(it) => DefWithBody::Const(it.into()),
+        }
+    }
+}
+
 impl From<AssocItemId> for AssocItem {
     fn from(def: AssocItemId) -> Self {
         match def {
@@ -122,3 +145,77 @@ impl From<GenericDefId> for GenericDef {
         }
     }
 }
+
+impl From<AdtId> for TypableDef {
+    fn from(id: AdtId) -> Self {
+        Adt::from(id).into()
+    }
+}
+
+impl From<StructId> for TypableDef {
+    fn from(id: StructId) -> Self {
+        AdtId::StructId(id).into()
+    }
+}
+
+impl From<UnionId> for TypableDef {
+    fn from(id: UnionId) -> Self {
+        AdtId::UnionId(id).into()
+    }
+}
+
+impl From<EnumId> for TypableDef {
+    fn from(id: EnumId) -> Self {
+        AdtId::EnumId(id).into()
+    }
+}
+
+impl From<EnumVariantId> for TypableDef {
+    fn from(id: EnumVariantId) -> Self {
+        EnumVariant::from(id).into()
+    }
+}
+
+impl From<TypeAliasId> for TypableDef {
+    fn from(id: TypeAliasId) -> Self {
+        TypeAlias::from(id).into()
+    }
+}
+
+impl From<FunctionId> for TypableDef {
+    fn from(id: FunctionId) -> Self {
+        Function::from(id).into()
+    }
+}
+impl From<ConstId> for TypableDef {
+    fn from(id: ConstId) -> Self {
+        Const::from(id).into()
+    }
+}
+impl From<StaticId> for TypableDef {
+    fn from(id: StaticId) -> Self {
+        Static::from(id).into()
+    }
+}
+
+impl From<Adt> for GenericDefId {
+    fn from(id: Adt) -> Self {
+        match id {
+            Adt::Struct(it) => it.id.into(),
+            Adt::Union(it) => it.id.into(),
+            Adt::Enum(it) => it.id.into(),
+        }
+    }
+}
+
+impl From<CallableDef> for GenericDefId {
+    fn from(def: CallableDef) -> Self {
+        match def {
+            CallableDef::Function(it) => it.id.into(),
+            CallableDef::Struct(it) => it.id.into(),
+            CallableDef::EnumVariant(it) => {
+                EnumVariantId { parent: it.parent.id, local_id: it.id }.into()
+            }
+        }
+    }
+}