Rebase fixes

Author: flodiebold

chalk-ir/src/lib.rs

@@ -547,7 +547,7 @@ impl DebruijnIndex {
 /// known. It is referenced within the type using `^1`, indicating
 /// a bound type with debruijn index 1 (i.e., skipping through one
 /// level of binder).
-#[derive(Clone, PartialEq, Eq, Hash, Fold, Visit)]
+#[derive(Clone, PartialEq, Eq, Hash, Fold, Visit, HasInterner)]
 pub struct DynTy<I: Interner> {
     pub bounds: Binders<QuantifiedWhereClauses<I>>,
 }

chalk-ir/src/visit/boring_impls.rs

@@ -5,7 +5,7 @@
 //! The more interesting impls of `Visit` remain in the `visit` module.
 
 use crate::{
-    AssocTypeId, DebruijnIndex, Goals, ImplId, Interner, Parameter, ParameterKind,
+    AssocTypeId, ClausePriority, DebruijnIndex, Goals, ImplId, Interner, Parameter, ParameterKind,
     PlaceholderIndex, ProgramClause, ProgramClauseData, ProgramClauses, QuantifiedWhereClauses,
     QuantifierKind, StructId, Substitution, SuperVisit, TraitId, UniverseIndex, Visit, VisitResult,
     Visitor,
@@ -205,6 +205,7 @@ const_visit!(QuantifierKind);
 const_visit!(DebruijnIndex);
 const_visit!(chalk_engine::TableIndex);
 const_visit!(chalk_engine::TimeStamp);
+const_visit!(ClausePriority);
 const_visit!(());
 
 #[macro_export]

chalk-solve/src/clauses.rs

@@ -415,7 +415,7 @@ fn program_clauses_for_env<'db, I: Interner>(
     environment: &Environment<I>,
     clauses: &mut Vec<ProgramClause<I>>,
 ) {
-    clauses.extend(environment.clauses.iter().cloned());
+    clauses.extend(environment.clauses.iter(db.interner()).cloned());
 
     let mut last_round = FxHashSet::default();
     elaborate_env_clauses(

chalk-solve/src/recursive/fulfill.rs

@@ -183,7 +183,8 @@ impl<'s, 'db, I: Interner> Fulfill<'s, 'db, I> {
                 self.push_goal(environment, subgoal)?;
             }
             GoalData::Implies(wc, subgoal) => {
-                let new_environment = &environment.add_clauses(wc.iter().cloned());
+                let new_environment =
+                    &environment.add_clauses(interner, wc.iter(interner).cloned());
                 self.push_goal(new_environment, subgoal.clone())?;
             }
             GoalData::All(goals) => {
@@ -293,7 +294,7 @@ impl<'s, 'db, I: Interner> Fulfill<'s, 'db, I> {
         // We use the empty environment for unification here because we're
         // really just doing a substitution on unconstrained variables, which is
         // guaranteed to succeed without generating any new constraints.
-        let empty_env = &Environment::new();
+        let empty_env = &Environment::new(self.solver.program.interner());
 
         for (i, free_var) in free_vars.into_iter().enumerate() {
             let subst_value = subst.at(self.interner(), i);

chalk-solve/src/recursive/mod.rs

@@ -395,13 +395,13 @@ impl<'me, I: Interner> Solver<'me, I> {
         for program_clause in clauses {
             debug_heading!("clause={:?}", program_clause);
 
-            match program_clause {
-                ProgramClause::Implies(implication) => {
+            match program_clause.data(self.program.interner()) {
+                ProgramClauseData::Implies(implication) => {
                     let res = self.solve_via_implication(
                         canonical_goal,
-                        Binders {
+                        &Binders {
                             binders: vec![],
-                            value: implication,
+                            value: implication.clone(),
                         },
                         minimums,
                     );
@@ -436,7 +436,7 @@ impl<'me, I: Interner> Solver<'me, I> {
                         debug!("error");
                     }
                 }
-                ProgramClause::ForAll(implication) => {
+                ProgramClauseData::ForAll(implication) => {
                     let res = self.solve_via_implication(canonical_goal, implication, minimums);
                     if let (Ok(solution), priority) = res {
                         debug!("ok: solution={:?} prio={:?}", solution, priority);
@@ -480,7 +480,7 @@ impl<'me, I: Interner> Solver<'me, I> {
     fn solve_via_implication(
         &mut self,
         canonical_goal: &UCanonical<InEnvironment<DomainGoal<I>>>,
-        clause: Binders<ProgramClauseImplication<I>>,
+        clause: &Binders<ProgramClauseImplication<I>>,
         minimums: &mut Minimums,
     ) -> (Fallible<Solution<I>>, ClausePriority) {
         info_heading!(
@@ -496,7 +496,7 @@ impl<'me, I: Interner> Solver<'me, I> {
             consequence,
             conditions,
             priority: _,
-        } = fulfill.instantiate_binders_existentially(&clause);
+        } = fulfill.instantiate_binders_existentially(clause);
 
         debug!("the subst is {:?}", subst);
 

chalk-solve/src/solve/slg/resolvent.rs

@@ -85,8 +85,8 @@ impl<I: Interner> context::ResolventOps<SlgContext<I>> for TruncatingInferenceTa
             conditions,
             priority: _,
         } = match clause.data(interner) {
-            ProgramClause::Implies(implication) => implication.clone(),
-            ProgramClause::ForAll(implication) => self
+            ProgramClauseData::Implies(implication) => implication.clone(),
+            ProgramClauseData::ForAll(implication) => self
                 .infer
                 .instantiate_binders_existentially(interner, implication),
         };