Propagate results of Fold signature change up the call graph

Author: ecstatic-morse

chalk-engine/src/logic.rs

@@ -149,7 +149,7 @@ impl<I: Interner> Forest<I> {
         Forest::canonicalize_strand_from(
             context,
             &mut infer,
-            &ex_clause,
+            ex_clause,
             selected_subgoal,
             last_pursued_time,
         )
@@ -158,12 +158,12 @@ impl<I: Interner> Forest<I> {
     fn canonicalize_strand_from(
         context: &SlgContextOps<I>,
         infer: &mut TruncatingInferenceTable<I>,
-        ex_clause: &ExClause<I>,
+        ex_clause: ExClause<I>,
         selected_subgoal: Option<SelectedSubgoal>,
         last_pursued_time: TimeStamp,
     ) -> CanonicalStrand<I> {
         let canonical_ex_clause =
-            infer.canonicalize_ex_clause(context.program().interner(), &ex_clause);
+            infer.canonicalize_ex_clause(context.program().interner(), ex_clause);
         CanonicalStrand {
             canonical_ex_clause,
             selected_subgoal,
@@ -194,10 +194,10 @@ impl<I: Interner> Forest<I> {
         // Subgoal abstraction:
         let (ucanonical_subgoal, universe_map) = match subgoal {
             Literal::Positive(subgoal) => {
-                Forest::abstract_positive_literal(context, infer, subgoal)?
+                Forest::abstract_positive_literal(context, infer, subgoal.clone())?
             }
             Literal::Negative(subgoal) => {
-                Forest::abstract_negative_literal(context, infer, subgoal)?
+                Forest::abstract_negative_literal(context, infer, subgoal.clone())?
             }
         };
 
@@ -257,7 +257,7 @@ impl<I: Interner> Forest<I> {
             chalk_solve::infer::InferenceTable::from_canonical(
                 context.program().interner(),
                 goal.universes,
-                &goal.canonical,
+                goal.canonical,
             );
         let mut infer = TruncatingInferenceTable::new(context.max_size(), infer);
         let goal_data = goal.data(context.program().interner());
@@ -350,9 +350,9 @@ impl<I: Interner> Forest<I> {
     fn abstract_positive_literal(
         context: &SlgContextOps<I>,
         infer: &mut TruncatingInferenceTable<I>,
-        subgoal: &InEnvironment<Goal<I>>,
+        subgoal: InEnvironment<Goal<I>>,
     ) -> Option<(UCanonical<InEnvironment<Goal<I>>>, UniverseMap)> {
-        if infer.goal_needs_truncation(context.program().interner(), subgoal) {
+        if infer.goal_needs_truncation(context.program().interner(), &subgoal) {
             None
         } else {
             Some(infer.fully_canonicalize_goal(context.program().interner(), subgoal))
@@ -369,7 +369,7 @@ impl<I: Interner> Forest<I> {
     fn abstract_negative_literal(
         context: &SlgContextOps<I>,
         infer: &mut TruncatingInferenceTable<I>,
-        subgoal: &InEnvironment<Goal<I>>,
+        subgoal: InEnvironment<Goal<I>>,
     ) -> Option<(UCanonical<InEnvironment<Goal<I>>>, UniverseMap)> {
         // First, we have to check that the selected negative literal
         // is ground, and invert any universally quantified variables.
@@ -413,7 +413,7 @@ impl<I: Interner> Forest<I> {
         if infer.goal_needs_truncation(context.program().interner(), &inverted_subgoal) {
             None
         } else {
-            Some(infer.fully_canonicalize_goal(context.program().interner(), &inverted_subgoal))
+            Some(infer.fully_canonicalize_goal(context.program().interner(), inverted_subgoal))
         }
     }
 }
@@ -494,7 +494,7 @@ impl<'forest, I: Interner> SolveState<'forest, I> {
                         let (_, _, ex_clause) = chalk_solve::infer::InferenceTable::from_canonical(
                             context.program().interner(),
                             num_universes,
-                            &strand.canonical_ex_clause,
+                            strand.canonical_ex_clause.clone(),
                         );
                         let time_eligble = strand.last_pursued_time < clock;
                         let mode_eligble = match (table_answer_mode, ex_clause.ambiguous) {
@@ -515,7 +515,7 @@ impl<'forest, I: Interner> SolveState<'forest, I> {
                             chalk_solve::infer::InferenceTable::from_canonical(
                                 context.program().interner(),
                                 num_universes,
-                                &canonical_ex_clause,
+                                canonical_ex_clause,
                             );
                         let infer = TruncatingInferenceTable::new(context.max_size(), infer);
                         Strand {
@@ -660,7 +660,7 @@ impl<'forest, I: Interner> SolveState<'forest, I> {
                     &mut strand.ex_clause,
                     &subgoal,
                     &table_goal,
-                    &answer_subst,
+                    answer_subst,
                 ) {
                     Ok(()) => {
                         let Strand {
@@ -1078,7 +1078,7 @@ impl<'forest, I: Interner> SolveState<'forest, I> {
         ) = chalk_solve::infer::InferenceTable::from_canonical(
             self.context.program().interner(),
             num_universes,
-            &answer.subst,
+            answer.subst.clone(),
         );
         let table = TruncatingInferenceTable::new(self.context.max_size(), infer);
 
@@ -1414,8 +1414,10 @@ impl<'forest, I: Interner> SolveState<'forest, I> {
         let filtered_delayed_subgoals = delayed_subgoals
             .into_iter()
             .filter(|delayed_subgoal| {
-                let (canonicalized, _) = infer
-                    .fully_canonicalize_goal(self.context.program().interner(), delayed_subgoal);
+                let (canonicalized, _) = infer.fully_canonicalize_goal(
+                    self.context.program().interner(),
+                    delayed_subgoal.clone(),
+                );
                 *table_goal != canonicalized
             })
             .collect();

chalk-engine/src/normalize_deep.rs

@@ -24,7 +24,7 @@ impl<I: Interner> DeepNormalizer<'_, '_, I> {
     pub fn normalize_deep<T: Fold<I>>(
         table: &mut InferenceTable<I>,
         interner: &I,
-        value: &T,
+        value: T,
     ) -> T::Result {
         value
             .fold_with(
@@ -53,6 +53,7 @@ where
         match self.table.probe_var(var) {
             Some(ty) => Ok(ty
                 .assert_ty_ref(interner)
+                .clone()
                 .fold_with(self, DebruijnIndex::INNERMOST)?
                 .shifted_in(interner)), // FIXME shift
             None => {
@@ -72,6 +73,7 @@ where
         match self.table.probe_var(var) {
             Some(l) => Ok(l
                 .assert_lifetime_ref(interner)
+                .clone()
                 .fold_with(self, DebruijnIndex::INNERMOST)?
                 .shifted_in(interner)),
             None => Ok(var.to_lifetime(interner)), // FIXME shift
@@ -80,17 +82,18 @@ where
 
     fn fold_inference_const(
         &mut self,
-        ty: &Ty<I>,
+        ty: Ty<I>,
         var: InferenceVar,
         _outer_binder: DebruijnIndex,
     ) -> Fallible<Const<I>> {
         let interner = self.interner;
         match self.table.probe_var(var) {
             Some(c) => Ok(c
                 .assert_const_ref(interner)
+                .clone()
                 .fold_with(self, DebruijnIndex::INNERMOST)?
                 .shifted_in(interner)),
-            None => Ok(var.to_const(interner, ty.clone())), // FIXME shift
+            None => Ok(var.to_const(interner, ty)), // FIXME shift
         }
     }
 
@@ -149,8 +152,8 @@ mod test {
         // _which_ of 'b' and 'c' becomes the root. We need to normalize
         // "b" too, then, to ensure we get a consistent result.
         assert_eq!(
-            DeepNormalizer::normalize_deep(&mut table, interner, &a),
-            ty!(apply (item 0) (expr DeepNormalizer::normalize_deep(&mut table, interner, &b))),
+            DeepNormalizer::normalize_deep(&mut table, interner, a.clone()),
+            ty!(apply (item 0) (expr DeepNormalizer::normalize_deep(&mut table, interner, b.clone()))),
         );
         table
             .relate(
@@ -163,7 +166,7 @@ mod test {
             )
             .unwrap();
         assert_eq!(
-            DeepNormalizer::normalize_deep(&mut table, interner, &a),
+            DeepNormalizer::normalize_deep(&mut table, interner, a),
             ty!(apply (item 0) (apply (item 1)))
         );
     }

chalk-engine/src/simplify.rs

@@ -37,13 +37,17 @@ impl<I: Interner> Forest<I> {
         while let Some((environment, goal)) = pending_goals.pop() {
             match goal.data(context.program().interner()) {
                 GoalData::Quantified(QuantifierKind::ForAll, subgoal) => {
-                    let subgoal = infer
-                        .instantiate_binders_universally(context.program().interner(), &subgoal);
+                    let subgoal = infer.instantiate_binders_universally(
+                        context.program().interner(),
+                        subgoal.clone(),
+                    );
                     pending_goals.push((environment, subgoal.clone()));
                 }
                 GoalData::Quantified(QuantifierKind::Exists, subgoal) => {
-                    let subgoal = infer
-                        .instantiate_binders_existentially(context.program().interner(), &subgoal);
+                    let subgoal = infer.instantiate_binders_existentially(
+                        context.program().interner(),
+                        subgoal.clone(),
+                    );
                     pending_goals.push((environment, subgoal.clone()));
                 }
                 GoalData::Implies(wc, subgoal) => {

chalk-engine/src/slg.rs

@@ -61,12 +61,12 @@ impl<I: Interner> SlgContextOps<'_, I> {
         let (mut infer, subst, _) = InferenceTable::from_canonical(
             self.program.interner(),
             goal.universes,
-            &goal.canonical,
+            goal.canonical.clone(),
         );
         infer
             .canonicalize(
                 self.program.interner(),
-                &ConstrainedSubst {
+                ConstrainedSubst {
                     subst,
                     constraints: Constraints::empty(self.program.interner()),
                 },
@@ -130,21 +130,18 @@ pub trait ResolventOps<I: Interner> {
         ex_clause: &mut ExClause<I>,
         selected_goal: &InEnvironment<Goal<I>>,
         answer_table_goal: &Canonical<InEnvironment<Goal<I>>>,
-        canonical_answer_subst: &Canonical<AnswerSubst<I>>,
+        canonical_answer_subst: Canonical<AnswerSubst<I>>,
     ) -> Fallible<()>;
 }
 
 /// Methods for unifying and manipulating terms and binders.
 pub trait UnificationOps<I: Interner> {
     // Used by: simplify
-    fn instantiate_binders_universally(&mut self, interner: &I, arg: &Binders<Goal<I>>) -> Goal<I>;
+    fn instantiate_binders_universally(&mut self, interner: &I, arg: Binders<Goal<I>>) -> Goal<I>;
 
     // Used by: simplify
-    fn instantiate_binders_existentially(
-        &mut self,
-        interner: &I,
-        arg: &Binders<Goal<I>>,
-    ) -> Goal<I>;
+    fn instantiate_binders_existentially(&mut self, interner: &I, arg: Binders<Goal<I>>)
+        -> Goal<I>;
 
     // Used by: logic (but for debugging only)
     fn debug_ex_clause<'v>(&mut self, interner: &I, value: &'v ExClause<I>) -> Box<dyn Debug + 'v>;
@@ -153,14 +150,14 @@ pub trait UnificationOps<I: Interner> {
     fn fully_canonicalize_goal(
         &mut self,
         interner: &I,
-        value: &InEnvironment<Goal<I>>,
+        value: InEnvironment<Goal<I>>,
     ) -> (UCanonical<InEnvironment<Goal<I>>>, UniverseMap);
 
     // Used by: logic
     fn canonicalize_ex_clause(
         &mut self,
         interner: &I,
-        value: &ExClause<I>,
+        value: ExClause<I>,
     ) -> Canonical<ExClause<I>>;
 
     // Used by: logic
@@ -184,7 +181,7 @@ pub trait UnificationOps<I: Interner> {
     fn invert_goal(
         &mut self,
         interner: &I,
-        value: &InEnvironment<Goal<I>>,
+        value: InEnvironment<Goal<I>>,
     ) -> Option<InEnvironment<Goal<I>>>;
 
     /// First unify the parameters, then add the residual subgoals
@@ -239,14 +236,14 @@ impl<I: Interner> TruncateOps<I> for TruncatingInferenceTable<I> {
 }
 
 impl<I: Interner> UnificationOps<I> for TruncatingInferenceTable<I> {
-    fn instantiate_binders_universally(&mut self, interner: &I, arg: &Binders<Goal<I>>) -> Goal<I> {
+    fn instantiate_binders_universally(&mut self, interner: &I, arg: Binders<Goal<I>>) -> Goal<I> {
         self.infer.instantiate_binders_universally(interner, arg)
     }
 
     fn instantiate_binders_existentially(
         &mut self,
         interner: &I,
-        arg: &Binders<Goal<I>>,
+        arg: Binders<Goal<I>>,
     ) -> Goal<I> {
         self.infer.instantiate_binders_existentially(interner, arg)
     }
@@ -255,14 +252,14 @@ impl<I: Interner> UnificationOps<I> for TruncatingInferenceTable<I> {
         Box::new(DeepNormalizer::normalize_deep(
             &mut self.infer,
             interner,
-            value,
+            value.clone(),
         ))
     }
 
     fn fully_canonicalize_goal(
         &mut self,
         interner: &I,
-        value: &InEnvironment<Goal<I>>,
+        value: InEnvironment<Goal<I>>,
     ) -> (UCanonical<InEnvironment<Goal<I>>>, UniverseMap) {
         let canonicalized_goal = self.infer.canonicalize(interner, value).quantified;
         let UCanonicalized {
@@ -275,7 +272,7 @@ impl<I: Interner> UnificationOps<I> for TruncatingInferenceTable<I> {
     fn canonicalize_ex_clause(
         &mut self,
         interner: &I,
-        value: &ExClause<I>,
+        value: ExClause<I>,
     ) -> Canonical<ExClause<I>> {
         self.infer.canonicalize(interner, value).quantified
     }
@@ -289,7 +286,7 @@ impl<I: Interner> UnificationOps<I> for TruncatingInferenceTable<I> {
         self.infer
             .canonicalize(
                 interner,
-                &ConstrainedSubst {
+                ConstrainedSubst {
                     subst,
                     constraints: Constraints::from_iter(interner, constraints),
                 },
@@ -307,7 +304,7 @@ impl<I: Interner> UnificationOps<I> for TruncatingInferenceTable<I> {
         self.infer
             .canonicalize(
                 interner,
-                &AnswerSubst {
+                AnswerSubst {
                     subst,
                     constraints: Constraints::from_iter(interner, constraints),
                     delayed_subgoals,
@@ -319,7 +316,7 @@ impl<I: Interner> UnificationOps<I> for TruncatingInferenceTable<I> {
     fn invert_goal(
         &mut self,
         interner: &I,
-        value: &InEnvironment<Goal<I>>,
+        value: InEnvironment<Goal<I>>,
     ) -> Option<InEnvironment<Goal<I>>> {
         self.infer.invert(interner, value)
     }

chalk-engine/src/slg/aggregate.rs

@@ -181,7 +181,7 @@ fn merge_into_guidance<I: Interner>(
 
     let aggr_subst = Substitution::from_iter(interner, aggr_generic_args);
 
-    infer.canonicalize(interner, &aggr_subst).quantified
+    infer.canonicalize(interner, aggr_subst).quantified
 }
 
 fn is_trivial<I: Interner>(interner: &I, subst: &Canonical<Substitution<I>>) -> bool {