Bubble old_defining_use_anchor upwards from select_all_or_error

oli-obk · oli-obk · commit 60ac06e836f6 · 2023-03-01T11:24:33.000Z
diff --git a/compiler/rustc_hir_analysis/src/autoderef.rs b/compiler/rustc_hir_analysis/src/autoderef.rs
@@ -2,7 +2,7 @@ use crate::errors::AutoDerefReachedRecursionLimit;
 use crate::traits::query::evaluate_obligation::InferCtxtExt;
 use crate::traits::NormalizeExt;
 use crate::traits::{self, TraitEngine, TraitEngineExt};
-use rustc_infer::infer::InferCtxt;
+use rustc_infer::infer::{DefiningAnchor, InferCtxt};
 use rustc_middle::ty::TypeVisitableExt;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_session::Limit;
@@ -30,6 +30,7 @@ pub struct Autoderef<'a, 'tcx> {
     span: Span,
     body_id: LocalDefId,
     param_env: ty::ParamEnv<'tcx>,
+    defining_use_anchor: DefiningAnchor,
 
     // Current state:
     state: AutoderefSnapshot<'tcx>,
@@ -99,6 +100,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
         body_def_id: LocalDefId,
         span: Span,
         base_ty: Ty<'tcx>,
+        defining_use_anchor: DefiningAnchor,
     ) -> Autoderef<'a, 'tcx> {
         Autoderef {
             infcx,
@@ -114,6 +116,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
             },
             include_raw_pointers: false,
             silence_errors: false,
+            defining_use_anchor,
         }
     }
 
@@ -145,7 +148,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
         let mut fulfillcx = <dyn TraitEngine<'tcx>>::new_in_snapshot(tcx);
         let normalized_ty =
             normalized_ty.into_value_registering_obligations(self.infcx, &mut *fulfillcx);
-        let errors = fulfillcx.select_where_possible(&self.infcx);
+        let errors = fulfillcx.select_where_possible(&self.infcx, self.defining_use_anchor);
         if !errors.is_empty() {
             // This shouldn't happen, except for evaluate/fulfill mismatches,
             // but that's not a reason for an ICE (`predicate_may_hold` is conservative
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -1545,7 +1545,7 @@ pub(super) fn check_generator_obligations(tcx: TyCtxt<'_>, def_id: LocalDefId) {
         let obligation = Obligation::new(tcx, cause.clone(), param_env, *predicate);
         fulfillment_cx.register_predicate_obligation(&infcx, obligation);
     }
-    let errors = fulfillment_cx.select_all_or_error(&infcx);
+    let errors = fulfillment_cx.select_all_or_error(&infcx, DefiningAnchor::Bind(def_id));
     debug!(?errors);
     if !errors.is_empty() {
         infcx.err_ctxt().report_fulfillment_errors(&errors, None);
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1674,7 +1674,14 @@ fn receiver_is_valid<'tcx>(
         return true;
     }
 
-    let mut autoderef = Autoderef::new(infcx, wfcx.param_env, wfcx.body_def_id, span, receiver_ty);
+    let mut autoderef = Autoderef::new(
+        infcx,
+        wfcx.param_env,
+        wfcx.body_def_id,
+        span,
+        receiver_ty,
+        wfcx.ocx.defining_use_anchor(),
+    );
 
     // The `arbitrary_self_types` feature allows raw pointer receivers like `self: *const Self`.
     if arbitrary_self_types_enabled {
diff --git a/compiler/rustc_hir_typeck/src/autoderef.rs b/compiler/rustc_hir_typeck/src/autoderef.rs
@@ -12,7 +12,7 @@ use std::iter;
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     pub fn autoderef(&'a self, span: Span, base_ty: Ty<'tcx>) -> Autoderef<'a, 'tcx> {
-        Autoderef::new(self, self.param_env, self.body_id, span, base_ty)
+        Autoderef::new(self, self.param_env, self.body_id, span, base_ty, self.defining_use_anchor)
     }
 
     pub fn try_overloaded_deref(
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -594,7 +594,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         &self,
         mutate_fulfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
     ) {
-        let mut result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
+        let mut result =
+            self.fulfillment_cx.borrow_mut().select_where_possible(self, self.defining_use_anchor);
         if !result.is_empty() {
             mutate_fulfillment_errors(&mut result);
             self.adjust_fulfillment_errors_for_expr_obligation(&mut result);
@@ -746,7 +747,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let expect_args = self
             .fudge_inference_if_ok(|| {
-                let ocx = ObligationCtxt::new_in_snapshot(self);
+                let ocx = ObligationCtxt::new_in_snapshot(self)
+                    .with_defining_use_anchor(self.defining_use_anchor);
 
                 // Attempt to apply a subtyping relationship between the formal
                 // return type (likely containing type variables if the function
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -507,10 +507,16 @@ fn method_autoderef_steps<'tcx>(
     let (ref infcx, goal, inference_vars) = tcx.infer_ctxt().build_with_canonical(DUMMY_SP, &goal);
     let ParamEnvAnd { param_env, value: self_ty } = goal;
 
-    let mut autoderef =
-        Autoderef::new(infcx, param_env, hir::def_id::CRATE_DEF_ID, DUMMY_SP, self_ty)
-            .include_raw_pointers()
-            .silence_errors();
+    let mut autoderef = Autoderef::new(
+        infcx,
+        param_env,
+        hir::def_id::CRATE_DEF_ID,
+        DUMMY_SP,
+        self_ty,
+        infer::DefiningAnchor::Error,
+    )
+    .include_raw_pointers()
+    .silence_errors();
     let mut reached_raw_pointer = false;
     let mut steps: Vec<_> = autoderef
         .by_ref()
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -111,7 +111,7 @@ impl<'tcx> InferCtxt<'tcx> {
         let tcx = self.tcx;
 
         // Select everything, returning errors.
-        let true_errors = fulfill_cx.select_where_possible(self);
+        let true_errors = fulfill_cx.select_where_possible(self, self.old_defining_use_anchor);
         debug!("true_errors = {:#?}", true_errors);
 
         if !true_errors.is_empty() {
@@ -121,7 +121,7 @@ impl<'tcx> InferCtxt<'tcx> {
         }
 
         // Anything left unselected *now* must be an ambiguity.
-        let ambig_errors = fulfill_cx.select_all_or_error(self);
+        let ambig_errors = fulfill_cx.select_all_or_error(self, self.old_defining_use_anchor);
         debug!("ambig_errors = {:#?}", ambig_errors);
 
         let region_obligations = self.take_registered_region_obligations();
diff --git a/compiler/rustc_infer/src/traits/engine.rs b/compiler/rustc_infer/src/traits/engine.rs
@@ -1,4 +1,4 @@
-use crate::infer::InferCtxt;
+use crate::infer::{DefiningAnchor, InferCtxt};
 use crate::traits::Obligation;
 use rustc_hir::def_id::DefId;
 use rustc_middle::ty::{self, ToPredicate, Ty};
@@ -36,7 +36,11 @@ pub trait TraitEngine<'tcx>: 'tcx {
         obligation: PredicateObligation<'tcx>,
     );
 
-    fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>>;
+    fn select_where_possible(
+        &mut self,
+        infcx: &InferCtxt<'tcx>,
+        defining_use_anchor: DefiningAnchor,
+    ) -> Vec<FulfillmentError<'tcx>>;
 
     fn collect_remaining_errors(&mut self) -> Vec<FulfillmentError<'tcx>>;
 
@@ -58,7 +62,11 @@ pub trait TraitEngineExt<'tcx> {
         obligations: impl IntoIterator<Item = PredicateObligation<'tcx>>,
     );
 
-    fn select_all_or_error(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>>;
+    fn select_all_or_error(
+        &mut self,
+        infcx: &InferCtxt<'tcx>,
+        defining_use_anchor: DefiningAnchor,
+    ) -> Vec<FulfillmentError<'tcx>>;
 }
 
 impl<'tcx, T: ?Sized + TraitEngine<'tcx>> TraitEngineExt<'tcx> for T {
@@ -72,8 +80,12 @@ impl<'tcx, T: ?Sized + TraitEngine<'tcx>> TraitEngineExt<'tcx> for T {
         }
     }
 
-    fn select_all_or_error(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>> {
-        let errors = self.select_where_possible(infcx);
+    fn select_all_or_error(
+        &mut self,
+        infcx: &InferCtxt<'tcx>,
+        defining_use_anchor: DefiningAnchor,
+    ) -> Vec<FulfillmentError<'tcx>> {
+        let errors = self.select_where_possible(infcx, defining_use_anchor);
         if !errors.is_empty() {
             return errors;
         }
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -1,6 +1,6 @@
 use std::mem;
 
-use rustc_infer::infer::InferCtxt;
+use rustc_infer::infer::{DefiningAnchor, InferCtxt};
 use rustc_infer::traits::{
     query::NoSolution, FulfillmentError, FulfillmentErrorCode, MismatchedProjectionTypes,
     PredicateObligation, SelectionError, TraitEngine,
@@ -51,7 +51,11 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentCtxt<'tcx> {
             .collect()
     }
 
-    fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>> {
+    fn select_where_possible(
+        &mut self,
+        infcx: &InferCtxt<'tcx>,
+        _defining_use_anchor: DefiningAnchor,
+    ) -> Vec<FulfillmentError<'tcx>> {
         let mut errors = Vec::new();
         for i in 0.. {
             if !infcx.tcx.recursion_limit().value_within_limit(i) {
diff --git a/compiler/rustc_trait_selection/src/traits/chalk_fulfill.rs b/compiler/rustc_trait_selection/src/traits/chalk_fulfill.rs
@@ -8,6 +8,7 @@ use crate::traits::{
     SelectionError, TraitEngine,
 };
 use rustc_data_structures::fx::FxIndexSet;
+use rustc_infer::infer::DefiningAnchor;
 use rustc_middle::ty::TypeVisitableExt;
 
 pub struct FulfillmentContext<'tcx> {
@@ -54,7 +55,11 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
             .collect()
     }
 
-    fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>> {
+    fn select_where_possible(
+        &mut self,
+        infcx: &InferCtxt<'tcx>,
+        _defining_use_anchor: DefiningAnchor,
+    ) -> Vec<FulfillmentError<'tcx>> {
         if !self.usable_in_snapshot {
             assert!(!infcx.is_in_snapshot());
         }
diff --git a/compiler/rustc_trait_selection/src/traits/engine.rs b/compiler/rustc_trait_selection/src/traits/engine.rs
@@ -65,19 +65,11 @@ impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
     }
 
     pub fn new_with_opaque_type_bubbling(infcx: &'a InferCtxt<'tcx>) -> Self {
-        Self {
-            infcx,
-            engine: RefCell::new(<dyn TraitEngine<'_>>::new(infcx.tcx)),
-            defining_use_anchor: DefiningAnchor::Bubble,
-        }
+        Self::new(infcx).with_defining_use_anchor(DefiningAnchor::Bubble)
     }
 
     pub fn new_with_opaque_type_anchor(infcx: &'a InferCtxt<'tcx>, anchor: LocalDefId) -> Self {
-        Self {
-            infcx,
-            engine: RefCell::new(<dyn TraitEngine<'_>>::new(infcx.tcx)),
-            defining_use_anchor: DefiningAnchor::Bind(anchor),
-        }
+        Self::new(infcx).with_defining_use_anchor(DefiningAnchor::Bind(anchor))
     }
 
     pub fn new_in_snapshot(infcx: &'a InferCtxt<'tcx>) -> Self {
@@ -88,6 +80,10 @@ impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
         }
     }
 
+    pub fn with_defining_use_anchor(self, defining_use_anchor: DefiningAnchor) -> Self {
+        Self { defining_use_anchor, ..self }
+    }
+
     pub fn register_obligation(&self, obligation: PredicateObligation<'tcx>) {
         self.engine.borrow_mut().register_predicate_obligation(self.infcx, obligation);
     }
@@ -203,11 +199,11 @@ impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
     }
 
     pub fn select_where_possible(&self) -> Vec<FulfillmentError<'tcx>> {
-        self.engine.borrow_mut().select_where_possible(self.infcx)
+        self.engine.borrow_mut().select_where_possible(self.infcx, self.defining_use_anchor)
     }
 
     pub fn select_all_or_error(&self) -> Vec<FulfillmentError<'tcx>> {
-        self.engine.borrow_mut().select_all_or_error(self.infcx)
+        self.engine.borrow_mut().select_all_or_error(self.infcx, self.defining_use_anchor)
     }
 
     pub fn assumed_wf_types(
@@ -254,4 +250,8 @@ impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
             &mut **self.engine.borrow_mut(),
         )
     }
+
+    pub fn defining_use_anchor(&self) -> DefiningAnchor {
+        self.defining_use_anchor
+    }
 }
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -2,6 +2,7 @@ use crate::infer::{InferCtxt, TyOrConstInferVar};
 use rustc_data_structures::obligation_forest::ProcessResult;
 use rustc_data_structures::obligation_forest::{Error, ForestObligation, Outcome};
 use rustc_data_structures::obligation_forest::{ObligationForest, ObligationProcessor};
+use rustc_infer::infer::DefiningAnchor;
 use rustc_infer::traits::ProjectionCacheKey;
 use rustc_infer::traits::{SelectionError, TraitEngine, TraitObligation};
 use rustc_middle::mir::interpret::ErrorHandled;
@@ -136,9 +137,12 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
         self.predicates.to_errors(CodeAmbiguity).into_iter().map(to_fulfillment_error).collect()
     }
 
-    fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>> {
-        let selcx =
-            SelectionContext::new(infcx).with_defining_use_anchor(infcx.old_defining_use_anchor);
+    fn select_where_possible(
+        &mut self,
+        infcx: &InferCtxt<'tcx>,
+        defining_use_anchor: DefiningAnchor,
+    ) -> Vec<FulfillmentError<'tcx>> {
+        let selcx = SelectionContext::new(infcx).with_defining_use_anchor(defining_use_anchor);
         self.select(selcx)
     }
 
diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs
@@ -402,7 +402,7 @@ pub fn fully_solve_obligations<'tcx>(
     infcx: &InferCtxt<'tcx>,
     obligations: impl IntoIterator<Item = PredicateObligation<'tcx>>,
 ) -> Vec<FulfillmentError<'tcx>> {
-    let ocx = ObligationCtxt::new(infcx);
+    let ocx = ObligationCtxt::new(infcx).with_defining_use_anchor(infcx.old_defining_use_anchor);
     ocx.register_obligations(obligations);
     ocx.select_all_or_error()
 }
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -625,10 +625,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         let mut fulfill_cx = crate::solve::FulfillmentCtxt::new();
         fulfill_cx.register_predicate_obligations(self.infcx, predicates);
         // True errors
-        if !fulfill_cx.select_where_possible(self.infcx).is_empty() {
+        if !fulfill_cx.select_where_possible(self.infcx, DefiningAnchor::Bubble).is_empty() {
             return Ok(EvaluatedToErr);
         }
-        if !fulfill_cx.select_all_or_error(self.infcx).is_empty() {
+        if !fulfill_cx.select_all_or_error(self.infcx, DefiningAnchor::Bubble).is_empty() {
             return Ok(EvaluatedToAmbig);
         }
         // Regions and opaques are handled in the `evaluation_probe` by looking at the snapshot
diff --git a/compiler/rustc_traits/src/codegen.rs b/compiler/rustc_traits/src/codegen.rs
@@ -63,7 +63,7 @@ pub fn codegen_select_candidate<'tcx>(
     // In principle, we only need to do this so long as `impl_source`
     // contains unbound type parameters. It could be a slight
     // optimization to stop iterating early.
-    let errors = fulfill_cx.select_all_or_error(&infcx);
+    let errors = fulfill_cx.select_all_or_error(&infcx, DefiningAnchor::Bubble);
     if !errors.is_empty() {
         // `rustc_monomorphize::collector` assumes there are no type errors.
         // Cycle errors are the only post-monomorphization errors possible; emit them now so

Original file line number	Diff line number	Diff line change
`@@ -1545,7 +1545,7 @@ pub(super) fn check_generator_obligations(tcx: TyCtxt<'_>, def_id: LocalDefId) {`
`1545`	`1545`	`let obligation = Obligation::new(tcx, cause.clone(), param_env, *predicate);`
`1546`	`1546`	`fulfillment_cx.register_predicate_obligation(&infcx, obligation);`
`1547`	`1547`	`}`
`1548`		`- let errors = fulfillment_cx.select_all_or_error(&infcx);`
	`1548`	`+ let errors = fulfillment_cx.select_all_or_error(&infcx, DefiningAnchor::Bind(def_id));`
`1549`	`1549`	`debug!(?errors);`
`1550`	`1550`	`if !errors.is_empty() {`
`1551`	`1551`	`infcx.err_ctxt().report_fulfillment_errors(&errors, None);`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ use std::iter;`
`12`	`12`
`13`	`13`	`impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`14`	`14`	`pub fn autoderef(&'a self, span: Span, base_ty: Ty<'tcx>) -> Autoderef<'a, 'tcx> {`
`15`		`- Autoderef::new(self, self.param_env, self.body_id, span, base_ty)`
	`15`	`+ Autoderef::new(self, self.param_env, self.body_id, span, base_ty, self.defining_use_anchor)`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`pub fn try_overloaded_deref(`