Make infcx in Resolver mut

Author: jyn514

compiler/rustc_infer/src/infer/mod.rs

@@ -1341,7 +1341,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn fully_resolve<T: TypeFoldable<'tcx>>(&self, value: T) -> FixupResult<'tcx, T> {
+    pub fn fully_resolve<T: TypeFoldable<'tcx>>(&mut self, value: T) -> FixupResult<'tcx, T> {
         /*!
          * Attempts to resolve all type/region/const variables in
          * `value`. Region inference must have been run already (e.g.,

compiler/rustc_infer/src/infer/outlives/obligations.rs

@@ -81,19 +81,18 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// available (see `region_obligations` field for more
     /// information).
     pub fn register_region_obligation(
-        &self,
+        &mut self,
         body_id: hir::HirId,
         obligation: RegionObligation<'tcx>,
     ) {
         debug!("register_region_obligation(body_id={:?}, obligation={:?})", body_id, obligation);
 
-        let mut inner = self.inner;
-        inner.undo_log.push(UndoLog::PushRegionObligation);
-        inner.region_obligations.push((body_id, obligation));
+        self.inner.undo_log.push(UndoLog::PushRegionObligation);
+        self.inner.region_obligations.push((body_id, obligation));
     }
 
     pub fn register_region_obligation_with_cause(
-        &self,
+        &mut self,
         sup_type: Ty<'tcx>,
         sub_region: Region<'tcx>,
         cause: &ObligationCause<'tcx>,
@@ -109,7 +108,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     }
 
     /// Trait queries just want to pass back type obligations "as is"
-    pub fn take_registered_region_obligations(&self) -> Vec<(hir::HirId, RegionObligation<'tcx>)> {
+    pub fn take_registered_region_obligations(&mut self) -> Vec<(hir::HirId, RegionObligation<'tcx>)> {
         std::mem::take(&mut self.inner.region_obligations)
     }
 

compiler/rustc_infer/src/infer/resolve.rs

@@ -127,8 +127,7 @@ impl<'a, 'tcx> TypeVisitor<'tcx> for UnresolvedTypeFinder<'a, 'tcx> {
                 // Since we called `shallow_resolve` above, this must
                 // be an (as yet...) unresolved inference variable.
                 let ty_var_span = if let ty::TyVar(ty_vid) = infer_ty {
-                    let mut inner = self.infcx.inner;
-                    let ty_vars = &inner.type_variables();
+                    let ty_vars = &self.infcx.inner.type_variables();
                     if let TypeVariableOrigin {
                         kind: TypeVariableOriginKind::TypeParameterDefinition(_, _),
                         span,
@@ -160,7 +159,7 @@ impl<'a, 'tcx> TypeVisitor<'tcx> for UnresolvedTypeFinder<'a, 'tcx> {
 /// Full type resolution replaces all type and region variables with
 /// their concrete results. If any variable cannot be replaced (never unified, etc)
 /// then an `Err` result is returned.
-pub fn fully_resolve<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>, value: T) -> FixupResult<'tcx, T>
+pub fn fully_resolve<'a, 'tcx, T>(infcx: &mut InferCtxt<'a, 'tcx>, value: T) -> FixupResult<'tcx, T>
 where
     T: TypeFoldable<'tcx>,
 {
@@ -174,12 +173,12 @@ where
 
 // N.B. This type is not public because the protocol around checking the
 // `err` field is not enforceable otherwise.
-struct FullTypeResolver<'a, 'tcx> {
-    infcx: &'a InferCtxt<'a, 'tcx>,
+struct FullTypeResolver<'a, 'cx, 'tcx> {
+    infcx: &'a mut InferCtxt<'cx, 'tcx>,
     err: Option<FixupError<'tcx>>,
 }
 
-impl<'a, 'tcx> TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {
+impl<'a, 'tcx> TypeFolder<'tcx> for FullTypeResolver<'a, '_, 'tcx> {
     fn tcx<'b>(&'b self) -> TyCtxt<'tcx> {
         self.infcx.tcx
     }