Remove the final use of old_defining_use_anchor

oli-obk · oli-obk · commit 209103f75a59 · 2023-03-01T11:24:34.000Z
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -1462,6 +1462,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self.param_env,
             original_values,
             query_result,
+            self.defining_use_anchor,
         )
     }
 
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -181,12 +181,18 @@ impl<'tcx> InferCtxt<'tcx> {
         param_env: ty::ParamEnv<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
         query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>,
+        defining_use_anchor: DefiningAnchor,
     ) -> InferResult<'tcx, R>
     where
         R: Debug + TypeFoldable<TyCtxt<'tcx>>,
     {
-        let InferOk { value: result_subst, mut obligations } =
-            self.query_response_substitution(cause, param_env, original_values, query_response)?;
+        let InferOk { value: result_subst, mut obligations } = self.query_response_substitution(
+            cause,
+            param_env,
+            original_values,
+            query_response,
+            defining_use_anchor,
+        )?;
 
         obligations.extend(self.query_outlives_constraints_into_obligations(
             cause,
@@ -243,12 +249,19 @@ impl<'tcx> InferCtxt<'tcx> {
         original_values: &OriginalQueryValues<'tcx>,
         query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>,
         output_query_region_constraints: &mut QueryRegionConstraints<'tcx>,
+        defining_use_anchor: DefiningAnchor,
     ) -> InferResult<'tcx, R>
     where
         R: Debug + TypeFoldable<TyCtxt<'tcx>>,
     {
         let InferOk { value: result_subst, mut obligations } = self
-            .query_response_substitution_guess(cause, param_env, original_values, query_response)?;
+            .query_response_substitution_guess(
+                cause,
+                param_env,
+                original_values,
+                query_response,
+                defining_use_anchor,
+            )?;
 
         // Compute `QueryOutlivesConstraint` values that unify each of
         // the original values `v_o` that was canonicalized into a
@@ -357,6 +370,7 @@ impl<'tcx> InferCtxt<'tcx> {
         param_env: ty::ParamEnv<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
         query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>,
+        defining_use_anchor: DefiningAnchor,
     ) -> InferResult<'tcx, CanonicalVarValues<'tcx>>
     where
         R: Debug + TypeFoldable<TyCtxt<'tcx>>,
@@ -371,6 +385,7 @@ impl<'tcx> InferCtxt<'tcx> {
             param_env,
             original_values,
             query_response,
+            defining_use_anchor,
         )?;
 
         value.obligations.extend(
@@ -403,6 +418,7 @@ impl<'tcx> InferCtxt<'tcx> {
         param_env: ty::ParamEnv<'tcx>,
         original_values: &OriginalQueryValues<'tcx>,
         query_response: &Canonical<'tcx, QueryResponse<'tcx, R>>,
+        defining_use_anchor: DefiningAnchor,
     ) -> InferResult<'tcx, CanonicalVarValues<'tcx>>
     where
         R: Debug + TypeFoldable<TyCtxt<'tcx>>,
@@ -504,7 +520,7 @@ impl<'tcx> InferCtxt<'tcx> {
             debug!(?a, ?b, "constrain opaque type");
             obligations.extend(
                 self.at(cause, param_env)
-                    .define_opaque_types(self.old_defining_use_anchor)
+                    .define_opaque_types(defining_use_anchor)
                     .eq(a, b)?
                     .obligations,
             );
diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs
@@ -2,7 +2,7 @@ use rustc_hir::def_id::DefId;
 use rustc_infer::infer::at::ToTrace;
 use rustc_infer::infer::canonical::CanonicalVarValues;
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
-use rustc_infer::infer::{InferCtxt, InferOk, LateBoundRegionConversionTime};
+use rustc_infer::infer::{DefiningAnchor, InferCtxt, InferOk, LateBoundRegionConversionTime};
 use rustc_infer::traits::query::NoSolution;
 use rustc_infer::traits::ObligationCause;
 use rustc_middle::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
@@ -27,6 +27,7 @@ pub struct EvalCtxt<'a, 'tcx> {
     /// This field is used by a debug assertion in [`EvalCtxt::evaluate_goal`],
     /// see the comment in that method for more details.
     pub in_projection_eq_hack: bool,
+    pub(super) defining_use_anchor: DefiningAnchor,
 }
 
 impl<'tcx> EvalCtxt<'_, 'tcx> {
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -54,7 +54,7 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentCtxt<'tcx> {
     fn select_where_possible(
         &mut self,
         infcx: &InferCtxt<'tcx>,
-        _defining_use_anchor: DefiningAnchor,
+        defining_use_anchor: DefiningAnchor,
     ) -> Vec<FulfillmentError<'tcx>> {
         let mut errors = Vec::new();
         for i in 0.. {
@@ -65,7 +65,8 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentCtxt<'tcx> {
             let mut has_changed = false;
             for obligation in mem::take(&mut self.obligations) {
                 let goal = obligation.clone().into();
-                let (changed, certainty) = match infcx.evaluate_root_goal(goal) {
+                let (changed, certainty) = match infcx.evaluate_root_goal(goal, defining_use_anchor)
+                {
                     Ok(result) => result,
                     Err(NoSolution) => {
                         errors.push(FulfillmentError {
diff --git a/compiler/rustc_trait_selection/src/solve/mod.rs b/compiler/rustc_trait_selection/src/solve/mod.rs
@@ -20,7 +20,7 @@ use std::mem;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::canonical::{Canonical, CanonicalVarValues};
 use rustc_infer::infer::canonical::{OriginalQueryValues, QueryRegionConstraints, QueryResponse};
-use rustc_infer::infer::{InferCtxt, InferOk, TyCtxtInferExt};
+use rustc_infer::infer::{DefiningAnchor, InferCtxt, InferOk, TyCtxtInferExt};
 use rustc_infer::traits::query::NoSolution;
 use rustc_infer::traits::Obligation;
 use rustc_middle::infer::canonical::Certainty as OldCertainty;
@@ -156,13 +156,15 @@ pub trait InferCtxtEvalExt<'tcx> {
     fn evaluate_root_goal(
         &self,
         goal: Goal<'tcx, ty::Predicate<'tcx>>,
+        defining_use_anchor: DefiningAnchor,
     ) -> Result<(bool, Certainty), NoSolution>;
 }
 
 impl<'tcx> InferCtxtEvalExt<'tcx> for InferCtxt<'tcx> {
     fn evaluate_root_goal(
         &self,
         goal: Goal<'tcx, ty::Predicate<'tcx>>,
+        defining_use_anchor: DefiningAnchor,
     ) -> Result<(bool, Certainty), NoSolution> {
         let mut search_graph = search_graph::SearchGraph::new(self.tcx);
 
@@ -171,6 +173,7 @@ impl<'tcx> InferCtxtEvalExt<'tcx> for InferCtxt<'tcx> {
             infcx: self,
             var_values: CanonicalVarValues::dummy(),
             in_projection_eq_hack: false,
+            defining_use_anchor,
         }
         .evaluate_goal(goal);
 
@@ -194,15 +197,21 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
         tcx: TyCtxt<'tcx>,
         search_graph: &'a mut search_graph::SearchGraph<'tcx>,
         canonical_goal: CanonicalGoal<'tcx>,
+        defining_use_anchor: DefiningAnchor,
     ) -> QueryResult<'tcx> {
         // Deal with overflow, caching, and coinduction.
         //
         // The actual solver logic happens in `ecx.compute_goal`.
         search_graph.with_new_goal(tcx, canonical_goal, |search_graph| {
             let (ref infcx, goal, var_values) =
                 tcx.infer_ctxt().build_with_canonical(DUMMY_SP, &canonical_goal);
-            let mut ecx =
-                EvalCtxt { infcx, var_values, search_graph, in_projection_eq_hack: false };
+            let mut ecx = EvalCtxt {
+                infcx,
+                var_values,
+                search_graph,
+                in_projection_eq_hack: false,
+                defining_use_anchor,
+            };
             ecx.compute_goal(goal)
         })
     }
@@ -225,12 +234,20 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
     ) -> Result<(bool, Certainty), NoSolution> {
         let mut orig_values = OriginalQueryValues::default();
         let canonical_goal = self.infcx.canonicalize_query(goal, &mut orig_values);
-        let canonical_response =
-            EvalCtxt::evaluate_canonical_goal(self.tcx(), self.search_graph, canonical_goal)?;
+        let canonical_response = EvalCtxt::evaluate_canonical_goal(
+            self.tcx(),
+            self.search_graph,
+            canonical_goal,
+            self.defining_use_anchor,
+        )?;
 
         let has_changed = !canonical_response.value.var_values.is_identity();
-        let certainty =
-            instantiate_canonical_query_response(self.infcx, &orig_values, canonical_response);
+        let certainty = instantiate_canonical_query_response(
+            self.infcx,
+            &orig_values,
+            canonical_response,
+            self.defining_use_anchor,
+        );
 
         // Check that rerunning this query with its inference constraints applied
         // doesn't result in new inference constraints and has the same result.
@@ -246,8 +263,12 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
         {
             let mut orig_values = OriginalQueryValues::default();
             let canonical_goal = self.infcx.canonicalize_query(goal, &mut orig_values);
-            let canonical_response =
-                EvalCtxt::evaluate_canonical_goal(self.tcx(), self.search_graph, canonical_goal)?;
+            let canonical_response = EvalCtxt::evaluate_canonical_goal(
+                self.tcx(),
+                self.search_graph,
+                canonical_goal,
+                self.defining_use_anchor,
+            )?;
             if !canonical_response.value.var_values.is_identity() {
                 bug!("unstable result: {goal:?} {canonical_goal:?} {canonical_response:?}");
             }
@@ -580,6 +601,7 @@ fn instantiate_canonical_query_response<'tcx>(
     infcx: &InferCtxt<'tcx>,
     original_values: &OriginalQueryValues<'tcx>,
     response: CanonicalResponse<'tcx>,
+    defining_use_anchor: DefiningAnchor,
 ) -> Certainty {
     let Ok(InferOk { value, obligations }) = infcx
         .instantiate_query_response_and_region_obligations(
@@ -599,6 +621,7 @@ fn instantiate_canonical_query_response<'tcx>(
                 opaque_types: resp.external_constraints.opaque_types.to_owned(),
                 value: resp.certainty,
             }),
+            defining_use_anchor,
         ) else { bug!(); };
     assert!(obligations.is_empty());
     value
diff --git a/compiler/rustc_trait_selection/src/traits/chalk_fulfill.rs b/compiler/rustc_trait_selection/src/traits/chalk_fulfill.rs
@@ -58,7 +58,7 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
     fn select_where_possible(
         &mut self,
         infcx: &InferCtxt<'tcx>,
-        _defining_use_anchor: DefiningAnchor,
+        defining_use_anchor: DefiningAnchor,
     ) -> Vec<FulfillmentError<'tcx>> {
         if !self.usable_in_snapshot {
             assert!(!infcx.is_in_snapshot());
@@ -95,6 +95,7 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
                                 obligation.param_env,
                                 &orig_values,
                                 &response,
+                                defining_use_anchor,
                             ) {
                                 Ok(infer_ok) => next_round.extend(
                                     infer_ok.obligations.into_iter().map(|obligation| {
diff --git a/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs b/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs
@@ -87,9 +87,10 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
             self.tcx.at(obligation.cause.span()).evaluate_obligation(c_pred)
         } else {
             self.probe(|snapshot| {
-                if let Ok((_, certainty)) =
-                    self.evaluate_root_goal(Goal::new(self.tcx, param_env, obligation.predicate))
-                {
+                if let Ok((_, certainty)) = self.evaluate_root_goal(
+                    Goal::new(self.tcx, param_env, obligation.predicate),
+                    rustc_infer::infer::DefiningAnchor::Error,
+                ) {
                     match certainty {
                         Certainty::Yes => {
                             if self.opaque_types_added_in_snapshot(snapshot) {
diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
@@ -10,6 +10,7 @@ use crate::traits::project::{needs_normalization, BoundVarReplacer, PlaceholderR
 use crate::traits::{ObligationCause, PredicateObligation, Reveal};
 use rustc_data_structures::sso::SsoHashMap;
 use rustc_data_structures::stack::ensure_sufficient_stack;
+use rustc_infer::infer::DefiningAnchor;
 use rustc_infer::traits::Normalized;
 use rustc_middle::ty::fold::{FallibleTypeFolder, TypeFoldable, TypeSuperFoldable};
 use rustc_middle::ty::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitableExt};
@@ -72,6 +73,7 @@ impl<'cx, 'tcx> QueryNormalizeExt<'tcx> for At<'cx, 'tcx> {
             cache: SsoHashMap::new(),
             anon_depth: 0,
             universes: vec![],
+            defining_use_anchor: self.define_opaque_types,
         };
 
         // This is actually a consequence by the way `normalize_erasing_regions` works currently.
@@ -168,6 +170,7 @@ struct QueryNormalizer<'cx, 'tcx> {
     cache: SsoHashMap<Ty<'tcx>, Ty<'tcx>>,
     anon_depth: usize,
     universes: Vec<Option<ty::UniverseIndex>>,
+    defining_use_anchor: DefiningAnchor,
 }
 
 impl<'cx, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'cx, 'tcx> {
@@ -282,6 +285,7 @@ impl<'cx, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'cx, 'tcx>
                         self.param_env,
                         &orig_values,
                         result,
+                        self.defining_use_anchor,
                     )?;
                 debug!("QueryNormalizer: result = {:#?}", result);
                 debug!("QueryNormalizer: obligations = {:#?}", obligations);
@@ -333,6 +337,7 @@ impl<'cx, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'cx, 'tcx>
                         self.param_env,
                         &orig_values,
                         result,
+                        self.defining_use_anchor,
                     )?;
                 debug!("QueryNormalizer: result = {:#?}", result);
                 debug!("QueryNormalizer: obligations = {:#?}", obligations);
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs
@@ -85,6 +85,7 @@ pub trait QueryTypeOp<'tcx>: fmt::Debug + Copy + TypeFoldable<TyCtxt<'tcx>> + 't
         query_key: ParamEnvAnd<'tcx, Self>,
         infcx: &InferCtxt<'tcx>,
         output_query_region_constraints: &mut QueryRegionConstraints<'tcx>,
+        defining_use_anchor: DefiningAnchor,
     ) -> Fallible<(
         Self::QueryResponse,
         Option<Canonical<'tcx, ParamEnvAnd<'tcx, Self>>>,
@@ -112,6 +113,7 @@ pub trait QueryTypeOp<'tcx>: fmt::Debug + Copy + TypeFoldable<TyCtxt<'tcx>> + 't
                 &canonical_var_values,
                 canonical_result,
                 output_query_region_constraints,
+                defining_use_anchor,
             )?;
 
         Ok((value, Some(canonical_self), obligations, canonical_result.value.certainty))
@@ -128,11 +130,11 @@ where
     fn fully_perform(
         self,
         infcx: &InferCtxt<'tcx>,
-        _defining_use_anchor: DefiningAnchor,
+        defining_use_anchor: DefiningAnchor,
     ) -> Fallible<TypeOpOutput<'tcx, Self>> {
         let mut region_constraints = QueryRegionConstraints::default();
         let (output, error_info, mut obligations, _) =
-            Q::fully_perform_into(self, infcx, &mut region_constraints)?;
+            Q::fully_perform_into(self, infcx, &mut region_constraints, defining_use_anchor)?;
 
         // Typically, instantiating NLL query results does not
         // create obligations. However, in some cases there
@@ -148,6 +150,7 @@ where
                     obligation.param_env.and(ProvePredicate::new(obligation.predicate)),
                     infcx,
                     &mut region_constraints,
+                    defining_use_anchor,
                 ) {
                     Ok(((), _, new, certainty)) => {
                         obligations.extend(new);

Original file line number	Diff line number	Diff line change
`@@ -1462,6 +1462,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1462`	`1462`	`self.param_env,`
`1463`	`1463`	`original_values,`
`1464`	`1464`	`query_result,`
	`1465`	`+ self.defining_use_anchor,`
`1465`	`1466`	`)`
`1466`	`1467`	`}`
`1467`	`1468`