1 files changed, 99 insertions, 113 deletions

diff --git a/crates/hir_ty/src/traits/chalk/mapping.rs b/crates/hir_ty/src/traits/chalk/mapping.rs
index aef6b8a15..701359e6f 100644
--- a/crates/hir_ty/src/traits/chalk/mapping.rs
+++ b/crates/hir_ty/src/traits/chalk/mapping.rs
@@ -3,18 +3,16 @@
 //! Chalk (in both directions); plus some helper functions for more specialized
 //! conversions.
 
-use chalk_ir::{cast::Cast, fold::shift::Shift, interner::HasInterner, LifetimeData};
+use chalk_ir::{cast::Cast, interner::HasInterner};
 use chalk_solve::rust_ir;
 
 use base_db::salsa::InternKey;
 use hir_def::{GenericDefId, TypeAliasId};
 
 use crate::{
-    db::HirDatabase,
-    primitive::UintTy,
-    traits::{Canonical, DomainGoal},
-    AliasTy, CallableDefId, FnPointer, InEnvironment, OpaqueTy, ProjectionTy,
-    QuantifiedWhereClause, Scalar, Substitution, TraitRef, Ty, TypeWalk, WhereClause,
+    db::HirDatabase, static_lifetime, AliasTy, CallableDefId, Canonical, ConstrainedSubst,
+    DomainGoal, FnPointer, GenericArg, InEnvironment, OpaqueTy, ProjectionTy, ProjectionTyExt,
+    QuantifiedWhereClause, Substitution, TraitRef, Ty, TypeWalk, WhereClause,
 };
 
 use super::interner::*;
@@ -24,16 +22,16 @@ impl ToChalk for Ty {
     type Chalk = chalk_ir::Ty<Interner>;
     fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Ty<Interner> {
         match self.into_inner() {
-            TyKind::Ref(m, ty) => ref_to_chalk(db, m, ty),
-            TyKind::Array(ty) => array_to_chalk(db, ty),
-            TyKind::Function(FnPointer { sig, substs, .. }) => {
-                let substitution = chalk_ir::FnSubst(substs.to_chalk(db).shifted_in(&Interner));
-                chalk_ir::TyKind::Function(chalk_ir::FnPointer {
-                    num_binders: 0,
-                    sig,
-                    substitution,
-                })
-                .intern(&Interner)
+            TyKind::Ref(m, lt, ty) => {
+                chalk_ir::TyKind::Ref(m, lt, ty.to_chalk(db)).intern(&Interner)
+            }
+            TyKind::Array(ty, size) => {
+                chalk_ir::TyKind::Array(ty.to_chalk(db), size).intern(&Interner)
+            }
+            TyKind::Function(FnPointer { sig, substitution: substs, num_binders }) => {
+                let substitution = chalk_ir::FnSubst(substs.0.to_chalk(db));
+                chalk_ir::TyKind::Function(chalk_ir::FnPointer { num_binders, sig, substitution })
+                    .intern(&Interner)
             }
             TyKind::AssociatedType(assoc_type_id, substs) => {
                 let substitution = substs.to_chalk(db);
@@ -45,7 +43,7 @@ impl ToChalk for Ty {
                 chalk_ir::TyKind::OpaqueType(id, substitution).intern(&Interner)
             }
 
-            TyKind::ForeignType(id) => chalk_ir::TyKind::Foreign(id).intern(&Interner),
+            TyKind::Foreign(id) => chalk_ir::TyKind::Foreign(id).intern(&Interner),
 
             TyKind::Scalar(scalar) => chalk_ir::TyKind::Scalar(scalar).intern(&Interner),
 
@@ -75,56 +73,41 @@ impl ToChalk for Ty {
                 chalk_ir::TyKind::Adt(adt_id, substitution).intern(&Interner)
             }
             TyKind::Alias(AliasTy::Projection(proj_ty)) => {
-                let associated_ty_id = proj_ty.associated_ty_id;
-                let substitution = proj_ty.substitution.to_chalk(db);
-                chalk_ir::AliasTy::Projection(chalk_ir::ProjectionTy {
-                    associated_ty_id,
-                    substitution,
-                })
-                .cast(&Interner)
-                .intern(&Interner)
-            }
-            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
-                let opaque_ty_id = opaque_ty.opaque_ty_id;
-                let substitution = opaque_ty.substitution.to_chalk(db);
-                chalk_ir::AliasTy::Opaque(chalk_ir::OpaqueTy { opaque_ty_id, substitution })
+                chalk_ir::AliasTy::Projection(proj_ty.to_chalk(db))
                     .cast(&Interner)
                     .intern(&Interner)
             }
+            TyKind::Alias(AliasTy::Opaque(opaque_ty)) => {
+                chalk_ir::AliasTy::Opaque(opaque_ty.to_chalk(db)).cast(&Interner).intern(&Interner)
+            }
             TyKind::Placeholder(idx) => idx.to_ty::<Interner>(&Interner),
             TyKind::BoundVar(idx) => chalk_ir::TyKind::BoundVar(idx).intern(&Interner),
             TyKind::InferenceVar(..) => panic!("uncanonicalized infer ty"),
             TyKind::Dyn(dyn_ty) => {
+                let (bounds, binders) = dyn_ty.bounds.into_value_and_skipped_binders();
                 let where_clauses = chalk_ir::QuantifiedWhereClauses::from_iter(
                     &Interner,
-                    dyn_ty.bounds.value.interned().iter().cloned().map(|p| p.to_chalk(db)),
+                    bounds.interned().iter().cloned().map(|p| p.to_chalk(db)),
                 );
                 let bounded_ty = chalk_ir::DynTy {
-                    bounds: make_binders(where_clauses, 1),
-                    lifetime: LifetimeData::Static.intern(&Interner),
+                    bounds: chalk_ir::Binders::new(binders, where_clauses),
+                    lifetime: dyn_ty.lifetime,
                 };
                 chalk_ir::TyKind::Dyn(bounded_ty).intern(&Interner)
             }
-            TyKind::Unknown => chalk_ir::TyKind::Error.intern(&Interner),
+            TyKind::Error => chalk_ir::TyKind::Error.intern(&Interner),
         }
     }
     fn from_chalk(db: &dyn HirDatabase, chalk: chalk_ir::Ty<Interner>) -> Self {
         match chalk.data(&Interner).kind.clone() {
-            chalk_ir::TyKind::Error => TyKind::Unknown,
-            chalk_ir::TyKind::Array(ty, _size) => TyKind::Array(from_chalk(db, ty)),
+            chalk_ir::TyKind::Error => TyKind::Error,
+            chalk_ir::TyKind::Array(ty, size) => TyKind::Array(from_chalk(db, ty), size),
             chalk_ir::TyKind::Placeholder(idx) => TyKind::Placeholder(idx),
             chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(proj)) => {
-                let associated_ty = proj.associated_ty_id;
-                let parameters = from_chalk(db, proj.substitution);
-                TyKind::Alias(AliasTy::Projection(ProjectionTy {
-                    associated_ty_id: associated_ty,
-                    substitution: parameters,
-                }))
+                TyKind::Alias(AliasTy::Projection(from_chalk(db, proj)))
             }
             chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(opaque_ty)) => {
-                let opaque_ty_id = opaque_ty.opaque_ty_id;
-                let parameters = from_chalk(db, opaque_ty.substitution);
-                TyKind::Alias(AliasTy::Opaque(OpaqueTy { opaque_ty_id, substitution: parameters }))
+                TyKind::Alias(AliasTy::Opaque(from_chalk(db, opaque_ty)))
             }
             chalk_ir::TyKind::Function(chalk_ir::FnPointer {
                 num_binders,
@@ -133,26 +116,25 @@ impl ToChalk for Ty {
                 ..
             }) => {
                 assert_eq!(num_binders, 0);
-                let substs: Substitution = from_chalk(
-                    db,
-                    substitution.0.shifted_out(&Interner).expect("fn ptr should have no binders"),
-                );
-                TyKind::Function(FnPointer { num_args: (substs.len() - 1), sig, substs })
+                let substs = crate::FnSubst(from_chalk(db, substitution.0));
+                TyKind::Function(FnPointer { num_binders, sig, substitution: substs })
             }
             chalk_ir::TyKind::BoundVar(idx) => TyKind::BoundVar(idx),
-            chalk_ir::TyKind::InferenceVar(_iv, _kind) => TyKind::Unknown,
-            chalk_ir::TyKind::Dyn(where_clauses) => {
-                assert_eq!(where_clauses.bounds.binders.len(&Interner), 1);
-                let bounds = where_clauses
-                    .bounds
-                    .skip_binders()
-                    .iter(&Interner)
-                    .map(|c| from_chalk(db, c.clone()));
+            chalk_ir::TyKind::InferenceVar(_iv, _kind) => TyKind::Error,
+            chalk_ir::TyKind::Dyn(dyn_ty) => {
+                assert_eq!(dyn_ty.bounds.binders.len(&Interner), 1);
+                let (bounds, binders) = dyn_ty.bounds.into_value_and_skipped_binders();
+                let where_clauses = crate::QuantifiedWhereClauses::from_iter(
+                    &Interner,
+                    bounds.interned().iter().cloned().map(|p| from_chalk(db, p)),
+                );
                 TyKind::Dyn(crate::DynTy {
-                    bounds: crate::Binders::new(
-                        1,
-                        crate::QuantifiedWhereClauses::from_iter(&Interner, bounds),
-                    ),
+                    bounds: crate::Binders::new(binders, where_clauses),
+                    // HACK: we sometimes get lifetime variables back in solutions
+                    // from Chalk, and don't have the infrastructure to substitute
+                    // them yet. So for now we just turn them into 'static right
+                    // when we get them
+                    lifetime: static_lifetime(),
                 })
             }
 
@@ -172,7 +154,11 @@ impl ToChalk for Ty {
             chalk_ir::TyKind::Raw(mutability, ty) => TyKind::Raw(mutability, from_chalk(db, ty)),
             chalk_ir::TyKind::Slice(ty) => TyKind::Slice(from_chalk(db, ty)),
             chalk_ir::TyKind::Ref(mutability, _lifetime, ty) => {
-                TyKind::Ref(mutability, from_chalk(db, ty))
+                // HACK: we sometimes get lifetime variables back in solutions
+                // from Chalk, and don't have the infrastructure to substitute
+                // them yet. So for now we just turn them into 'static right
+                // when we get them
+                TyKind::Ref(mutability, static_lifetime(), from_chalk(db, ty))
             }
             chalk_ir::TyKind::Str => TyKind::Str,
             chalk_ir::TyKind::Never => TyKind::Never,
@@ -183,7 +169,7 @@ impl ToChalk for Ty {
 
             chalk_ir::TyKind::Closure(id, subst) => TyKind::Closure(id, from_chalk(db, subst)),
 
-            chalk_ir::TyKind::Foreign(foreign_def_id) => TyKind::ForeignType(foreign_def_id),
+            chalk_ir::TyKind::Foreign(foreign_def_id) => TyKind::Foreign(foreign_def_id),
             chalk_ir::TyKind::Generator(_, _) => unimplemented!(), // FIXME
             chalk_ir::TyKind::GeneratorWitness(_, _) => unimplemented!(), // FIXME
         }
@@ -191,50 +177,40 @@ impl ToChalk for Ty {
     }
 }
 
-/// We currently don't model lifetimes, but Chalk does. So, we have to insert a
-/// fake lifetime here, because Chalks built-in logic may expect it to be there.
-fn ref_to_chalk(
-    db: &dyn HirDatabase,
-    mutability: chalk_ir::Mutability,
-    ty: Ty,
-) -> chalk_ir::Ty<Interner> {
-    let arg = ty.to_chalk(db);
-    let lifetime = LifetimeData::Static.intern(&Interner);
-    chalk_ir::TyKind::Ref(mutability, lifetime, arg).intern(&Interner)
-}
+impl ToChalk for GenericArg {
+    type Chalk = chalk_ir::GenericArg<Interner>;
+
+    fn to_chalk(self, db: &dyn HirDatabase) -> Self::Chalk {
+        match self.interned() {
+            crate::GenericArgData::Ty(ty) => ty.clone().to_chalk(db).cast(&Interner),
+        }
+    }
 
-/// We currently don't model constants, but Chalk does. So, we have to insert a
-/// fake constant here, because Chalks built-in logic may expect it to be there.
-fn array_to_chalk(db: &dyn HirDatabase, ty: Ty) -> chalk_ir::Ty<Interner> {
-    let arg = ty.to_chalk(db);
-    let usize_ty = chalk_ir::TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner);
-    let const_ = chalk_ir::ConstData {
-        ty: usize_ty,
-        value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst { interned: () }),
-    }
-    .intern(&Interner);
-    chalk_ir::TyKind::Array(arg, const_).intern(&Interner)
+    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
+        match chalk.interned() {
+            chalk_ir::GenericArgData::Ty(ty) => Ty::from_chalk(db, ty.clone()).cast(&Interner),
+            chalk_ir::GenericArgData::Lifetime(_) => unimplemented!(),
+            chalk_ir::GenericArgData::Const(_) => unimplemented!(),
+        }
+    }
 }
 
 impl ToChalk for Substitution {
     type Chalk = chalk_ir::Substitution<Interner>;
 
     fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Substitution<Interner> {
-        chalk_ir::Substitution::from_iter(&Interner, self.iter().map(|ty| ty.clone().to_chalk(db)))
+        chalk_ir::Substitution::from_iter(
+            &Interner,
+            self.iter(&Interner).map(|ty| ty.clone().to_chalk(db)),
+        )
     }
 
     fn from_chalk(
         db: &dyn HirDatabase,
         parameters: chalk_ir::Substitution<Interner>,
     ) -> Substitution {
-        let tys = parameters
-            .iter(&Interner)
-            .map(|p| match p.ty(&Interner) {
-                Some(ty) => from_chalk(db, ty.clone()),
-                None => unimplemented!(),
-            })
-            .collect();
-        Substitution(tys)
+        let tys = parameters.iter(&Interner).map(|p| from_chalk(db, p.clone())).collect();
+        Substitution::intern(tys)
     }
 }
 
@@ -473,19 +449,25 @@ where
     type Chalk = chalk_ir::Binders<T::Chalk>;
 
     fn to_chalk(self, db: &dyn HirDatabase) -> chalk_ir::Binders<T::Chalk> {
-        chalk_ir::Binders::new(
-            chalk_ir::VariableKinds::from_iter(
-                &Interner,
-                std::iter::repeat(chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General))
-                    .take(self.num_binders),
-            ),
-            self.value.to_chalk(db),
-        )
+        let (value, binders) = self.into_value_and_skipped_binders();
+        chalk_ir::Binders::new(binders, value.to_chalk(db))
     }
 
     fn from_chalk(db: &dyn HirDatabase, binders: chalk_ir::Binders<T::Chalk>) -> crate::Binders<T> {
         let (v, b) = binders.into_value_and_skipped_binders();
-        crate::Binders::new(b.len(&Interner), from_chalk(db, v))
+        crate::Binders::new(b, from_chalk(db, v))
+    }
+}
+
+impl ToChalk for crate::ConstrainedSubst {
+    type Chalk = chalk_ir::ConstrainedSubst<Interner>;
+
+    fn to_chalk(self, _db: &dyn HirDatabase) -> Self::Chalk {
+        unimplemented!()
+    }
+
+    fn from_chalk(db: &dyn HirDatabase, chalk: Self::Chalk) -> Self {
+        ConstrainedSubst { subst: from_chalk(db, chalk.subst) }
     }
 }
 
@@ -511,7 +493,7 @@ pub(super) fn convert_where_clauses(
     let generic_predicates = db.generic_predicates(def);
     let mut result = Vec::with_capacity(generic_predicates.len());
     for pred in generic_predicates.iter() {
-        result.push(pred.clone().subst(substs).to_chalk(db));
+        result.push(pred.clone().substitute(&Interner, substs).to_chalk(db));
     }
     result
 }
@@ -523,27 +505,28 @@ pub(super) fn generic_predicate_to_inline_bound(
 ) -> Option<chalk_ir::Binders<rust_ir::InlineBound<Interner>>> {
     // An InlineBound is like a GenericPredicate, except the self type is left out.
     // We don't have a special type for this, but Chalk does.
-    let self_ty_shifted_in = self_ty.clone().shift_bound_vars(DebruijnIndex::ONE);
-    match &pred.value {
+    let self_ty_shifted_in = self_ty.clone().shifted_in_from(DebruijnIndex::ONE);
+    let (pred, binders) = pred.as_ref().into_value_and_skipped_binders();
+    match pred {
         WhereClause::Implemented(trait_ref) => {
-            if trait_ref.self_type_parameter() != &self_ty_shifted_in {
+            if trait_ref.self_type_parameter(&Interner) != self_ty_shifted_in {
                 // we can only convert predicates back to type bounds if they
                 // have the expected self type
                 return None;
             }
-            let args_no_self = trait_ref.substitution[1..]
+            let args_no_self = trait_ref.substitution.interned()[1..]
                 .iter()
                 .map(|ty| ty.clone().to_chalk(db).cast(&Interner))
                 .collect();
             let trait_bound = rust_ir::TraitBound { trait_id: trait_ref.trait_id, args_no_self };
-            Some(make_binders(rust_ir::InlineBound::TraitBound(trait_bound), pred.num_binders))
+            Some(chalk_ir::Binders::new(binders, rust_ir::InlineBound::TraitBound(trait_bound)))
         }
         WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection_ty), ty }) => {
-            if projection_ty.self_type_parameter() != &self_ty_shifted_in {
+            if projection_ty.self_type_parameter(&Interner) != self_ty_shifted_in {
                 return None;
             }
             let trait_ = projection_ty.trait_(db);
-            let args_no_self = projection_ty.substitution[1..]
+            let args_no_self = projection_ty.substitution.interned()[1..]
                 .iter()
                 .map(|ty| ty.clone().to_chalk(db).cast(&Interner))
                 .collect();
@@ -553,7 +536,10 @@ pub(super) fn generic_predicate_to_inline_bound(
                 associated_ty_id: projection_ty.associated_ty_id,
                 parameters: Vec::new(), // FIXME we don't support generic associated types yet
             };
-            Some(make_binders(rust_ir::InlineBound::AliasEqBound(alias_eq_bound), pred.num_binders))
+            Some(chalk_ir::Binders::new(
+                binders,
+                rust_ir::InlineBound::AliasEqBound(alias_eq_bound),
+            ))
         }
         _ => None,
     }