Some fixes after rebase.

Author: crlf0710

chalk-integration/src/lowering.rs

@@ -1,8 +1,8 @@
 use chalk_ir::cast::{Cast, Caster};
 use chalk_ir::interner::{ChalkIr, HasInterner};
 use chalk_ir::{
-    self, AssocTypeId, BoundVar, ClausePriority, DebruijnIndex, ImplId, OpaqueTyId, ParameterKinds, QuantifiedWhereClauses,
-    StructId, Substitution, TraitId,
+    self, AssocTypeId, BoundVar, ClausePriority, DebruijnIndex, ImplId, OpaqueTyId, ParameterKinds,
+    QuantifiedWhereClauses, StructId, Substitution, TraitId,
 };
 use chalk_parse::ast::*;
 use chalk_rust_ir as rust_ir;
@@ -635,11 +635,15 @@ impl LowerTypeKind for TraitDefn {
 
 impl LowerTypeKind for OpaqueTyDefn {
     fn lower_type_kind(&self) -> LowerResult<TypeKind> {
+        let interner = &ChalkIr;
         let binders: Vec<_> = self.parameter_kinds.iter().map(|p| p.lower()).collect();
         Ok(TypeKind {
             sort: TypeSort::Opaque,
             name: self.identifier.str,
-            binders: chalk_ir::Binders::new(binders.anonymize(), ()),
+            binders: chalk_ir::Binders::new(
+                ParameterKinds::from(interner, binders.anonymize()),
+                crate::Unit,
+            ),
         })
     }
 }

chalk-ir/src/lib.rs

@@ -1638,12 +1638,12 @@ impl<T: HasInterner> UCanonical<T> {
         subst.is_identity_subst(interner)
     }
 
-    pub fn trivial_substitution<I: Interner>(&self, interner: &I) -> Substitution<I> {
+    pub fn trivial_substitution(&self, interner: &T::Interner) -> Substitution<T::Interner> {
         let binders = &self.canonical.binders;
         Substitution::from(
             interner,
             binders
-                .iter()
+                .iter(interner)
                 .enumerate()
                 .map(|(index, pk)| {
                     let bound_var = BoundVar::new(DebruijnIndex::INNERMOST, index);

chalk-ir/src/tls.rs

@@ -1,8 +1,9 @@
 use crate::interner::ChalkIr;
 use crate::{
     debug::SeparatorTraitRef, AliasTy, ApplicationTy, AssocTypeId, CanonicalVarKinds, Goal, Goals,
-    Lifetime, OpaqueTy, OpaqueTyId, Parameter, ParameterKinds, ProgramClause, ProgramClauseImplication,
-    ProgramClauses, ProjectionTy, QuantifiedWhereClauses, StructId, Substitution, TraitId, Ty,
+    Lifetime, OpaqueTy, OpaqueTyId, Parameter, ParameterKinds, ProgramClause,
+    ProgramClauseImplication, ProgramClauses, ProjectionTy, QuantifiedWhereClauses, StructId,
+    Substitution, TraitId, Ty,
 };
 use std::cell::RefCell;
 use std::fmt;

chalk-solve/src/clauses/generalize.rs

@@ -9,8 +9,9 @@
 use chalk_engine::fallible::Fallible;
 use chalk_ir::{
     fold::{Fold, Folder},
-    interner::Interner,
-    Binders, BoundVar, DebruijnIndex, Lifetime, LifetimeData, ParameterKind, Ty, TyData,
+    interner::{HasInterner, Interner},
+    Binders, BoundVar, DebruijnIndex, Lifetime, LifetimeData, ParameterKind, ParameterKinds, Ty,
+    TyData,
 };
 use std::collections::HashMap;
 
@@ -21,7 +22,11 @@ pub struct Generalize<'i, I: Interner> {
 }
 
 impl<I: Interner> Generalize<'_, I> {
-    pub fn apply<T: Fold<I, I>>(interner: &I, value: &T) -> Binders<T::Result> {
+    pub fn apply<T>(interner: &I, value: &T) -> Binders<T::Result>
+    where
+        T: HasInterner<Interner = I> + Fold<I, I>,
+        T::Result: HasInterner<Interner = I>,
+    {
         let mut generalize = Generalize {
             binders: Vec::new(),
             mapping: HashMap::new(),
@@ -30,7 +35,7 @@ impl<I: Interner> Generalize<'_, I> {
         let value = value
             .fold_with(&mut generalize, DebruijnIndex::INNERMOST)
             .unwrap();
-        Binders::new(generalize.binders, value)
+        Binders::new(ParameterKinds::from(interner, generalize.binders), value)
     }
 }
 

chalk-solve/src/recursive.rs

@@ -366,7 +366,10 @@ impl<'me, I: Interner> Solver<'me, I> {
                 ProgramClauseData::Implies(implication) => {
                     let res = self.solve_via_implication(
                         canonical_goal,
-                        &Binders::new(vec![], implication.clone()),
+                        &Binders::new(
+                            ParameterKinds::from(self.program.interner(), vec![]),
+                            implication.clone(),
+                        ),
                         minimums,
                     );
                     if let (Ok(solution), priority) = res {
@@ -521,10 +524,10 @@ fn combine_with_priorities<I: Interner>(
                 );
                 (higher, ClausePriority::High)
             } else {
-                (higher.combine(lower), ClausePriority::High)
+                (higher.combine(lower, interner), ClausePriority::High)
             }
         }
-        (_, _, a, b) => (a.combine(b), prio_a),
+        (_, _, a, b) => (a.combine(b, interner), prio_a),
     }
 }
 

chalk-solve/src/recursive/fulfill.rs

@@ -108,7 +108,7 @@ impl<'s, 'db, I: Interner> Fulfill<'s, 'db, I> {
     /// Wraps `InferenceTable::instantiate_in`
     pub(crate) fn instantiate_binders_existentially<T>(
         &mut self,
-        arg: impl IntoBindersAndValue<Value = T>,
+        arg: impl IntoBindersAndValue<'s, I, Value = T>,
     ) -> T::Result
     where
         T: Fold<I, I>,

chalk-solve/src/solve.rs

@@ -69,14 +69,18 @@ impl<I: Interner> Solution<I> {
     //    Clone`.
     //
     // But you get the idea.
-    pub(crate) fn combine(self, other: Solution<I>) -> Solution<I> {
+    pub(crate) fn combine(self, other: Solution<I>, interner: &I) -> Solution<I> {
         use self::Guidance::*;
 
         if self == other {
             return self;
         }
 
-        debug!("combine {} with {}", self, other);
+        debug!(
+            "combine {} with {}",
+            self.display(interner),
+            other.display(interner)
+        );
 
         // Otherwise, always downgrade to Ambig: