Update Chalk, clean up Chalk integration a bit

1 files changed, 87 insertions, 93 deletions

diff --git a/crates/ra_hir_ty/src/traits/chalk.rs b/crates/ra_hir_ty/src/traits/chalk.rs
index 5eb032d86..3a91a374d 100644
--- a/crates/ra_hir_ty/src/traits/chalk.rs
+++ b/crates/ra_hir_ty/src/traits/chalk.rs
@@ -3,15 +3,9 @@ use std::sync::Arc;
 
 use log::debug;
 
-use chalk_ir::{
-    cast::Cast, family::ChalkIr, Identifier, Parameter, PlaceholderIndex, TypeId, TypeKindId,
-    TypeName, UniverseIndex,
-};
-use chalk_rust_ir::{AssociatedTyDatum, AssociatedTyValue, ImplDatum, StructDatum, TraitDatum};
+use chalk_ir::{cast::Cast, family::ChalkIr, Parameter, PlaceholderIndex, TypeName, UniverseIndex};
 
-use hir_def::{
-    AssocContainerId, AssocItemId, GenericDefId, HasModule, ImplId, Lookup, TraitId, TypeAliasId,
-};
+use hir_def::{AssocContainerId, AssocItemId, GenericDefId, HasModule, Lookup, TypeAliasId};
 use ra_db::{
     salsa::{InternId, InternKey},
     CrateId,
@@ -23,9 +17,20 @@ use crate::{
     ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
 };
 
+pub type TypeFamily = chalk_ir::family::ChalkIr; // TODO use everywhere
+pub type AssocTypeId = chalk_ir::AssocTypeId<TypeFamily>;
+pub type AssociatedTyDatum = chalk_rust_ir::AssociatedTyDatum<TypeFamily>;
+pub type TraitId = chalk_ir::TraitId<TypeFamily>;
+pub type TraitDatum = chalk_rust_ir::TraitDatum<TypeFamily>;
+pub type StructId = chalk_ir::StructId<TypeFamily>;
+pub type StructDatum = chalk_rust_ir::StructDatum<TypeFamily>;
+pub type ImplId = chalk_ir::ImplId<TypeFamily>;
+pub type ImplDatum = chalk_rust_ir::ImplDatum<TypeFamily>;
+pub type AssociatedTyValueId = chalk_rust_ir::AssociatedTyValueId;
+pub type AssociatedTyValue = chalk_rust_ir::AssociatedTyValue<TypeFamily>;
+
 /// This represents a trait whose name we could not resolve.
-const UNKNOWN_TRAIT: chalk_ir::TraitId =
-    chalk_ir::TraitId(chalk_ir::RawId { index: u32::max_value() });
+const UNKNOWN_TRAIT: TraitId = chalk_ir::TraitId(chalk_ir::RawId { index: u32::max_value() });
 
 pub(super) trait ToChalk {
     type Chalk;
@@ -53,7 +58,7 @@ impl ToChalk for Ty {
                     _ => {
                         // other TypeCtors get interned and turned into a chalk StructId
                         let struct_id = apply_ty.ctor.to_chalk(db);
-                        TypeName::TypeKindId(struct_id.into())
+                        TypeName::Struct(struct_id.into())
                     }
                 };
                 let parameters = apply_ty.parameters.to_chalk(db);
@@ -71,11 +76,13 @@ impl ToChalk for Ty {
             Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
             Ty::Dyn(predicates) => {
                 let where_clauses = predicates.iter().cloned().map(|p| p.to_chalk(db)).collect();
-                chalk_ir::TyData::Dyn(make_binders(where_clauses, 1)).intern()
+                let bounded_ty = chalk_ir::BoundedTy { bounds: make_binders(where_clauses, 1) };
+                chalk_ir::TyData::Dyn(bounded_ty).intern()
             }
             Ty::Opaque(predicates) => {
                 let where_clauses = predicates.iter().cloned().map(|p| p.to_chalk(db)).collect();
-                chalk_ir::TyData::Opaque(make_binders(where_clauses, 1)).intern()
+                let bounded_ty = chalk_ir::BoundedTy { bounds: make_binders(where_clauses, 1) };
+                chalk_ir::TyData::Opaque(bounded_ty).intern()
             }
             Ty::Unknown => {
                 let parameters = Vec::new();
@@ -87,10 +94,9 @@ impl ToChalk for Ty {
     fn from_chalk(db: &impl HirDatabase, chalk: chalk_ir::Ty<ChalkIr>) -> Self {
         match chalk.data().clone() {
             chalk_ir::TyData::Apply(apply_ty) => {
-                // FIXME this is kind of hacky due to the fact that
-                // TypeName::Placeholder is a Ty::Param on our side
+                // TODO clean this up now that Placeholder isn't in TypeName anymore
                 match apply_ty.name {
-                    TypeName::TypeKindId(TypeKindId::StructId(struct_id)) => {
+                    TypeName::Struct(struct_id) => {
                         let ctor = from_chalk(db, struct_id);
                         let parameters = from_chalk(db, apply_ty.parameters);
                         Ty::Apply(ApplicationTy { ctor, parameters })
@@ -101,14 +107,12 @@ impl ToChalk for Ty {
                         Ty::Apply(ApplicationTy { ctor, parameters })
                     }
                     TypeName::Error => Ty::Unknown,
-                    // FIXME handle TypeKindId::Trait/Type here
-                    TypeName::TypeKindId(_) => unimplemented!(),
-                    TypeName::Placeholder(idx) => {
-                        assert_eq!(idx.ui, UniverseIndex::ROOT);
-                        Ty::Param { idx: idx.idx as u32, name: crate::Name::missing() }
-                    }
                 }
             }
+            chalk_ir::TyData::Placeholder(idx) => {
+                assert_eq!(idx.ui, UniverseIndex::ROOT);
+                Ty::Param { idx: idx.idx as u32, name: crate::Name::missing() }
+            }
             chalk_ir::TyData::Projection(proj) => {
                 let associated_ty = from_chalk(db, proj.associated_ty_id);
                 let parameters = from_chalk(db, proj.parameters);
@@ -118,15 +122,15 @@ impl ToChalk for Ty {
             chalk_ir::TyData::BoundVar(idx) => Ty::Bound(idx as u32),
             chalk_ir::TyData::InferenceVar(_iv) => Ty::Unknown,
             chalk_ir::TyData::Dyn(where_clauses) => {
-                assert_eq!(where_clauses.binders.len(), 1);
+                assert_eq!(where_clauses.bounds.binders.len(), 1);
                 let predicates =
-                    where_clauses.value.into_iter().map(|c| from_chalk(db, c)).collect();
+                    where_clauses.bounds.value.into_iter().map(|c| from_chalk(db, c)).collect();
                 Ty::Dyn(predicates)
             }
             chalk_ir::TyData::Opaque(where_clauses) => {
-                assert_eq!(where_clauses.binders.len(), 1);
+                assert_eq!(where_clauses.bounds.binders.len(), 1);
                 let predicates =
-                    where_clauses.value.into_iter().map(|c| from_chalk(db, c)).collect();
+                    where_clauses.bounds.value.into_iter().map(|c| from_chalk(db, c)).collect();
                 Ty::Opaque(predicates)
             }
         }
@@ -143,9 +147,9 @@ impl ToChalk for Substs {
     fn from_chalk(db: &impl HirDatabase, parameters: Vec<chalk_ir::Parameter<ChalkIr>>) -> Substs {
         let tys = parameters
             .into_iter()
-            .map(|p| match p {
-                chalk_ir::Parameter(chalk_ir::ParameterKind::Ty(ty)) => from_chalk(db, ty),
-                chalk_ir::Parameter(chalk_ir::ParameterKind::Lifetime(_)) => unimplemented!(),
+            .map(|p| match p.ty() {
+                Some(ty) => from_chalk(db, ty.clone()),
+                None => unimplemented!(),
             })
             .collect();
         Substs(tys)
@@ -168,65 +172,62 @@ impl ToChalk for TraitRef {
     }
 }
 
-impl ToChalk for TraitId {
-    type Chalk = chalk_ir::TraitId;
+impl ToChalk for hir_def::TraitId {
+    type Chalk = TraitId;
 
-    fn to_chalk(self, _db: &impl HirDatabase) -> chalk_ir::TraitId {
+    fn to_chalk(self, _db: &impl HirDatabase) -> TraitId {
         chalk_ir::TraitId(id_to_chalk(self))
     }
 
-    fn from_chalk(_db: &impl HirDatabase, trait_id: chalk_ir::TraitId) -> TraitId {
+    fn from_chalk(_db: &impl HirDatabase, trait_id: TraitId) -> hir_def::TraitId {
         id_from_chalk(trait_id.0)
     }
 }
 
 impl ToChalk for TypeCtor {
-    type Chalk = chalk_ir::StructId;
+    type Chalk = StructId;
 
-    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::StructId {
+    fn to_chalk(self, db: &impl HirDatabase) -> StructId {
         db.intern_type_ctor(self).into()
     }
 
-    fn from_chalk(db: &impl HirDatabase, struct_id: chalk_ir::StructId) -> TypeCtor {
+    fn from_chalk(db: &impl HirDatabase, struct_id: StructId) -> TypeCtor {
         db.lookup_intern_type_ctor(struct_id.into())
     }
 }
 
 impl ToChalk for Impl {
-    type Chalk = chalk_ir::ImplId;
+    type Chalk = ImplId;
 
-    fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::ImplId {
+    fn to_chalk(self, db: &impl HirDatabase) -> ImplId {
         db.intern_chalk_impl(self).into()
     }
 
-    fn from_chalk(db: &impl HirDatabase, impl_id: chalk_ir::ImplId) -> Impl {
+    fn from_chalk(db: &impl HirDatabase, impl_id: ImplId) -> Impl {
         db.lookup_intern_chalk_impl(impl_id.into())
     }
 }
 
 impl ToChalk for TypeAliasId {
-    type Chalk = chalk_ir::TypeId;
+    type Chalk = AssocTypeId;
 
-    fn to_chalk(self, _db: &impl HirDatabase) -> chalk_ir::TypeId {
-        chalk_ir::TypeId(id_to_chalk(self))
+    fn to_chalk(self, _db: &impl HirDatabase) -> AssocTypeId {
+        chalk_ir::AssocTypeId(id_to_chalk(self))
     }
 
-    fn from_chalk(_db: &impl HirDatabase, type_alias_id: chalk_ir::TypeId) -> TypeAliasId {
+    fn from_chalk(_db: &impl HirDatabase, type_alias_id: AssocTypeId) -> TypeAliasId {
         id_from_chalk(type_alias_id.0)
     }
 }
 
 impl ToChalk for AssocTyValue {
-    type Chalk = chalk_rust_ir::AssociatedTyValueId;
+    type Chalk = AssociatedTyValueId;
 
-    fn to_chalk(self, db: &impl HirDatabase) -> chalk_rust_ir::AssociatedTyValueId {
+    fn to_chalk(self, db: &impl HirDatabase) -> AssociatedTyValueId {
         db.intern_assoc_ty_value(self).into()
     }
 
-    fn from_chalk(
-        db: &impl HirDatabase,
-        assoc_ty_value_id: chalk_rust_ir::AssociatedTyValueId,
-    ) -> AssocTyValue {
+    fn from_chalk(db: &impl HirDatabase, assoc_ty_value_id: AssociatedTyValueId) -> AssocTyValue {
         db.lookup_intern_assoc_ty_value(assoc_ty_value_id.into())
     }
 }
@@ -468,28 +469,28 @@ impl<'a, DB> chalk_solve::RustIrDatabase<ChalkIr> for ChalkContext<'a, DB>
 where
     DB: HirDatabase,
 {
-    fn associated_ty_data(&self, id: TypeId) -> Arc<AssociatedTyDatum<ChalkIr>> {
+    fn associated_ty_data(&self, id: AssocTypeId) -> Arc<AssociatedTyDatum> {
         self.db.associated_ty_data(id)
     }
-    fn trait_datum(&self, trait_id: chalk_ir::TraitId) -> Arc<TraitDatum<ChalkIr>> {
+    fn trait_datum(&self, trait_id: TraitId) -> Arc<TraitDatum> {
         self.db.trait_datum(self.krate, trait_id)
     }
-    fn struct_datum(&self, struct_id: chalk_ir::StructId) -> Arc<StructDatum<ChalkIr>> {
+    fn struct_datum(&self, struct_id: StructId) -> Arc<StructDatum> {
         self.db.struct_datum(self.krate, struct_id)
     }
-    fn impl_datum(&self, impl_id: chalk_ir::ImplId) -> Arc<ImplDatum<ChalkIr>> {
+    fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum> {
         self.db.impl_datum(self.krate, impl_id)
     }
     fn impls_for_trait(
         &self,
-        trait_id: chalk_ir::TraitId,
-        parameters: &[Parameter<ChalkIr>],
-    ) -> Vec<chalk_ir::ImplId> {
+        trait_id: TraitId,
+        parameters: &[Parameter<TypeFamily>],
+    ) -> Vec<ImplId> {
         debug!("impls_for_trait {:?}", trait_id);
         if trait_id == UNKNOWN_TRAIT {
             return Vec::new();
         }
-        let trait_: TraitId = from_chalk(self.db, trait_id);
+        let trait_: hir_def::TraitId = from_chalk(self.db, trait_id);
         let mut result: Vec<_> = self
             .db
             .impls_for_trait(self.krate, trait_.into())
@@ -508,39 +509,32 @@ where
         debug!("impls_for_trait returned {} impls", result.len());
         result
     }
-    fn impl_provided_for(
-        &self,
-        auto_trait_id: chalk_ir::TraitId,
-        struct_id: chalk_ir::StructId,
-    ) -> bool {
+    fn impl_provided_for(&self, auto_trait_id: TraitId, struct_id: StructId) -> bool {
         debug!("impl_provided_for {:?}, {:?}", auto_trait_id, struct_id);
         false // FIXME
     }
-    fn type_name(&self, _id: TypeKindId) -> Identifier {
-        unimplemented!()
-    }
-    fn associated_ty_value(
-        &self,
-        id: chalk_rust_ir::AssociatedTyValueId,
-    ) -> Arc<AssociatedTyValue<ChalkIr>> {
+    fn associated_ty_value(&self, id: AssociatedTyValueId) -> Arc<AssociatedTyValue> {
         self.db.associated_ty_value(self.krate.into(), id)
     }
     fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause<ChalkIr>> {
         vec![]
     }
-    fn local_impls_to_coherence_check(
-        &self,
-        _trait_id: chalk_ir::TraitId,
-    ) -> Vec<chalk_ir::ImplId> {
+    fn local_impls_to_coherence_check(&self, _trait_id: TraitId) -> Vec<ImplId> {
         // We don't do coherence checking (yet)
         unimplemented!()
     }
+    fn as_struct_id(&self, id: &TypeName<TypeFamily>) -> Option<StructId> {
+        match id {
+            TypeName::Struct(struct_id) => Some(*struct_id),
+            _ => None,
+        }
+    }
 }
 
 pub(crate) fn associated_ty_data_query(
     db: &impl HirDatabase,
-    id: TypeId,
-) -> Arc<AssociatedTyDatum<ChalkIr>> {
+    id: AssocTypeId,
+) -> Arc<AssociatedTyDatum> {
     debug!("associated_ty_data {:?}", id);
     let type_alias: TypeAliasId = from_chalk(db, id);
     let trait_ = match type_alias.lookup(db).container {
@@ -565,8 +559,8 @@ pub(crate) fn associated_ty_data_query(
 pub(crate) fn trait_datum_query(
     db: &impl HirDatabase,
     krate: CrateId,
-    trait_id: chalk_ir::TraitId,
-) -> Arc<TraitDatum<ChalkIr>> {
+    trait_id: TraitId,
+) -> Arc<TraitDatum> {
     debug!("trait_datum {:?}", trait_id);
     if trait_id == UNKNOWN_TRAIT {
         let trait_datum_bound = chalk_rust_ir::TraitDatumBound { where_clauses: Vec::new() };
@@ -586,7 +580,7 @@ pub(crate) fn trait_datum_query(
             associated_ty_ids: vec![],
         });
     }
-    let trait_: TraitId = from_chalk(db, trait_id);
+    let trait_: hir_def::TraitId = from_chalk(db, trait_id);
     let trait_data = db.trait_data(trait_);
     debug!("trait {:?} = {:?}", trait_id, trait_data.name);
     let generic_params = generics(db, trait_.into());
@@ -616,8 +610,8 @@ pub(crate) fn trait_datum_query(
 pub(crate) fn struct_datum_query(
     db: &impl HirDatabase,
     krate: CrateId,
-    struct_id: chalk_ir::StructId,
-) -> Arc<StructDatum<ChalkIr>> {
+    struct_id: StructId,
+) -> Arc<StructDatum> {
     debug!("struct_datum {:?}", struct_id);
     let type_ctor: TypeCtor = from_chalk(db, struct_id);
     debug!("struct {:?} = {:?}", struct_id, type_ctor);
@@ -648,8 +642,8 @@ pub(crate) fn struct_datum_query(
 pub(crate) fn impl_datum_query(
     db: &impl HirDatabase,
     krate: CrateId,
-    impl_id: chalk_ir::ImplId,
-) -> Arc<ImplDatum<ChalkIr>> {
+    impl_id: ImplId,
+) -> Arc<ImplDatum> {
     let _p = ra_prof::profile("impl_datum");
     debug!("impl_datum {:?}", impl_id);
     let impl_: Impl = from_chalk(db, impl_id);
@@ -663,9 +657,9 @@ pub(crate) fn impl_datum_query(
 fn impl_block_datum(
     db: &impl HirDatabase,
     krate: CrateId,
-    chalk_id: chalk_ir::ImplId,
-    impl_id: ImplId,
-) -> Option<Arc<ImplDatum<ChalkIr>>> {
+    chalk_id: ImplId,
+    impl_id: hir_def::ImplId,
+) -> Option<Arc<ImplDatum>> {
     let trait_ref = db.impl_trait(impl_id)?;
     let impl_data = db.impl_data(impl_id);
 
@@ -721,7 +715,7 @@ fn impl_block_datum(
     Some(Arc::new(impl_datum))
 }
 
-fn invalid_impl_datum() -> Arc<ImplDatum<ChalkIr>> {
+fn invalid_impl_datum() -> Arc<ImplDatum> {
     let trait_ref = chalk_ir::TraitRef {
         trait_id: UNKNOWN_TRAIT,
         parameters: vec![chalk_ir::TyData::BoundVar(0).cast().intern().cast()],
@@ -754,7 +748,7 @@ fn type_alias_associated_ty_value(
     db: &impl HirDatabase,
     _krate: CrateId,
     type_alias: TypeAliasId,
-) -> Arc<AssociatedTyValue<ChalkIr>> {
+) -> Arc<AssociatedTyValue> {
     let type_alias_data = db.type_alias_data(type_alias);
     let impl_id = match type_alias.lookup(db).container {
         AssocContainerId::ImplId(it) => it,
@@ -786,25 +780,25 @@ 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::TypeCtorId {
-    fn from(struct_id: chalk_ir::StructId) -> Self {
+impl From<StructId> for crate::TypeCtorId {
+    fn from(struct_id: StructId) -> Self {
         id_from_chalk(struct_id.0)
     }
 }
 
-impl From<crate::TypeCtorId> for chalk_ir::StructId {
+impl From<crate::TypeCtorId> for StructId {
     fn from(type_ctor_id: crate::TypeCtorId) -> Self {
         chalk_ir::StructId(id_to_chalk(type_ctor_id))
     }
 }
 
-impl From<chalk_ir::ImplId> for crate::traits::GlobalImplId {
-    fn from(impl_id: chalk_ir::ImplId) -> Self {
+impl From<ImplId> for crate::traits::GlobalImplId {
+    fn from(impl_id: ImplId) -> Self {
         id_from_chalk(impl_id.0)
     }
 }
 
-impl From<crate::traits::GlobalImplId> for chalk_ir::ImplId {
+impl From<crate::traits::GlobalImplId> for ImplId {
     fn from(impl_id: crate::traits::GlobalImplId) -> Self {
         chalk_ir::ImplId(id_to_chalk(impl_id))
     }