1 files changed, 24 insertions, 24 deletions

diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 9bf93981a..0272dd9ae 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -9,6 +9,7 @@ use chalk_ir::{
 };
 use chalk_rust_ir::{AssociatedTyDatum, AssociatedTyValue, ImplDatum, StructDatum, TraitDatum};
 
+use hir_def::{lang_item::LangItemTarget, GenericDefId};
 use hir_expand::name;
 
 use ra_db::salsa::{InternId, InternKey};
@@ -16,10 +17,9 @@ use ra_db::salsa::{InternId, InternKey};
 use super::{AssocTyValue, Canonical, ChalkContext, Impl, Obligation};
 use crate::{
     db::HirDatabase,
-    generics::{GenericDef, HasGenericParams},
     ty::display::HirDisplay,
     ty::{ApplicationTy, GenericPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk},
-    Crate, HasBody, ImplBlock, Trait, TypeAlias,
+    Crate, ImplBlock, Trait, TypeAlias,
 };
 
 /// This represents a trait whose name we could not resolve.
@@ -402,7 +402,7 @@ fn make_binders<T>(value: T, num_vars: usize) -> chalk_ir::Binders<T> {
 
 fn convert_where_clauses(
     db: &impl HirDatabase,
-    def: GenericDef,
+    def: GenericDefId,
     substs: &Substs,
 ) -> Vec<chalk_ir::QuantifiedWhereClause<ChalkIr>> {
     let generic_predicates = db.generic_predicates(def);
@@ -509,7 +509,7 @@ pub(crate) fn associated_ty_data_query(
         Some(crate::Container::Trait(t)) => t,
         _ => panic!("associated type not in trait"),
     };
-    let generic_params = type_alias.generic_params(db);
+    let generic_params = db.generic_params(type_alias.id.into());
     let bound_data = chalk_rust_ir::AssociatedTyDatumBound {
         // FIXME add bounds and where clauses
         bounds: vec![],
@@ -550,7 +550,7 @@ pub(crate) fn trait_datum_query(
     }
     let trait_: Trait = from_chalk(db, trait_id);
     debug!("trait {:?} = {:?}", trait_id, trait_.name(db));
-    let generic_params = trait_.generic_params(db);
+    let generic_params = db.generic_params(trait_.id.into());
     let bound_vars = Substs::bound_vars(&generic_params);
     let flags = chalk_rust_ir::TraitFlags {
         auto: trait_.is_auto(db),
@@ -561,7 +561,7 @@ pub(crate) fn trait_datum_query(
         marker: false,
         fundamental: false,
     };
-    let where_clauses = convert_where_clauses(db, trait_.into(), &bound_vars);
+    let where_clauses = convert_where_clauses(db, trait_.id.into(), &bound_vars);
     let associated_ty_ids = trait_
         .items(db)
         .into_iter()
@@ -594,7 +594,7 @@ pub(crate) fn struct_datum_query(
     let where_clauses = type_ctor
         .as_generic_def()
         .map(|generic_def| {
-            let generic_params = generic_def.generic_params(db);
+            let generic_params = db.generic_params(generic_def.into());
             let bound_vars = Substs::bound_vars(&generic_params);
             convert_where_clauses(db, generic_def, &bound_vars)
         })
@@ -634,7 +634,7 @@ fn impl_block_datum(
     impl_id: ImplId,
     impl_block: ImplBlock,
 ) -> Option<Arc<ImplDatum<ChalkIr>>> {
-    let generic_params = impl_block.generic_params(db);
+    let generic_params = db.generic_params(impl_block.id.into());
     let bound_vars = Substs::bound_vars(&generic_params);
     let trait_ref = impl_block.target_trait_ref(db)?.subst(&bound_vars);
     let trait_ = trait_ref.trait_;
@@ -643,7 +643,7 @@ fn impl_block_datum(
     } else {
         chalk_rust_ir::ImplType::External
     };
-    let where_clauses = convert_where_clauses(db, impl_block.into(), &bound_vars);
+    let where_clauses = convert_where_clauses(db, impl_block.id.into(), &bound_vars);
     let negative = impl_block.is_negative(db);
     debug!(
         "impl {:?}: {}{} where {:?}",
@@ -715,7 +715,7 @@ fn closure_fn_trait_impl_datum(
     let fn_once_trait = get_fn_trait(db, krate, super::FnTrait::FnOnce)?;
     fn_once_trait.associated_type_by_name(db, &name::OUTPUT_TYPE)?;
 
-    let num_args: u16 = match &data.def.body(db)[data.expr] {
+    let num_args: u16 = match &db.body(data.def.into())[data.expr] {
         crate::expr::Expr::Lambda { args, .. } => args.len() as u16,
         _ => {
             log::warn!("closure for closure type {:?} not found", data);
@@ -736,7 +736,7 @@ fn closure_fn_trait_impl_datum(
 
     let trait_ref = TraitRef {
         trait_,
-        substs: Substs::build_for_def(db, trait_).push(self_ty).push(arg_ty).build(),
+        substs: Substs::build_for_def(db, trait_.id).push(self_ty).push(arg_ty).build(),
     };
 
     let output_ty_id = AssocTyValue::ClosureFnTraitImplOutput(data.clone()).to_chalk(db);
@@ -786,7 +786,7 @@ fn type_alias_associated_ty_value(
     let assoc_ty = trait_
         .associated_type_by_name(db, &type_alias.name(db))
         .expect("assoc ty value should not exist"); // validated when building the impl data as well
-    let generic_params = impl_block.generic_params(db);
+    let generic_params = db.generic_params(impl_block.id.into());
     let bound_vars = Substs::bound_vars(&generic_params);
     let ty = db.type_for_def(type_alias.into(), crate::ty::Namespace::Types).subst(&bound_vars);
     let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: ty.to_chalk(db) };
@@ -805,7 +805,7 @@ fn closure_fn_trait_output_assoc_ty_value(
 ) -> Arc<AssociatedTyValue<ChalkIr>> {
     let impl_id = Impl::ClosureFnTraitImpl(data.clone()).to_chalk(db);
 
-    let num_args: u16 = match &data.def.body(db)[data.expr] {
+    let num_args: u16 = match &db.body(data.def.into())[data.expr] {
         crate::expr::Expr::Lambda { args, .. } => args.len() as u16,
         _ => {
             log::warn!("closure for closure type {:?} not found", data);
@@ -833,9 +833,9 @@ fn closure_fn_trait_output_assoc_ty_value(
 }
 
 fn get_fn_trait(db: &impl HirDatabase, krate: Crate, fn_trait: super::FnTrait) -> Option<Trait> {
-    let target = db.lang_item(krate, fn_trait.lang_item_name().into())?;
+    let target = db.lang_item(krate.crate_id, fn_trait.lang_item_name().into())?;
     match target {
-        crate::lang_item::LangItemTarget::Trait(t) => Some(t),
+        LangItemTarget::TraitId(t) => Some(t.into()),
         _ => None,
     }
 }
@@ -847,38 +847,38 @@ fn id_to_chalk<T: InternKey>(salsa_id: T) -> chalk_ir::RawId {
     chalk_ir::RawId { index: salsa_id.as_intern_id().as_u32() }
 }
 
-impl From<chalk_ir::StructId> for crate::ids::TypeCtorId {
+impl From<chalk_ir::StructId> for crate::ty::TypeCtorId {
     fn from(struct_id: chalk_ir::StructId) -> Self {
         id_from_chalk(struct_id.0)
     }
 }
 
-impl From<crate::ids::TypeCtorId> for chalk_ir::StructId {
-    fn from(type_ctor_id: crate::ids::TypeCtorId) -> Self {
+impl From<crate::ty::TypeCtorId> for chalk_ir::StructId {
+    fn from(type_ctor_id: crate::ty::TypeCtorId) -> Self {
         chalk_ir::StructId(id_to_chalk(type_ctor_id))
     }
 }
 
-impl From<chalk_ir::ImplId> for crate::ids::GlobalImplId {
+impl From<chalk_ir::ImplId> for crate::ty::traits::GlobalImplId {
     fn from(impl_id: chalk_ir::ImplId) -> Self {
         id_from_chalk(impl_id.0)
     }
 }
 
-impl From<crate::ids::GlobalImplId> for chalk_ir::ImplId {
-    fn from(impl_id: crate::ids::GlobalImplId) -> Self {
+impl From<crate::ty::traits::GlobalImplId> for chalk_ir::ImplId {
+    fn from(impl_id: crate::ty::traits::GlobalImplId) -> Self {
         chalk_ir::ImplId(id_to_chalk(impl_id))
     }
 }
 
-impl From<chalk_rust_ir::AssociatedTyValueId> for crate::ids::AssocTyValueId {
+impl From<chalk_rust_ir::AssociatedTyValueId> for crate::ty::traits::AssocTyValueId {
     fn from(id: chalk_rust_ir::AssociatedTyValueId) -> Self {
         id_from_chalk(id.0)
     }
 }
 
-impl From<crate::ids::AssocTyValueId> for chalk_rust_ir::AssociatedTyValueId {
-    fn from(assoc_ty_value_id: crate::ids::AssocTyValueId) -> Self {
+impl From<crate::ty::traits::AssocTyValueId> for chalk_rust_ir::AssociatedTyValueId {
+    fn from(assoc_ty_value_id: crate::ty::traits::AssocTyValueId) -> Self {
         chalk_rust_ir::AssociatedTyValueId(id_to_chalk(assoc_ty_value_id))
     }
 }