Fix easiest borrowck errors

Author: jyn514

compiler/rustc_infer/src/infer/at.rs

@@ -192,8 +192,8 @@ impl<'a, 'tcx> Trace<'a, 'tcx> {
     {
         debug!("sub({:?} <: {:?})", a, b);
         let Trace { at, trace, a_is_expected } = self;
-        at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env);
+        at.infcx.commit_if_ok(|infcx, _| {
+            let mut fields = infcx.combine_fields(trace, at.param_env);
             fields
                 .sub(a_is_expected)
                 .relate(a, b)
@@ -209,8 +209,8 @@ impl<'a, 'tcx> Trace<'a, 'tcx> {
     {
         debug!("eq({:?} == {:?})", a, b);
         let Trace { at, trace, a_is_expected } = self;
-        at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env);
+        at.infcx.commit_if_ok(|infcx, _| {
+            let mut fields = infcx.combine_fields(trace, at.param_env);
             fields
                 .equate(a_is_expected)
                 .relate(a, b)
@@ -224,8 +224,8 @@ impl<'a, 'tcx> Trace<'a, 'tcx> {
     {
         debug!("lub({:?} \\/ {:?})", a, b);
         let Trace { at, trace, a_is_expected } = self;
-        at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env);
+        at.infcx.commit_if_ok(|infcx, _| {
+            let mut fields = infcx.combine_fields(trace, at.param_env);
             fields
                 .lub(a_is_expected)
                 .relate(a, b)
@@ -239,8 +239,8 @@ impl<'a, 'tcx> Trace<'a, 'tcx> {
     {
         debug!("glb({:?} /\\ {:?})", a, b);
         let Trace { at, trace, a_is_expected } = self;
-        at.infcx.commit_if_ok(|_| {
-            let mut fields = at.infcx.combine_fields(trace, at.param_env);
+        at.infcx.commit_if_ok(|infcx, _| {
+            let mut fields = infcx.combine_fields(trace, at.param_env);
             fields
                 .glb(a_is_expected)
                 .relate(a, b)

compiler/rustc_infer/src/infer/canonical/mod.rs

@@ -98,7 +98,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// variable, then you'll get a new inference variable; if it is a
     /// universally quantified variable, you get a placeholder.
     fn instantiate_canonical_var(
-        &self,
+        &mut self,
         span: Span,
         cv_info: CanonicalVarInfo<'tcx>,
         universe_map: impl Fn(ty::UniverseIndex) -> ty::UniverseIndex,

compiler/rustc_infer/src/infer/canonical/query_response.rs

@@ -49,7 +49,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// - Finally, if any of the obligations result in a hard error,
     ///   then `Err(NoSolution)` is returned.
     pub fn make_canonicalized_query_response<T>(
-        &self,
+        &mut self,
         inference_vars: CanonicalVarValues<'tcx>,
         answer: T,
         fulfill_cx: &mut dyn TraitEngine<'tcx>,
@@ -94,7 +94,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// Helper for `make_canonicalized_query_response` that does
     /// everything up until the final canonicalization.
     fn make_query_response<T>(
-        &self,
+        &mut self,
         inference_vars: CanonicalVarValues<'tcx>,
         answer: T,
         fulfill_cx: &mut dyn TraitEngine<'tcx>,
@@ -156,7 +156,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     ///
     /// [c]: https://rust-lang.github.io/chalk/book/canonical_queries/canonicalization.html#processing-the-canonicalized-query-result
     pub fn instantiate_query_response_and_region_obligations<R>(
-        &self,
+        &mut self,
         cause: &ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
@@ -217,7 +217,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// - Finally, the query result (of type `R`) is propagated back,
     ///   after applying the substitution `S`.
     pub fn instantiate_nll_query_response_and_region_obligations<R>(
-        &self,
+        &mut self,
         cause: &ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
@@ -334,7 +334,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// assigned to a type variable is unified with an unnormalized
     /// projection.
     fn query_response_substitution<R>(
-        &self,
+        &mut self,
         cause: &ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
@@ -374,7 +374,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// variable instead. Therefore, the result of this method must be
     /// properly unified
     fn query_response_substitution_guess<R>(
-        &self,
+        &mut self,
         cause: &ObligationCause<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
         query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>,
@@ -487,7 +487,7 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     ///
     /// See also: `query_response_substitution_guess`
     fn unify_query_response_substitution_guess<R>(
-        &self,
+        &mut self,
         cause: &ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
@@ -501,8 +501,9 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
         // canonical variable; this is taken from
         // `query_response.var_values` after applying the substitution
         // `result_subst`.
+        let tcx = self.tcx;
         let substituted_query_response = |index: BoundVar| -> GenericArg<'tcx> {
-            query_response.substitute_projected(self.tcx, &result_subst, |v| v.var_values[index])
+            query_response.substitute_projected(tcx, &result_subst, |v| v.var_values[index])
         };
 
         // Unify the original value for each variable with the value
@@ -550,21 +551,21 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
     /// Given two sets of values for the same set of canonical variables, unify them.
     /// The second set is produced lazily by supplying indices from the first set.
     fn unify_canonical_vars(
-        &self,
+        &mut self,
         cause: &ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         variables1: &OriginalQueryValues<'tcx>,
         variables2: impl Fn(BoundVar) -> GenericArg<'tcx>,
     ) -> InferResult<'tcx, ()> {
-        self.commit_if_ok(|_| {
+        self.commit_if_ok(|this, _| {
             let mut obligations = vec![];
             for (index, value1) in variables1.var_values.iter().enumerate() {
                 let value2 = variables2(BoundVar::new(index));
 
                 match (value1.unpack(), value2.unpack()) {
                     (GenericArgKind::Type(v1), GenericArgKind::Type(v2)) => {
                         obligations
-                            .extend(self.at(cause, param_env).eq(v1, v2)?.into_obligations());
+                            .extend(this.at(cause, param_env).eq(v1, v2)?.into_obligations());
                     }
                     (
                         GenericArgKind::Lifetime(ty::ReErased),
@@ -574,10 +575,10 @@ impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> {
                     }
                     (GenericArgKind::Lifetime(v1), GenericArgKind::Lifetime(v2)) => {
                         obligations
-                            .extend(self.at(cause, param_env).eq(v1, v2)?.into_obligations());
+                            .extend(this.at(cause, param_env).eq(v1, v2)?.into_obligations());
                     }
                     (GenericArgKind::Const(v1), GenericArgKind::Const(v2)) => {
-                        let ok = self.at(cause, param_env).eq(v1, v2)?;
+                        let ok = this.at(cause, param_env).eq(v1, v2)?;
                         obligations.extend(ok.into_obligations());
                     }
                     _ => {

compiler/rustc_infer/src/infer/combine.rs

@@ -63,7 +63,7 @@ pub enum RelationDir {
 
 impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
     pub fn super_combine_tys<R>(
-        &self,
+        &mut self,
         relation: &mut R,
         a: Ty<'tcx>,
         b: Ty<'tcx>,
@@ -120,7 +120,7 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
     }
 
     pub fn super_combine_consts<R>(
-        &self,
+        &mut self,
         relation: &mut R,
         a: &'tcx ty::Const<'tcx>,
         b: &'tcx ty::Const<'tcx>,
@@ -220,15 +220,14 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
     ///
     /// See `src/test/ui/const-generics/occurs-check/` for more examples where this is relevant.
     fn unify_const_variable(
-        &self,
+        &mut self,
         param_env: ty::ParamEnv<'tcx>,
         target_vid: ty::ConstVid<'tcx>,
         ct: &'tcx ty::Const<'tcx>,
         vid_is_expected: bool,
     ) -> RelateResult<'tcx, &'tcx ty::Const<'tcx>> {
         let (for_universe, span) = {
-            let mut inner = self.inner;
-            let variable_table = &mut inner.const_unification_table();
+            let variable_table = &mut self.inner.const_unification_table();
             let var_value = variable_table.probe_value(target_vid);
             match var_value.val {
                 ConstVariableValue::Known { value } => {

compiler/rustc_infer/src/infer/fudge.rs

@@ -102,18 +102,18 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         debug!("fudge_inference_if_ok()");
 
         let variable_lengths = self.variable_lengths();
-        let (mut fudger, value) = self.probe(|_| {
+        let (mut fudger, value) = self.probe(|this, _| {
             match f() {
                 Ok(value) => {
-                    let value = self.resolve_vars_if_possible(value);
+                    let value = this.resolve_vars_if_possible(value);
 
                     // At this point, `value` could in principle refer
                     // to inference variables that have been created during
                     // the snapshot. Once we exit `probe()`, those are
                     // going to be popped, so we will have to
                     // eliminate any references to them.
 
-                    let mut inner = self.inner;
+                    let mut inner = this.inner;
                     let type_vars =
                         inner.type_variables().vars_since_snapshot(variable_lengths.type_var_len);
                     let int_vars = vars_since_snapshot(

compiler/rustc_infer/src/infer/higher_ranked/mod.rs

@@ -30,17 +30,17 @@ impl<'a, 'tcx> CombineFields<'a, 'tcx> {
 
         let span = self.trace.cause.span;
 
-        self.infcx.commit_if_ok(|_| {
+        self.infcx.commit_if_ok(|infcx, _| {
             // First, we instantiate each bound region in the supertype with a
             // fresh placeholder region.
-            let b_prime = self.infcx.replace_bound_vars_with_placeholders(b);
+            let b_prime = infcx.replace_bound_vars_with_placeholders(b);
 
             // Next, we instantiate each bound region in the subtype
             // with a fresh region variable. These region variables --
             // but no other pre-existing region variables -- can name
             // the placeholders.
             let (a_prime, _) =
-                self.infcx.replace_bound_vars_with_fresh_vars(span, HigherRankedType, a);
+                infcx.replace_bound_vars_with_fresh_vars(span, HigherRankedType, a);
 
             debug!("a_prime={:?}", a_prime);
             debug!("b_prime={:?}", b_prime);