Require SelectionContext to have a DefiningAnchor from the start

oli-obk · oli-obk · commit 01aacd4b900f · 2023-03-01T11:24:35.000Z
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
@@ -744,7 +744,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
 
                     let implsrc = {
                         let infcx = tcx.infer_ctxt().build();
-                        let mut selcx = SelectionContext::new(&infcx);
+                        let mut selcx = SelectionContext::new(&infcx, DefiningAnchor::Error);
                         selcx.select(&obligation)
                     };
 
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/ops.rs b/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
@@ -7,7 +7,7 @@ use rustc_errors::{
 };
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
-use rustc_infer::infer::TyCtxtInferExt;
+use rustc_infer::infer::{DefiningAnchor, TyCtxtInferExt};
 use rustc_infer::traits::{ImplSource, Obligation, ObligationCause};
 use rustc_middle::mir;
 use rustc_middle::ty::print::with_no_trimmed_paths;
@@ -149,7 +149,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
                     );
 
                     let infcx = tcx.infer_ctxt().build();
-                    let mut selcx = SelectionContext::new(&infcx);
+                    let mut selcx = SelectionContext::new(&infcx, DefiningAnchor::Error);
                     let implsrc = selcx.select(&obligation);
 
                     if let Ok(Some(ImplSource::UserDefined(data))) = implsrc {
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs
@@ -4,7 +4,7 @@
 
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::LangItem;
-use rustc_infer::infer::TyCtxtInferExt;
+use rustc_infer::infer::{DefiningAnchor, TyCtxtInferExt};
 use rustc_middle::mir;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, subst::SubstsRef, AdtDef, Ty};
@@ -162,7 +162,7 @@ impl Qualif for NeedsNonConstDrop {
         );
 
         let infcx = cx.tcx.infer_ctxt().build();
-        let mut selcx = SelectionContext::new(&infcx);
+        let mut selcx = SelectionContext::new(&infcx, DefiningAnchor::Error);
         let Some(impl_src) = selcx.select(&obligation).ok().flatten() else {
             // If we couldn't select a const destruct candidate, then it's bad
             return true;
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -585,8 +585,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             }
         })?;
 
-        let mut selcx = traits::SelectionContext::new(self)
-            .with_defining_use_anchor(self.defining_use_anchor());
+        let mut selcx = traits::SelectionContext::new(self, self.defining_use_anchor());
 
         // Create an obligation for `Source: CoerceUnsized<Target>`.
         let cause = ObligationCause::new(
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -1903,7 +1903,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             self.param_env,
                             ty::Binder::dummy(trait_ref),
                         );
-                        match SelectionContext::new(&self).with_defining_use_anchor(self.defining_use_anchor()).select(&obligation) {
+                        match SelectionContext::new(&self,self.defining_use_anchor()).select(&obligation) {
                             Ok(Some(traits::ImplSource::UserDefined(impl_source))) => {
                                 Some(impl_source.impl_def_id)
                             }
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -1428,9 +1428,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         let cause = traits::ObligationCause::misc(self.span, self.body_id);
         let predicate = ty::Binder::dummy(trait_ref);
         let obligation = traits::Obligation::new(self.tcx, cause, self.param_env, predicate);
-        traits::SelectionContext::new(self)
-            .with_defining_use_anchor(self.defining_use_anchor())
-            .select(&obligation)
+        traits::SelectionContext::new(self, self.defining_use_anchor()).select(&obligation)
     }
 
     fn candidate_source(&self, candidate: &Candidate<'tcx>, self_ty: Ty<'tcx>) -> CandidateSource {
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -89,7 +89,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
         let trait_ref = tcx.mk_trait_ref(trait_did, [ty]);
 
         let infcx = tcx.infer_ctxt().build();
-        let mut selcx = SelectionContext::new(&infcx);
+        let mut selcx = SelectionContext::new(&infcx, DefiningAnchor::Error);
         for polarity in [true, false] {
             let result = selcx.select(&Obligation::new(
                 tcx,
@@ -256,7 +256,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
             fresh_preds.insert(self.clean_pred(infcx, predicate));
         }
 
-        let mut select = SelectionContext::new(&infcx);
+        let mut select = SelectionContext::new(&infcx, DefiningAnchor::Error);
 
         let mut already_visited = FxHashSet::default();
         let mut predicates = VecDeque::new();
diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs
@@ -96,7 +96,7 @@ pub fn overlapping_impls(
     }
 
     let infcx = tcx.infer_ctxt().intercrate().build();
-    let selcx = &mut SelectionContext::new(&infcx);
+    let selcx = &mut SelectionContext::new(&infcx, DefiningAnchor::Error);
     let overlaps =
         overlap(selcx, skip_leak_check, impl1_def_id, impl2_def_id, overlap_mode).is_some();
     if !overlaps {
@@ -107,7 +107,7 @@ pub fn overlapping_impls(
     // this time tracking intercrate ambiguity causes for better
     // diagnostics. (These take time and can lead to false errors.)
     let infcx = tcx.infer_ctxt().intercrate().build();
-    let selcx = &mut SelectionContext::new(&infcx);
+    let selcx = &mut SelectionContext::new(&infcx, DefiningAnchor::Error);
     selcx.enable_tracking_intercrate_ambiguity_causes();
     Some(overlap(selcx, skip_leak_check, impl1_def_id, impl2_def_id, overlap_mode).unwrap())
 }
@@ -305,7 +305,7 @@ fn negative_impl(tcx: TyCtxt<'_>, impl1_def_id: DefId, impl2_def_id: DefId) -> b
     };
 
     // Attempt to prove that impl2 applies, given all of the above.
-    let selcx = &mut SelectionContext::new(&infcx);
+    let selcx = &mut SelectionContext::new(&infcx, DefiningAnchor::Error);
     let impl2_substs = infcx.fresh_substs_for_item(DUMMY_SP, impl2_def_id);
     let (subject2, obligations) =
         impl_subject_and_oblig(selcx, impl_env, impl2_def_id, impl2_substs);
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -2316,8 +2316,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
                 };
 
                 let obligation = obligation.with(self.tcx, trait_ref);
-                let mut selcx =
-                    SelectionContext::new(&self).with_defining_use_anchor(DefiningAnchor::Bubble);
+                let mut selcx = SelectionContext::new(&self, DefiningAnchor::Bubble);
                 match selcx.select_from_obligation(&obligation) {
                     Ok(None) => {
                         let ambiguities =
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -149,7 +149,7 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
     }
 
     fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>> {
-        let selcx = SelectionContext::new(infcx).with_defining_use_anchor(self.defining_use_anchor);
+        let selcx = SelectionContext::new(infcx, self.defining_use_anchor);
         self.select(selcx)
     }
 
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -28,6 +28,7 @@ use rustc_hir::def::DefKind;
 use rustc_hir::lang_items::LangItem;
 use rustc_infer::infer::at::At;
 use rustc_infer::infer::resolve::OpportunisticRegionResolver;
+use rustc_infer::infer::DefiningAnchor;
 use rustc_infer::traits::ImplSourceBuiltinData;
 use rustc_middle::traits::select::OverflowError;
 use rustc_middle::ty::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
@@ -58,7 +59,7 @@ pub trait NormalizeExt<'tcx> {
 
 impl<'tcx> NormalizeExt<'tcx> for At<'_, 'tcx> {
     fn normalize<T: TypeFoldable<TyCtxt<'tcx>>>(&self, value: T) -> InferOk<'tcx, T> {
-        let mut selcx = SelectionContext::new(self.infcx);
+        let mut selcx = SelectionContext::new(self.infcx, DefiningAnchor::Error);
         let Normalized { value, obligations } =
             normalize_with_depth(&mut selcx, self.param_env, self.cause.clone(), 0, value);
         InferOk { value, obligations }
diff --git a/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs b/compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs
@@ -1,3 +1,4 @@
+use rustc_infer::infer::DefiningAnchor;
 use rustc_middle::ty;
 use rustc_session::config::TraitSolver;
 
@@ -127,7 +128,7 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
         match self.evaluate_obligation(obligation) {
             Ok(result) => result,
             Err(OverflowError::Canonical) => {
-                let mut selcx = SelectionContext::new(&self);
+                let mut selcx = SelectionContext::new(&self, DefiningAnchor::Error);
                 selcx.evaluate_root_obligation(obligation).unwrap_or_else(|r| match r {
                     OverflowError::Canonical => {
                         span_bug!(
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -211,27 +211,25 @@ enum BuiltinImplConditions<'tcx> {
 }
 
 impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
-    pub fn new(infcx: &'cx InferCtxt<'tcx>) -> SelectionContext<'cx, 'tcx> {
+    pub fn new(
+        infcx: &'cx InferCtxt<'tcx>,
+        defining_use_anchor: impl Into<DefiningAnchor>,
+    ) -> SelectionContext<'cx, 'tcx> {
         SelectionContext {
             infcx,
             freshener: infcx.freshener_keep_static(),
             intercrate_ambiguity_causes: None,
             query_mode: TraitQueryMode::Standard,
-            defining_use_anchor: DefiningAnchor::Error,
+            defining_use_anchor: defining_use_anchor.into(),
         }
     }
 
-    pub fn with_defining_use_anchor(self, defining_use_anchor: DefiningAnchor) -> Self {
-        Self { defining_use_anchor, ..self }
-    }
-
     pub fn new_in_canonical_query(infcx: &'cx InferCtxt<'tcx>) -> SelectionContext<'cx, 'tcx> {
         SelectionContext {
             query_mode: TraitQueryMode::Canonical,
             // This bubble is required for this tests to pass:
             // impl-trait/issue99642.rs
-            defining_use_anchor: DefiningAnchor::Bubble,
-            ..SelectionContext::new(infcx)
+            ..SelectionContext::new(infcx, DefiningAnchor::Bubble)
         }
     }
 
diff --git a/compiler/rustc_trait_selection/src/traits/specialize/mod.rs b/compiler/rustc_trait_selection/src/traits/specialize/mod.rs
@@ -187,7 +187,7 @@ fn fulfill_implication<'tcx>(
 
     let source_trait = ImplSubject::Trait(source_trait_ref);
 
-    let selcx = &mut SelectionContext::new(&infcx);
+    let selcx = &mut SelectionContext::new(&infcx, DefiningAnchor::Error);
     let target_substs = infcx.fresh_substs_for_item(DUMMY_SP, target_impl);
     let (target_trait, obligations) =
         util::impl_subject_and_oblig(selcx, param_env, target_impl, target_substs);
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -2,6 +2,7 @@ use crate::infer::InferCtxt;
 use crate::traits;
 use rustc_hir as hir;
 use rustc_hir::lang_items::LangItem;
+use rustc_infer::infer::DefiningAnchor;
 use rustc_middle::ty::subst::{GenericArg, GenericArgKind, SubstsRef};
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
 use rustc_span::def_id::{DefId, LocalDefId, CRATE_DEF_ID};
@@ -314,7 +315,7 @@ impl<'tcx> WfPredicates<'tcx> {
         let mut obligations = Vec::with_capacity(self.out.len());
         for mut obligation in self.out {
             assert!(!obligation.has_escaping_bound_vars());
-            let mut selcx = traits::SelectionContext::new(infcx);
+            let mut selcx = traits::SelectionContext::new(infcx, DefiningAnchor::Error);
             // Don't normalize the whole obligation, the param env is either
             // already normalized, or we're currently normalizing the
             // param_env. Either way we should only normalize the predicate.
diff --git a/compiler/rustc_traits/src/codegen.rs b/compiler/rustc_traits/src/codegen.rs
@@ -32,7 +32,7 @@ pub fn codegen_select_candidate<'tcx>(
     let infcx = tcx.infer_ctxt().ignoring_regions().build();
     // HACK `Bubble` is required for
     // this test to pass: type-alias-impl-trait/assoc-projection-ice.rs
-    let mut selcx = SelectionContext::new(&infcx).with_defining_use_anchor(DefiningAnchor::Bubble);
+    let mut selcx = SelectionContext::new(&infcx, DefiningAnchor::Bubble);
 
     let obligation_cause = ObligationCause::dummy();
     let obligation = Obligation::new(tcx, obligation_cause, param_env, trait_ref);
diff --git a/compiler/rustc_traits/src/normalize_projection_ty.rs b/compiler/rustc_traits/src/normalize_projection_ty.rs
@@ -1,5 +1,5 @@
 use rustc_infer::infer::canonical::{Canonical, QueryResponse};
-use rustc_infer::infer::TyCtxtInferExt;
+use rustc_infer::infer::{DefiningAnchor, TyCtxtInferExt};
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::{ParamEnvAnd, TyCtxt};
 use rustc_trait_selection::infer::InferCtxtBuilderExt;
@@ -23,7 +23,7 @@ fn normalize_projection_ty<'tcx>(
     tcx.infer_ctxt().enter_canonical_trait_query(
         &goal,
         |ocx, ParamEnvAnd { param_env, value: goal }| {
-            let selcx = &mut SelectionContext::new(ocx.infcx);
+            let selcx = &mut SelectionContext::new(ocx.infcx, DefiningAnchor::Error);
             let cause = ObligationCause::dummy();
             let mut obligations = vec![];
             let answer = traits::normalize_projection_type(

Original file line number	Diff line number	Diff line change
`@@ -585,8 +585,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {`
`585`	`585`	`}`
`586`	`586`	`})?;`
`587`	`587`
`588`		`- let mut selcx = traits::SelectionContext::new(self)`
`589`		`- .with_defining_use_anchor(self.defining_use_anchor());`
	`588`	`+ let mut selcx = traits::SelectionContext::new(self, self.defining_use_anchor());`
`590`	`589`
`591`	`590`	// Create an obligation for `Source: CoerceUnsized<Target>`.
`592`	`591`	`let cause = ObligationCause::new(`
Original file line number	Diff line number	Diff line change
`@@ -1903,7 +1903,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1903`	`1903`	`self.param_env,`
`1904`	`1904`	`ty::Binder::dummy(trait_ref),`
`1905`	`1905`	`);`
`1906`		`- match SelectionContext::new(&self).with_defining_use_anchor(self.defining_use_anchor()).select(&obligation) {`
	`1906`	`+ match SelectionContext::new(&self,self.defining_use_anchor()).select(&obligation) {`
`1907`	`1907`	`Ok(Some(traits::ImplSource::UserDefined(impl_source))) => {`
`1908`	`1908`	`Some(impl_source.impl_def_id)`
`1909`	`1909`	`}`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>> {`
`152`		`- let selcx = SelectionContext::new(infcx).with_defining_use_anchor(self.defining_use_anchor);`
	`152`	`+ let selcx = SelectionContext::new(infcx, self.defining_use_anchor);`
`153`	`153`	`self.select(selcx)`
`154`	`154`	`}`
`155`	`155`