Make infcx mut in TypeFreshener

Author: jyn514

compiler/rustc_infer/src/infer/freshen.rs

@@ -41,16 +41,16 @@ use std::collections::hash_map::Entry;
 use super::unify_key::ToType;
 use super::InferCtxt;
 
-pub struct TypeFreshener<'a, 'tcx> {
-    infcx: &'a InferCtxt<'a, 'tcx>,
+pub struct TypeFreshener<'a, 'cx, 'tcx> {
+    infcx: &'a mut InferCtxt<'cx, 'tcx>,
     ty_freshen_count: u32,
     const_freshen_count: u32,
     ty_freshen_map: FxHashMap<ty::InferTy, Ty<'tcx>>,
     const_freshen_map: FxHashMap<ty::InferConst<'tcx>, &'tcx ty::Const<'tcx>>,
 }
 
-impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
-    pub fn new(infcx: &'a InferCtxt<'a, 'tcx>) -> TypeFreshener<'a, 'tcx> {
+impl<'a, 'cx, 'tcx> TypeFreshener<'a, 'cx, 'tcx> {
+    pub fn new(infcx: &'a mut InferCtxt<'cx, 'tcx>) -> Self {
         TypeFreshener {
             infcx,
             ty_freshen_count: 0,
@@ -112,7 +112,7 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
+impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, '_, 'tcx> {
     fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
         self.infcx.tcx
     }
@@ -150,25 +150,31 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
                 self.freshen_ty(opt_ty, ty::TyVar(v), ty::FreshTy)
             }
 
-            ty::Infer(ty::IntVar(v)) => self.freshen_ty(
-                self.infcx
+            ty::Infer(ty::IntVar(v)) => {
+                let opt_ty = self.infcx
                     .inner
                     .int_unification_table()
                     .probe_value(v)
-                    .map(|v| v.to_type(tcx)),
-                ty::IntVar(v),
-                ty::FreshIntTy,
-            ),
+                    .map(|v| v.to_type(tcx));
+                self.freshen_ty(
+                    opt_ty,
+                    ty::IntVar(v),
+                    ty::FreshIntTy,
+                )
+            }
 
-            ty::Infer(ty::FloatVar(v)) => self.freshen_ty(
-                self.infcx
+            ty::Infer(ty::FloatVar(v)) => {
+                let opt_ty = self.infcx
                     .inner
                     .float_unification_table()
                     .probe_value(v)
-                    .map(|v| v.to_type(tcx)),
+                    .map(|v| v.to_type(tcx));
+                self.freshen_ty(
+                    opt_ty,
                 ty::FloatVar(v),
                 ty::FreshFloatTy,
-            ),
+                )
+            }
 
             ty::Infer(ty::FreshTy(ct) | ty::FreshIntTy(ct) | ty::FreshFloatTy(ct)) => {
                 if ct >= self.ty_freshen_count {

compiler/rustc_infer/src/infer/mod.rs

@@ -637,7 +637,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         self.in_snapshot.get()
     }
 
-    pub fn freshen<T: TypeFoldable<'tcx>>(&self, t: T) -> T {
+    pub fn freshen<T: TypeFoldable<'tcx>>(&mut self, t: T) -> T {
         t.fold_with(&mut self.freshener())
     }
 
@@ -648,7 +648,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn freshener<'b>(&'b self) -> TypeFreshener<'b, 'tcx> {
+    pub fn freshener<'b>(&'b mut self) -> TypeFreshener<'b, 'a, 'tcx> {
         freshen::TypeFreshener::new(self)
     }