From e1a6e38767c1e47e5e88a97a9ef5b4547390803c Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Wed, 20 Nov 2019 12:25:02 +0300
Subject: Move Generics to hir_def

---
 crates/ra_hir/src/from_id.rs | 44 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 42 insertions(+), 2 deletions(-)

(limited to 'crates/ra_hir/src/from_id.rs')

diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index f2203e995..b7692d407 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -3,9 +3,9 @@
 //! 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, ModuleDefId};
+use hir_def::{AdtId, AssocItemId, DefWithBodyId, EnumVariantId, GenericDefId, ModuleDefId};
 
-use crate::{Adt, AssocItem, DefWithBody, EnumVariant, ModuleDef};
+use crate::{Adt, AssocItem, DefWithBody, EnumVariant, GenericDef, ModuleDef};
 
 macro_rules! from_id {
     ($(($id:path, $ty:path)),*) => {$(
@@ -41,6 +41,16 @@ impl From<AdtId> for Adt {
     }
 }
 
+impl From<Adt> for AdtId {
+    fn from(id: Adt) -> Self {
+        match id {
+            Adt::Struct(it) => AdtId::StructId(it.id),
+            Adt::Union(it) => AdtId::UnionId(it.id),
+            Adt::Enum(it) => AdtId::EnumId(it.id),
+        }
+    }
+}
+
 impl From<EnumVariantId> for EnumVariant {
     fn from(id: EnumVariantId) -> Self {
         EnumVariant { parent: id.parent.into(), id: id.local_id }
@@ -82,3 +92,33 @@ impl From<AssocItemId> for AssocItem {
         }
     }
 }
+
+impl From<GenericDef> for GenericDefId {
+    fn from(def: GenericDef) -> Self {
+        match def {
+            GenericDef::Function(it) => GenericDefId::FunctionId(it.id),
+            GenericDef::Adt(it) => GenericDefId::AdtId(it.into()),
+            GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
+            GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
+            GenericDef::ImplBlock(it) => GenericDefId::ImplId(it.id),
+            GenericDef::EnumVariant(it) => {
+                GenericDefId::EnumVariantId(EnumVariantId { parent: it.parent.id, local_id: it.id })
+            }
+            GenericDef::Const(it) => GenericDefId::ConstId(it.id),
+        }
+    }
+}
+
+impl From<GenericDefId> for GenericDef {
+    fn from(def: GenericDefId) -> Self {
+        match def {
+            GenericDefId::FunctionId(it) => GenericDef::Function(it.into()),
+            GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
+            GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
+            GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
+            GenericDefId::ImplId(it) => GenericDef::ImplBlock(it.into()),
+            GenericDefId::EnumVariantId(it) => GenericDef::EnumVariant(it.into()),
+            GenericDefId::ConstId(it) => GenericDef::Const(it.into()),
+        }
+    }
+}
-- 
cgit v1.2.3