Prefer a local DefiningAnchor over the InferCtxt one

Author: oli-obk

compiler/rustc_borrowck/src/consumers.rs

@@ -36,5 +36,7 @@ pub fn get_body_with_borrowck_facts(
     let infcx = tcx.infer_ctxt().with_opaque_type_inference(DefiningAnchor::Bind(def.did)).build();
     let input_body: &Body<'_> = &input_body.borrow();
     let promoted: &IndexVec<_, _> = &promoted.borrow();
-    *super::do_mir_borrowck(&infcx, input_body, promoted, true).1.unwrap()
+    *super::do_mir_borrowck(&infcx, input_body, promoted, true, DefiningAnchor::Bind(def.did))
+        .1
+        .unwrap()
 }

compiler/rustc_borrowck/src/lib.rs

@@ -156,7 +156,14 @@ fn mir_borrowck(tcx: TyCtxt<'_>, def: ty::WithOptConstParam<LocalDefId>) -> &Bor
         tcx.infer_ctxt().with_opaque_type_inference(DefiningAnchor::Bind(hir_owner.def_id)).build();
     let input_body: &Body<'_> = &input_body.borrow();
     let promoted: &IndexVec<_, _> = &promoted.borrow();
-    let opt_closure_req = do_mir_borrowck(&infcx, input_body, promoted, false).0;
+    let opt_closure_req = do_mir_borrowck(
+        &infcx,
+        input_body,
+        promoted,
+        false,
+        DefiningAnchor::Bind(hir_owner.def_id),
+    )
+    .0;
     debug!("mir_borrowck done");
 
     tcx.arena.alloc(opt_closure_req)
@@ -173,6 +180,7 @@ fn do_mir_borrowck<'tcx>(
     input_body: &Body<'tcx>,
     input_promoted: &IndexVec<Promoted, Body<'tcx>>,
     return_body_with_facts: bool,
+    defining_use_anchor: DefiningAnchor,
 ) -> (BorrowCheckResult<'tcx>, Option<Box<BodyWithBorrowckFacts<'tcx>>>) {
     let def = input_body.source.with_opt_param().as_local().unwrap();
     debug!(?def);
@@ -275,6 +283,7 @@ fn do_mir_borrowck<'tcx>(
         &borrow_set,
         &upvars,
         use_polonius,
+        defining_use_anchor,
     );
 
     // Dump MIR results into a file, if that is enabled. This let us

compiler/rustc_borrowck/src/nll.rs

@@ -5,6 +5,7 @@
 use rustc_data_structures::vec_map::VecMap;
 use rustc_hir::def_id::LocalDefId;
 use rustc_index::vec::IndexVec;
+use rustc_infer::infer::DefiningAnchor;
 use rustc_middle::mir::{create_dump_file, dump_enabled, dump_mir, PassWhere};
 use rustc_middle::mir::{
     BasicBlock, Body, ClosureOutlivesSubject, ClosureRegionRequirements, LocalKind, Location,
@@ -167,6 +168,7 @@ pub(crate) fn compute_regions<'cx, 'tcx>(
     borrow_set: &BorrowSet<'tcx>,
     upvars: &[Upvar<'tcx>],
     use_polonius: bool,
+    defining_use_anchor: DefiningAnchor,
 ) -> NllOutput<'tcx> {
     let mut all_facts =
         (use_polonius || AllFacts::enabled(infcx.tcx)).then_some(AllFacts::default());
@@ -191,6 +193,7 @@ pub(crate) fn compute_regions<'cx, 'tcx>(
             elements,
             upvars,
             use_polonius,
+            defining_use_anchor,
         );
 
     if let Some(all_facts) = &mut all_facts {

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -21,7 +21,8 @@ use rustc_infer::infer::outlives::env::RegionBoundPairs;
 use rustc_infer::infer::region_constraints::RegionConstraintData;
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc_infer::infer::{
-    InferCtxt, InferOk, LateBoundRegion, LateBoundRegionConversionTime, NllRegionVariableOrigin,
+    DefiningAnchor, InferCtxt, InferOk, LateBoundRegion, LateBoundRegionConversionTime,
+    NllRegionVariableOrigin,
 };
 use rustc_middle::mir::tcx::PlaceTy;
 use rustc_middle::mir::visit::{NonMutatingUseContext, PlaceContext, Visitor};
@@ -136,6 +137,7 @@ pub(crate) fn type_check<'mir, 'tcx>(
     elements: &Rc<RegionValueElements>,
     upvars: &[Upvar<'tcx>],
     use_polonius: bool,
+    defining_use_anchor: DefiningAnchor,
 ) -> MirTypeckResults<'tcx> {
     let implicit_region_bound = infcx.tcx.mk_re_var(universal_regions.fr_fn_body);
     let mut constraints = MirTypeckRegionConstraints {
@@ -182,6 +184,7 @@ pub(crate) fn type_check<'mir, 'tcx>(
         &region_bound_pairs,
         implicit_region_bound,
         &mut borrowck_context,
+        defining_use_anchor,
     );
 
     let errors_reported = {
@@ -877,6 +880,7 @@ struct TypeChecker<'a, 'tcx> {
     implicit_region_bound: ty::Region<'tcx>,
     reported_errors: FxHashSet<(Ty<'tcx>, Span)>,
     borrowck_context: &'a mut BorrowCheckContext<'a, 'tcx>,
+    defining_use_anchor: DefiningAnchor,
 }
 
 struct BorrowCheckContext<'a, 'tcx> {
@@ -1025,6 +1029,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         region_bound_pairs: &'a RegionBoundPairs<'tcx>,
         implicit_region_bound: ty::Region<'tcx>,
         borrowck_context: &'a mut BorrowCheckContext<'a, 'tcx>,
+        defining_use_anchor: DefiningAnchor,
     ) -> Self {
         let mut checker = Self {
             infcx,
@@ -1036,6 +1041,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             implicit_region_bound,
             borrowck_context,
             reported_errors: Default::default(),
+            defining_use_anchor,
         };
         checker.check_user_type_annotations();
         checker

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -88,7 +88,7 @@ impl<'tcx> TypeRelatingDelegate<'tcx> for NllTypeRelatingDelegate<'_, '_, 'tcx>
     }
 
     fn defining_use_anchor(&self) -> rustc_infer::infer::DefiningAnchor {
-        self.type_checker.infcx.defining_use_anchor
+        self.type_checker.defining_use_anchor
     }
 
     fn param_env(&self) -> ty::ParamEnv<'tcx> {

compiler/rustc_hir_typeck/src/demand.rs

@@ -113,7 +113,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expected: Ty<'tcx>,
         actual: Ty<'tcx>,
     ) -> Option<DiagnosticBuilder<'tcx, ErrorGuaranteed>> {
-        match self.at(cause, self.param_env).define_opaque_types(self.defining_use_anchor).sup(expected, actual) {
+        match self
+            .at(cause, self.param_env)
+            .define_opaque_types(self.defining_use_anchor)
+            .sup(expected, actual)
+        {
             Ok(InferOk { obligations, value: () }) => {
                 self.register_predicates(obligations);
                 None

compiler/rustc_infer/src/infer/at.rs

@@ -61,7 +61,7 @@ impl<'tcx> InferCtxt<'tcx> {
     pub fn fork(&self) -> Self {
         Self {
             tcx: self.tcx,
-            defining_use_anchor: self.defining_use_anchor,
+            old_defining_use_anchor: self.old_defining_use_anchor,
             considering_regions: self.considering_regions,
             inner: self.inner.clone(),
             skip_leak_check: self.skip_leak_check.clone(),

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

@@ -501,7 +501,7 @@ impl<'tcx> InferCtxt<'tcx> {
             debug!(?a, ?b, "constrain opaque type");
             obligations.extend(
                 self.at(cause, param_env)
-                    .define_opaque_types(self.defining_use_anchor)
+                    .define_opaque_types(self.old_defining_use_anchor)
                     .eq(a, b)?
                     .obligations,
             );

compiler/rustc_infer/src/infer/mod.rs

@@ -242,7 +242,7 @@ pub struct InferCtxt<'tcx> {
     ///
     /// Its default value is `DefiningAnchor::Error`, this way it is easier to catch errors that
     /// might come up during inference or typeck.
-    pub defining_use_anchor: DefiningAnchor,
+    pub old_defining_use_anchor: DefiningAnchor,
 
     /// Whether this inference context should care about region obligations in
     /// the root universe. Most notably, this is used during hir typeck as region
@@ -604,7 +604,7 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
         let InferCtxtBuilder { tcx, defining_use_anchor, considering_regions, intercrate } = *self;
         InferCtxt {
             tcx,
-            defining_use_anchor,
+            old_defining_use_anchor: defining_use_anchor,
             considering_regions,
             inner: RefCell::new(InferCtxtInner::new()),
             lexical_region_resolutions: RefCell::new(None),
@@ -1318,7 +1318,7 @@ impl<'tcx> InferCtxt<'tcx> {
 
     #[instrument(level = "debug", skip(self), ret)]
     pub fn take_opaque_types(&self) -> opaque_types::OpaqueTypeMap<'tcx> {
-        debug_assert_ne!(self.defining_use_anchor, DefiningAnchor::Error);
+        debug_assert_ne!(self.old_defining_use_anchor, DefiningAnchor::Error);
         std::mem::take(&mut self.inner.borrow_mut().opaque_type_storage.opaque_types)
     }
 

compiler/rustc_trait_selection/src/traits/engine.rs

@@ -11,7 +11,7 @@ use rustc_infer::infer::at::ToTrace;
 use rustc_infer::infer::canonical::{
     Canonical, CanonicalQueryResponse, CanonicalVarValues, QueryResponse,
 };
-use rustc_infer::infer::{InferCtxt, InferOk};
+use rustc_infer::infer::{DefiningAnchor, InferCtxt, InferOk};
 use rustc_infer::traits::query::Fallible;
 use rustc_infer::traits::{
     FulfillmentError, Obligation, ObligationCause, PredicateObligation, TraitEngineExt as _,
@@ -52,15 +52,24 @@ impl<'tcx> TraitEngineExt<'tcx> for dyn TraitEngine<'tcx> {
 pub struct ObligationCtxt<'a, 'tcx> {
     pub infcx: &'a InferCtxt<'tcx>,
     engine: RefCell<Box<dyn TraitEngine<'tcx>>>,
+    defining_use_anchor: DefiningAnchor,
 }
 
 impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
     pub fn new(infcx: &'a InferCtxt<'tcx>) -> Self {
-        Self { infcx, engine: RefCell::new(<dyn TraitEngine<'_>>::new(infcx.tcx)) }
+        Self {
+            infcx,
+            engine: RefCell::new(<dyn TraitEngine<'_>>::new(infcx.tcx)),
+            defining_use_anchor: infcx.old_defining_use_anchor,
+        }
     }
 
     pub fn new_in_snapshot(infcx: &'a InferCtxt<'tcx>) -> Self {
-        Self { infcx, engine: RefCell::new(<dyn TraitEngine<'_>>::new_in_snapshot(infcx.tcx)) }
+        Self {
+            infcx,
+            engine: RefCell::new(<dyn TraitEngine<'_>>::new_in_snapshot(infcx.tcx)),
+            defining_use_anchor: infcx.old_defining_use_anchor,
+        }
     }
 
     pub fn register_obligation(&self, obligation: PredicateObligation<'tcx>) {
@@ -128,7 +137,7 @@ impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
     {
         self.infcx
             .at(cause, param_env)
-            .define_opaque_types(self.infcx.defining_use_anchor)
+            .define_opaque_types(self.defining_use_anchor)
             .eq_exp(a_is_expected, a, b)
             .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
     }
@@ -142,7 +151,7 @@ impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
     ) -> Result<(), TypeError<'tcx>> {
         self.infcx
             .at(cause, param_env)
-            .define_opaque_types(self.infcx.defining_use_anchor)
+            .define_opaque_types(self.defining_use_anchor)
             .eq(expected, actual)
             .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
     }
@@ -157,7 +166,7 @@ impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
     ) -> Result<(), TypeError<'tcx>> {
         self.infcx
             .at(cause, param_env)
-            .define_opaque_types(self.infcx.defining_use_anchor)
+            .define_opaque_types(self.defining_use_anchor)
             .sup(expected, actual)
             .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
     }
@@ -172,7 +181,7 @@ impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
     ) -> Result<(), TypeError<'tcx>> {
         self.infcx
             .at(cause, param_env)
-            .define_opaque_types(self.infcx.defining_use_anchor)
+            .define_opaque_types(self.defining_use_anchor)
             .sup(expected, actual)
             .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
     }