Use owned copies of Interner rather than refs

Author: eggyal

chalk-derive/src/lib.rs

@@ -177,14 +177,11 @@ fn derive_any_visit(
     s.bound_impl(
         quote!(::chalk_ir::visit:: #trait_name <#interner>),
         quote! {
-            fn #method_name <'i, B>(
+            fn #method_name <B>(
                 &self,
-                visitor: &mut dyn ::chalk_ir::visit::Visitor < 'i, #interner, BreakTy = B >,
+                visitor: &mut dyn ::chalk_ir::visit::Visitor < #interner, BreakTy = B >,
                 outer_binder: ::chalk_ir::DebruijnIndex,
-            ) -> std::ops::ControlFlow<B>
-            where
-                #interner: 'i
-            {
+            ) -> std::ops::ControlFlow<B> {
                 match *self {
                     #body
                 }
@@ -241,15 +238,12 @@ fn derive_zip(mut s: synstructure::Structure) -> TokenStream {
         quote!(::chalk_ir::zip::Zip<#interner>),
         quote! {
 
-            fn zip_with<'i, Z: ::chalk_ir::zip::Zipper<'i, #interner>>(
+            fn zip_with<Z: ::chalk_ir::zip::Zipper<#interner>>(
                 zipper: &mut Z,
                 variance: ::chalk_ir::Variance,
                 a: &Self,
                 b: &Self,
-            ) -> ::chalk_ir::Fallible<()>
-            where
-                #interner: 'i,
-                {
+            ) -> ::chalk_ir::Fallible<()> {
                     match (a, b) { #body }
                 }
         },
@@ -299,14 +293,11 @@ fn derive_fold(mut s: synstructure::Structure) -> TokenStream {
         quote! {
             type Result = #result;
 
-            fn fold_with<'i, E>(
+            fn fold_with<E>(
                 self,
-                folder: &mut dyn ::chalk_ir::fold::Folder < 'i, #interner, Error = E >,
+                folder: &mut dyn ::chalk_ir::fold::Folder < #interner, Error = E >,
                 outer_binder: ::chalk_ir::DebruijnIndex,
-            ) -> ::std::result::Result<Self::Result, E>
-            where
-                #interner: 'i,
-            {
+            ) -> ::std::result::Result<Self::Result, E> {
                 Ok(match self { #body })
             }
         },

chalk-engine/src/normalize_deep.rs

@@ -4,12 +4,12 @@ use chalk_ir::interner::Interner;
 use chalk_ir::*;
 use chalk_solve::infer::InferenceTable;
 
-pub(crate) struct DeepNormalizer<'table, 'i, I: Interner> {
+pub(crate) struct DeepNormalizer<'table, I: Interner> {
     table: &'table mut InferenceTable<I>,
-    interner: &'i I,
+    interner: I,
 }
 
-impl<I: Interner> DeepNormalizer<'_, '_, I> {
+impl<I: Interner> DeepNormalizer<'_, I> {
     /// Given a value `value` with variables in it, replaces those variables
     /// with their instantiated values (if any). Uninstantiated variables are
     /// left as-is.
@@ -23,7 +23,7 @@ impl<I: Interner> DeepNormalizer<'_, '_, I> {
     /// variables.
     pub fn normalize_deep<T: Fold<I>>(
         table: &mut InferenceTable<I>,
-        interner: &I,
+        interner: I,
         value: T,
     ) -> T::Result {
         value
@@ -35,13 +35,10 @@ impl<I: Interner> DeepNormalizer<'_, '_, I> {
     }
 }
 
-impl<'i, I: Interner> Folder<'i, I> for DeepNormalizer<'_, 'i, I>
-where
-    I: 'i,
-{
+impl<I: Interner> Folder<I> for DeepNormalizer<'_, I> {
     type Error = NoSolution;
 
-    fn as_dyn(&mut self) -> &mut dyn Folder<'i, I, Error = Self::Error> {
+    fn as_dyn(&mut self) -> &mut dyn Folder<I, Error = Self::Error> {
         self
     }
 
@@ -103,7 +100,7 @@ where
         true
     }
 
-    fn interner(&self) -> &'i I {
+    fn interner(&self) -> I {
         self.interner
     }
 }
@@ -122,17 +119,17 @@ mod test {
     struct TestDatabase;
     impl UnificationDatabase<ChalkIr> for TestDatabase {
         fn fn_def_variance(&self, _fn_def_id: FnDefId<ChalkIr>) -> Variances<ChalkIr> {
-            Variances::from_iter(&ChalkIr, [Variance::Invariant; 20].iter().copied())
+            Variances::from_iter(ChalkIr, [Variance::Invariant; 20].iter().copied())
         }
 
         fn adt_variance(&self, _adt_id: AdtId<ChalkIr>) -> Variances<ChalkIr> {
-            Variances::from_iter(&ChalkIr, [Variance::Invariant; 20].iter().copied())
+            Variances::from_iter(ChalkIr, [Variance::Invariant; 20].iter().copied())
         }
     }
 
     #[test]
     fn infer() {
-        let interner = &ChalkIr;
+        let interner = ChalkIr;
         let mut table: InferenceTable<ChalkIr> = InferenceTable::new();
         let environment0 = Environment::new(interner);
         let a = table.new_variable(U0).to_ty(interner);

chalk-engine/src/slg.rs

@@ -91,7 +91,7 @@ pub trait ResolventOps<I: Interner> {
     fn resolvent_clause(
         &mut self,
         ops: &dyn UnificationDatabase<I>,
-        interner: &I,
+        interner: I,
         environment: &Environment<I>,
         goal: &DomainGoal<I>,
         subst: &Substitution<I>,
@@ -100,7 +100,7 @@ pub trait ResolventOps<I: Interner> {
 
     fn apply_answer_subst(
         &mut self,
-        interner: &I,
+        interner: I,
         unification_database: &dyn UnificationDatabase<I>,
         ex_clause: &mut ExClause<I>,
         selected_goal: &InEnvironment<Goal<I>>,
@@ -110,23 +110,23 @@ pub trait ResolventOps<I: Interner> {
 }
 
 trait SubstitutionExt<I: Interner> {
-    fn may_invalidate(&self, interner: &I, subst: &Canonical<Substitution<I>>) -> bool;
+    fn may_invalidate(&self, interner: I, subst: &Canonical<Substitution<I>>) -> bool;
 }
 
 impl<I: Interner> SubstitutionExt<I> for Substitution<I> {
-    fn may_invalidate(&self, interner: &I, subst: &Canonical<Substitution<I>>) -> bool {
+    fn may_invalidate(&self, interner: I, subst: &Canonical<Substitution<I>>) -> bool {
         self.iter(interner)
             .zip(subst.value.iter(interner))
             .any(|(new, current)| MayInvalidate { interner }.aggregate_generic_args(new, current))
     }
 }
 
 // This is a struct in case we need to add state at any point like in AntiUnifier
-struct MayInvalidate<'i, I> {
-    interner: &'i I,
+struct MayInvalidate<I> {
+    interner: I,
 }
 
-impl<I: Interner> MayInvalidate<'_, I> {
+impl<I: Interner> MayInvalidate<I> {
     fn aggregate_generic_args(&mut self, new: &GenericArg<I>, current: &GenericArg<I>) -> bool {
         let interner = self.interner;
         match (new.data(interner), current.data(interner)) {

chalk-engine/src/slg/aggregate.rs

@@ -129,7 +129,7 @@ impl<I: Interner> AggregateOps<I> for SlgContextOps<'_, I> {
 /// u32` and the new answer is `?0 = i32`, then the guidance would
 /// become `?0 = ?X` (where `?X` is some fresh variable).
 fn merge_into_guidance<I: Interner>(
-    interner: &I,
+    interner: I,
     root_goal: &Canonical<InEnvironment<Goal<I>>>,
     guidance: Canonical<Substitution<I>>,
     answer: &Canonical<ConstrainedSubst<I>>,
@@ -184,7 +184,7 @@ fn merge_into_guidance<I: Interner>(
     infer.canonicalize(interner, aggr_subst).quantified
 }
 
-fn is_trivial<I: Interner>(interner: &I, subst: &Canonical<Substitution<I>>) -> bool {
+fn is_trivial<I: Interner>(interner: I, subst: &Canonical<Substitution<I>>) -> bool {
     // A subst is trivial if..
     subst
         .value
@@ -226,13 +226,13 @@ fn is_trivial<I: Interner>(interner: &I, subst: &Canonical<Substitution<I>>) ->
 /// inference variables.
 ///
 /// [Anti-unification]: https://en.wikipedia.org/wiki/Anti-unification_(computer_science)
-struct AntiUnifier<'infer, 'intern, I: Interner> {
+struct AntiUnifier<'infer, I: Interner> {
     infer: &'infer mut InferenceTable<I>,
     universe: UniverseIndex,
-    interner: &'intern I,
+    interner: I,
 }
 
-impl<I: Interner> AntiUnifier<'_, '_, I> {
+impl<I: Interner> AntiUnifier<'_, I> {
     fn aggregate_tys(&mut self, ty0: &Ty<I>, ty1: &Ty<I>) -> Ty<I> {
         let interner = self.interner;
         match (ty0.kind(interner), ty1.kind(interner)) {
@@ -587,7 +587,7 @@ mod test {
         let mut anti_unifier = AntiUnifier {
             infer: &mut infer,
             universe: UniverseIndex::root(),
-            interner: &ChalkIr,
+            interner: ChalkIr,
         };
 
         let ty = anti_unifier.aggregate_tys(
@@ -601,7 +601,7 @@ mod test {
     #[test]
     fn vec_i32_vs_vec_i32() {
         use chalk_integration::interner::ChalkIr;
-        let interner = &ChalkIr;
+        let interner = ChalkIr;
         let mut infer: InferenceTable<ChalkIr> = InferenceTable::new();
         let mut anti_unifier = AntiUnifier {
             interner,
@@ -620,7 +620,7 @@ mod test {
     #[test]
     fn vec_x_vs_vec_y() {
         use chalk_integration::interner::ChalkIr;
-        let interner = &ChalkIr;
+        let interner = ChalkIr;
         let mut infer: InferenceTable<ChalkIr> = InferenceTable::new();
         let mut anti_unifier = AntiUnifier {
             interner,

chalk-engine/src/slg/resolvent.rs

@@ -59,7 +59,7 @@ impl<I: Interner> ResolventOps<I> for InferenceTable<I> {
     fn resolvent_clause(
         &mut self,
         db: &dyn UnificationDatabase<I>,
-        interner: &I,
+        interner: I,
         environment: &Environment<I>,
         goal: &DomainGoal<I>,
         subst: &Substitution<I>,
@@ -214,7 +214,7 @@ impl<I: Interner> ResolventOps<I> for InferenceTable<I> {
     #[instrument(level = "debug", skip(self, interner))]
     fn apply_answer_subst(
         &mut self,
-        interner: &I,
+        interner: I,
         unification_database: &dyn UnificationDatabase<I>,
         ex_clause: &mut ExClause<I>,
         selected_goal: &InEnvironment<Goal<I>>,
@@ -276,13 +276,13 @@ struct AnswerSubstitutor<'t, I: Interner> {
     outer_binder: DebruijnIndex,
 
     ex_clause: &'t mut ExClause<I>,
-    interner: &'t I,
+    interner: I,
     unification_database: &'t dyn UnificationDatabase<I>,
 }
 
 impl<I: Interner> AnswerSubstitutor<'_, I> {
     fn substitute<T: Zip<I>>(
-        interner: &I,
+        interner: I,
         unification_database: &dyn UnificationDatabase<I>,
         table: &mut InferenceTable<I>,
         environment: &Environment<I>,
@@ -306,7 +306,7 @@ impl<I: Interner> AnswerSubstitutor<'_, I> {
 
     fn unify_free_answer_var(
         &mut self,
-        interner: &I,
+        interner: I,
         db: &dyn UnificationDatabase<I>,
         variance: Variance,
         answer_var: BoundVar,
@@ -379,7 +379,7 @@ impl<I: Interner> AnswerSubstitutor<'_, I> {
     }
 }
 
-impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
+impl<'i, I: Interner> Zipper<I> for AnswerSubstitutor<'i, I> {
     fn zip_tys(&mut self, variance: Variance, answer: &Ty<I>, pending: &Ty<I>) -> Fallible<()> {
         let interner = self.interner;
 
@@ -721,7 +721,7 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
         Ok(())
     }
 
-    fn interner(&self) -> &'i I {
+    fn interner(&self) -> I {
         self.interner
     }
 

chalk-engine/src/strand.rs

@@ -37,14 +37,11 @@ pub(crate) struct SelectedSubgoal {
 
 impl<I: Interner> Fold<I> for Strand<I> {
     type Result = Strand<I>;
-    fn fold_with<'i, E>(
+    fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<'i, I, Error = E>,
+        folder: &mut dyn Folder<I, Error = E>,
         outer_binder: DebruijnIndex,
-    ) -> Result<Self::Result, E>
-    where
-        I: 'i,
-    {
+    ) -> Result<Self::Result, E> {
         Ok(Strand {
             ex_clause: self.ex_clause.fold_with(folder, outer_binder)?,
             last_pursued_time: self.last_pursued_time,

chalk-integration/src/db.rs

@@ -173,8 +173,8 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
         chalk_solve::program_clauses_for_env(self, environment)
     }
 
-    fn interner(&self) -> &ChalkIr {
-        &ChalkIr
+    fn interner(&self) -> ChalkIr {
+        ChalkIr
     }
 
     fn is_object_safe(&self, trait_id: TraitId<ChalkIr>) -> bool {