Remove DefiningAnchor from InferCtxt entirely

Author: oli-obk

compiler/rustc_borrowck/src/consumers.rs

@@ -33,7 +33,7 @@ pub fn get_body_with_borrowck_facts(
     def: ty::WithOptConstParam<LocalDefId>,
 ) -> BodyWithBorrowckFacts<'_> {
     let (input_body, promoted) = tcx.mir_promoted(def);
-    let infcx = tcx.infer_ctxt().with_opaque_type_inference(DefiningAnchor::Bind(def.did)).build();
+    let infcx = tcx.infer_ctxt().build();
     let input_body: &Body<'_> = &input_body.borrow();
     let promoted: &IndexVec<_, _> = &promoted.borrow();
     *super::do_mir_borrowck(&infcx, input_body, promoted, true, DefiningAnchor::Bind(def.did))

compiler/rustc_borrowck/src/lib.rs

@@ -152,8 +152,7 @@ fn mir_borrowck(tcx: TyCtxt<'_>, def: ty::WithOptConstParam<LocalDefId>) -> &Bor
 
     let hir_owner = tcx.hir().local_def_id_to_hir_id(def.did).owner;
 
-    let infcx =
-        tcx.infer_ctxt().with_opaque_type_inference(DefiningAnchor::Bind(hir_owner.def_id)).build();
+    let infcx = tcx.infer_ctxt().build();
     let input_body: &Body<'_> = &input_body.borrow();
     let promoted: &IndexVec<_, _> = &promoted.borrow();
     let opt_closure_req = do_mir_borrowck(

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -3,8 +3,8 @@ use rustc_data_structures::vec_map::VecMap;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::OpaqueTyOrigin;
+use rustc_infer::infer::InferCtxt;
 use rustc_infer::infer::TyCtxtInferExt as _;
-use rustc_infer::infer::{DefiningAnchor, InferCtxt};
 use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_middle::ty::subst::{GenericArgKind, InternalSubsts};
 use rustc_middle::ty::visit::TypeVisitableExt;
@@ -273,11 +273,10 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
         // This logic duplicates most of `check_opaque_meets_bounds`.
         // FIXME(oli-obk): Also do region checks here and then consider removing `check_opaque_meets_bounds` entirely.
         let param_env = self.tcx.param_env(def_id);
+        let infcx = self.tcx.infer_ctxt().build();
         // HACK This bubble is required for this tests to pass:
         // nested-return-type2-tait2.rs
         // nested-return-type2-tait3.rs
-        let infcx =
-            self.tcx.infer_ctxt().with_opaque_type_inference(DefiningAnchor::Bubble).build();
         let ocx = ObligationCtxt::new_with_opaque_type_bubbling(&infcx);
         // Require the hidden type to be well-formed with only the generics of the opaque type.
         // Defining use functions may have more bounds than the opaque type, which is ok, as long as the

compiler/rustc_hir_analysis/src/check/check.rs

@@ -413,10 +413,7 @@ fn check_opaque_meets_bounds<'tcx>(
     };
     let param_env = tcx.param_env(defining_use_anchor);
 
-    let infcx = tcx
-        .infer_ctxt()
-        .with_opaque_type_inference(DefiningAnchor::Bind(defining_use_anchor))
-        .build();
+    let infcx = tcx.infer_ctxt().build();
     let ocx = ObligationCtxt::new_with_opaque_type_anchor(&infcx, defining_use_anchor);
     let opaque_ty = tcx.mk_opaque(def_id.to_def_id(), substs);
 
@@ -1536,15 +1533,14 @@ pub(super) fn check_generator_obligations(tcx: TyCtxt<'_>, def_id: LocalDefId) {
         // typeck writeback gives us predicates with their regions erased.
         // As borrowck already has checked lifetimes, we do not need to do it again.
         .ignoring_regions()
-        // Bind opaque types to `def_id` as they should have been checked by borrowck.
-        .with_opaque_type_inference(DefiningAnchor::Bind(def_id))
         .build();
 
     let mut fulfillment_cx = <dyn TraitEngine<'_>>::new(infcx.tcx);
     for (predicate, cause) in generator_interior_predicates {
         let obligation = Obligation::new(tcx, cause.clone(), param_env, *predicate);
         fulfillment_cx.register_predicate_obligation(&infcx, obligation);
     }
+    // Bind opaque types to `def_id` as they should have been checked by borrowck.
     let errors = fulfillment_cx.select_all_or_error(&infcx, DefiningAnchor::Bind(def_id));
     debug!(?errors);
     if !errors.is_empty() {

compiler/rustc_hir_typeck/src/inherited.rs

@@ -96,10 +96,7 @@ impl<'tcx> Inherited<'tcx> {
         let hir_owner = tcx.hir().local_def_id_to_hir_id(def_id).owner;
 
         InheritedBuilder {
-            infcx: tcx
-                .infer_ctxt()
-                .ignoring_regions()
-                .with_opaque_type_inference(DefiningAnchor::Bind(hir_owner.def_id)),
+            infcx: tcx.infer_ctxt().ignoring_regions(),
             def_id,
             typeck_results: RefCell::new(ty::TypeckResults::new(hir_owner)),
         }

compiler/rustc_infer/src/infer/at.rs

@@ -61,7 +61,6 @@ impl<'tcx> InferCtxt<'tcx> {
     pub fn fork(&self) -> Self {
         Self {
             tcx: self.tcx,
-            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/mod.rs

@@ -232,18 +232,6 @@ pub enum DefiningAnchor {
 pub struct InferCtxt<'tcx> {
     pub tcx: TyCtxt<'tcx>,
 
-    /// The `DefId` of the item in whose context we are performing inference or typeck.
-    /// It is used to check whether an opaque type use is a defining use.
-    ///
-    /// If it is `DefiningAnchor::Bubble`, we can't resolve opaque types here and need to bubble up
-    /// the obligation. This frequently happens for
-    /// short lived InferCtxt within queries. The opaque type obligations are forwarded
-    /// to the outside until the end up in an `InferCtxt` for typeck or borrowck.
-    ///
-    /// Its default value is `DefiningAnchor::Error`, this way it is easier to catch errors that
-    /// might come up during inference or typeck.
-    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
     /// solving is left to borrowck instead.
@@ -537,7 +525,6 @@ impl<'tcx> fmt::Display for FixupError<'tcx> {
 /// Used to configure inference contexts before their creation
 pub struct InferCtxtBuilder<'tcx> {
     tcx: TyCtxt<'tcx>,
-    defining_use_anchor: DefiningAnchor,
     considering_regions: bool,
     /// Whether we are in coherence mode.
     intercrate: bool,
@@ -549,27 +536,11 @@ pub trait TyCtxtInferExt<'tcx> {
 
 impl<'tcx> TyCtxtInferExt<'tcx> for TyCtxt<'tcx> {
     fn infer_ctxt(self) -> InferCtxtBuilder<'tcx> {
-        InferCtxtBuilder {
-            tcx: self,
-            defining_use_anchor: DefiningAnchor::Error,
-            considering_regions: true,
-            intercrate: false,
-        }
+        InferCtxtBuilder { tcx: self, considering_regions: true, intercrate: false }
     }
 }
 
 impl<'tcx> InferCtxtBuilder<'tcx> {
-    /// Whenever the `InferCtxt` should be able to handle defining uses of opaque types,
-    /// you need to call this function. Otherwise the opaque type will be treated opaquely.
-    ///
-    /// It is only meant to be called in two places, for typeck
-    /// (via `Inherited::build`) and for the inference context used
-    /// in mir borrowck.
-    pub fn with_opaque_type_inference(mut self, defining_use_anchor: DefiningAnchor) -> Self {
-        self.defining_use_anchor = defining_use_anchor;
-        self
-    }
-
     pub fn intercrate(mut self) -> Self {
         self.intercrate = true;
         self
@@ -601,10 +572,9 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
     }
 
     pub fn build(&mut self) -> InferCtxt<'tcx> {
-        let InferCtxtBuilder { tcx, defining_use_anchor, considering_regions, intercrate } = *self;
+        let InferCtxtBuilder { tcx, considering_regions, intercrate } = *self;
         InferCtxt {
             tcx,
-            old_defining_use_anchor: defining_use_anchor,
             considering_regions,
             inner: RefCell::new(InferCtxtInner::new()),
             lexical_region_resolutions: RefCell::new(None),

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

@@ -228,6 +228,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     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)
         }

compiler/rustc_traits/src/codegen.rs

@@ -29,12 +29,8 @@ pub fn codegen_select_candidate<'tcx>(
 
     // Do the initial selection for the obligation. This yields the
     // shallow result we are looking for -- that is, what specific impl.
-    let infcx = tcx
-        .infer_ctxt()
-        .ignoring_regions()
-        .with_opaque_type_inference(DefiningAnchor::Bubble)
-        .build();
-    //~^ HACK `Bubble` is required for
+    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);
 

compiler/rustc_traits/src/evaluate_obligation.rs

@@ -1,4 +1,4 @@
-use rustc_infer::infer::{DefiningAnchor, TyCtxtInferExt};
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::{ParamEnvAnd, TyCtxt};
 use rustc_span::source_map::DUMMY_SP;
@@ -16,12 +16,8 @@ fn evaluate_obligation<'tcx>(
     canonical_goal: CanonicalPredicateGoal<'tcx>,
 ) -> Result<EvaluationResult, OverflowError> {
     debug!("evaluate_obligation(canonical_goal={:#?})", canonical_goal);
-    // HACK This bubble is required for this tests to pass:
-    // impl-trait/issue99642.rs
-    let (ref infcx, goal, _canonical_inference_vars) = tcx
-        .infer_ctxt()
-        .with_opaque_type_inference(DefiningAnchor::Bubble)
-        .build_with_canonical(DUMMY_SP, &canonical_goal);
+    let (ref infcx, goal, _canonical_inference_vars) =
+        tcx.infer_ctxt().build_with_canonical(DUMMY_SP, &canonical_goal);
     debug!("evaluate_obligation: goal={:#?}", goal);
     let ParamEnvAnd { param_env, value: predicate } = goal;