Use ids for Callable

1 files changed, 20 insertions, 18 deletions

diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 348c5f67d..27cfe00c1 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -14,9 +14,11 @@ use hir_def::{
     path::{GenericArg, PathSegment},
     resolver::{HasResolver, Resolver, TypeNs},
     type_ref::{TypeBound, TypeRef},
-    AdtId, EnumVariantId, FunctionId, GenericDefId, LocalStructFieldId, StructId, VariantId,
+    AdtId, AstItemDef, EnumVariantId, FunctionId, GenericDefId, HasModule, LocalStructFieldId,
+    Lookup, StructId, VariantId,
 };
 use ra_arena::map::ArenaMap;
+use ra_db::CrateId;
 
 use super::{
     FnSig, GenericPredicate, ProjectionPredicate, ProjectionTy, Substs, TraitEnvironment, TraitRef,
@@ -546,9 +548,9 @@ pub(crate) fn type_for_def(db: &impl HirDatabase, def: TypableDef, ns: Namespace
 /// Build the signature of a callable item (function, struct or enum variant).
 pub(crate) fn callable_item_sig(db: &impl HirDatabase, def: CallableDef) -> FnSig {
     match def {
-        CallableDef::Function(f) => fn_sig_for_fn(db, f.id),
-        CallableDef::Struct(s) => fn_sig_for_struct_constructor(db, s.id),
-        CallableDef::EnumVariant(e) => fn_sig_for_enum_variant_constructor(db, e.into()),
+        CallableDef::FunctionId(f) => fn_sig_for_fn(db, f),
+        CallableDef::StructId(s) => fn_sig_for_struct_constructor(db, s),
+        CallableDef::EnumVariantId(e) => fn_sig_for_enum_variant_constructor(db, e),
     }
 }
 
@@ -643,7 +645,7 @@ fn fn_sig_for_fn(db: &impl HirDatabase, def: FunctionId) -> FnSig {
 fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
     let generics = db.generic_params(def.id.into());
     let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(def.id.into()), substs)
 }
 
 /// Build the declared type of a const.
@@ -723,7 +725,7 @@ fn type_for_struct_constructor(db: &impl HirDatabase, def: Struct) -> Ty {
     }
     let generics = db.generic_params(def.id.into());
     let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(def.id.into()), substs)
 }
 
 fn fn_sig_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariantId) -> FnSig {
@@ -749,7 +751,7 @@ fn type_for_enum_variant_constructor(db: &impl HirDatabase, def: EnumVariant) ->
     }
     let generics = db.generic_params(def.parent_enum(db).id.into());
     let substs = Substs::identity(&generics);
-    Ty::apply(TypeCtor::FnDef(def.into()), substs)
+    Ty::apply(TypeCtor::FnDef(EnumVariantId::from(def).into()), substs)
 }
 
 fn type_for_adt(db: &impl HirDatabase, adt: impl Into<Adt>) -> Ty {
@@ -806,18 +808,18 @@ impl From<ModuleDef> for Option<TypableDef> {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum CallableDef {
-    Function(Function),
-    Struct(Struct),
-    EnumVariant(EnumVariant),
+    FunctionId(FunctionId),
+    StructId(StructId),
+    EnumVariantId(EnumVariantId),
 }
-impl_froms!(CallableDef: Function, Struct, EnumVariant);
+impl_froms!(CallableDef: FunctionId, StructId, EnumVariantId);
 
 impl CallableDef {
-    pub fn krate(self, db: &impl HirDatabase) -> Option<crate::Crate> {
+    pub fn krate(self, db: &impl HirDatabase) -> CrateId {
         match self {
-            CallableDef::Function(f) => f.krate(db),
-            CallableDef::Struct(s) => s.krate(db),
-            CallableDef::EnumVariant(e) => e.parent_enum(db).krate(db),
+            CallableDef::FunctionId(f) => f.lookup(db).module(db).krate,
+            CallableDef::StructId(s) => s.0.module(db).krate,
+            CallableDef::EnumVariantId(e) => e.parent.module(db).krate,
         }
     }
 }
@@ -825,9 +827,9 @@ impl CallableDef {
 impl From<CallableDef> for GenericDefId {
     fn from(def: CallableDef) -> GenericDefId {
         match def {
-            CallableDef::Function(f) => f.id.into(),
-            CallableDef::Struct(s) => s.id.into(),
-            CallableDef::EnumVariant(e) => EnumVariantId::from(e).into(),
+            CallableDef::FunctionId(f) => f.into(),
+            CallableDef::StructId(s) => s.into(),
+            CallableDef::EnumVariantId(e) => e.into(),
         }
     }
 }