Stop using old_defining_use_anchor except in select_where_possible

Author: oli-obk

compiler/rustc_hir_typeck/src/coercion.rs

@@ -585,7 +585,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             }
         })?;
 
-        let mut selcx = traits::SelectionContext::new(self);
+        let mut selcx =
+            traits::SelectionContext::new(self).with_defining_use_anchor(self.defining_use_anchor);
 
         // Create an obligation for `Source: CoerceUnsized<Target>`.
         let cause = ObligationCause::new(

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).select(&obligation) {
+                        match SelectionContext::new(&self).with_defining_use_anchor(self.defining_use_anchor).select(&obligation) {
                             Ok(Some(traits::ImplSource::UserDefined(impl_source))) => {
                                 Some(impl_source.impl_def_id)
                             }

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -1422,7 +1422,9 @@ 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).select(&obligation)
+        traits::SelectionContext::new(self)
+            .with_defining_use_anchor(self.defining_use_anchor)
+            .select(&obligation)
     }
 
     fn candidate_source(&self, candidate: &Candidate<'tcx>, self_ty: Ty<'tcx>) -> CandidateSource {

compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs

@@ -30,7 +30,7 @@ use rustc_hir::GenericParam;
 use rustc_hir::Item;
 use rustc_hir::Node;
 use rustc_infer::infer::error_reporting::TypeErrCtxt;
-use rustc_infer::infer::{InferOk, TypeTrace};
+use rustc_infer::infer::{DefiningAnchor, InferOk, TypeTrace};
 use rustc_middle::traits::select::OverflowError;
 use rustc_middle::ty::abstract_const::NotConstEvaluatable;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
@@ -2316,7 +2316,8 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
                 };
 
                 let obligation = obligation.with(self.tcx, trait_ref);
-                let mut selcx = SelectionContext::new(&self);
+                let mut selcx =
+                    SelectionContext::new(&self).with_defining_use_anchor(DefiningAnchor::Bubble);
                 match selcx.select_from_obligation(&obligation) {
                     Ok(None) => {
                         let ambiguities =

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -137,7 +137,8 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
     }
 
     fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>> {
-        let selcx = SelectionContext::new(infcx);
+        let selcx =
+            SelectionContext::new(infcx).with_defining_use_anchor(infcx.old_defining_use_anchor);
         self.select(selcx)
     }
 

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -217,16 +217,20 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             freshener: infcx.freshener_keep_static(),
             intercrate_ambiguity_causes: None,
             query_mode: TraitQueryMode::Standard,
-            defining_use_anchor: infcx.old_defining_use_anchor,
+            defining_use_anchor: DefiningAnchor::Error,
         }
     }
 
-    pub fn with_query_mode(
-        infcx: &'cx InferCtxt<'tcx>,
-        query_mode: TraitQueryMode,
-    ) -> SelectionContext<'cx, 'tcx> {
-        debug!(?query_mode, "with_query_mode");
-        SelectionContext { query_mode, ..SelectionContext::new(infcx) }
+    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,
+            defining_use_anchor: DefiningAnchor::Bubble,
+            ..SelectionContext::new(infcx)
+        }
     }
 
     /// Enables tracking of intercrate ambiguity causes. See

compiler/rustc_traits/src/codegen.rs

@@ -36,7 +36,7 @@ pub fn codegen_select_candidate<'tcx>(
         .build();
     //~^ HACK `Bubble` is required for
     // this test to pass: type-alias-impl-trait/assoc-projection-ice.rs
-    let mut selcx = SelectionContext::new(&infcx);
+    let mut selcx = SelectionContext::new(&infcx).with_defining_use_anchor(DefiningAnchor::Bubble);
 
     let obligation_cause = ObligationCause::dummy();
     let obligation = Obligation::new(tcx, obligation_cause, param_env, trait_ref);

compiler/rustc_traits/src/evaluate_obligation.rs

@@ -4,7 +4,7 @@ use rustc_middle::ty::{ParamEnvAnd, TyCtxt};
 use rustc_span::source_map::DUMMY_SP;
 use rustc_trait_selection::traits::query::CanonicalPredicateGoal;
 use rustc_trait_selection::traits::{
-    EvaluationResult, Obligation, ObligationCause, OverflowError, SelectionContext, TraitQueryMode,
+    EvaluationResult, Obligation, ObligationCause, OverflowError, SelectionContext,
 };
 
 pub(crate) fn provide(p: &mut Providers) {
@@ -25,7 +25,7 @@ fn evaluate_obligation<'tcx>(
     debug!("evaluate_obligation: goal={:#?}", goal);
     let ParamEnvAnd { param_env, value: predicate } = goal;
 
-    let mut selcx = SelectionContext::with_query_mode(&infcx, TraitQueryMode::Canonical);
+    let mut selcx = SelectionContext::new_in_canonical_query(&infcx);
     let obligation = Obligation::new(tcx, ObligationCause::dummy(), param_env, predicate);
 
     selcx.evaluate_root_obligation(&obligation)

tests/ui/type-alias-impl-trait/issue-53398-cyclic-types.stderr

@@ -1,11 +1,8 @@
-error[E0275]: overflow evaluating the requirement `Foo: Sized`
+error[E0275]: overflow evaluating the requirement `<fn() -> Foo {foo} as FnOnce<()>>::Output == fn() -> Foo {foo}`
   --> $DIR/issue-53398-cyclic-types.rs:5:13
    |
 LL | fn foo() -> Foo {
    |             ^^^
-   |
-   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`issue_53398_cyclic_types`)
-   = note: required because it appears within the type `fn() -> Foo {foo}`
 
 error: aborting due to previous error