Remove the now-redundant field from Inherited

oli-obk · oli-obk · commit a5f9af250581 · 2023-03-01T11:24:35.000Z
diff --git a/compiler/rustc_hir_typeck/src/autoderef.rs b/compiler/rustc_hir_typeck/src/autoderef.rs
@@ -12,7 +12,14 @@ 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, self.defining_use_anchor)
+        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/check.rs b/compiler/rustc_hir_typeck/src/check.rs
@@ -46,7 +46,7 @@ pub(super) fn check_fn<'a, 'tcx>(
             fn_def_id,
             decl.output.span(),
             fcx.param_env,
-            fcx.defining_use_anchor,
+            fcx.defining_use_anchor(),
         ));
 
     fcx.ret_coercion = Some(RefCell::new(CoerceMany::new(ret_ty)));
diff --git a/compiler/rustc_hir_typeck/src/closure.rs b/compiler/rustc_hir_typeck/src/closure.rs
@@ -565,7 +565,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let cause = self.misc(hir_ty.span);
                 let InferOk { value: (), obligations } = self
                     .at(&cause, self.param_env)
-                    .define_opaque_types(self.defining_use_anchor)
+                    .define_opaque_types(self.defining_use_anchor())
                     .eq(*expected_ty, supplied_ty)?;
                 all_obligations.extend(obligations);
             }
@@ -578,7 +578,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             let cause = &self.misc(decl.output.span());
             let InferOk { value: (), obligations } = self
                 .at(cause, self.param_env)
-                .define_opaque_types(self.defining_use_anchor)
+                .define_opaque_types(self.defining_use_anchor())
                 .eq(expected_sigs.liberated_sig.output(), supplied_output_ty)?;
             all_obligations.extend(obligations);
 
@@ -735,7 +735,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 body_def_id,
                 self.tcx.def_span(expr_def_id),
                 self.param_env,
-                self.defining_use_anchor,
+                self.defining_use_anchor(),
             );
         self.register_predicates(obligations);
 
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -145,7 +145,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         self.commit_if_ok(|_| {
             let at = self
                 .at(&self.cause, self.fcx.param_env)
-                .define_opaque_types(self.defining_use_anchor);
+                .define_opaque_types(self.defining_use_anchor());
             if self.use_lub {
                 at.lub(b, a)
             } else {
@@ -178,7 +178,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             // due to `[type error]` and `_` not coercing together.
             let _ = self.commit_if_ok(|_| {
                 self.at(&self.cause, self.param_env)
-                    .define_opaque_types(self.defining_use_anchor)
+                    .define_opaque_types(self.defining_use_anchor())
                     .eq(a, b)
             });
             return success(vec![], self.fcx.tcx.ty_error(guar), vec![]);
@@ -585,8 +585,8 @@ 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)
+            .with_defining_use_anchor(self.defining_use_anchor());
 
         // Create an obligation for `Source: CoerceUnsized<Target>`.
         let cause = ObligationCause::new(
@@ -1492,7 +1492,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
             assert!(expression_ty.is_unit(), "if let hack without unit type");
             fcx.at(cause, fcx.param_env)
                 // needed for tests/ui/type-alias-impl-trait/issue-65679-inst-opaque-ty-from-val-twice.rs
-                .define_opaque_types(fcx.defining_use_anchor)
+                .define_opaque_types(fcx.defining_use_anchor())
                 .eq_exp(label_expression_as_expected, expression_ty, self.merged_ty())
                 .map(|infer_ok| {
                     fcx.register_infer_ok_obligations(infer_ok);
diff --git a/compiler/rustc_hir_typeck/src/demand.rs b/compiler/rustc_hir_typeck/src/demand.rs
@@ -115,7 +115,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ) -> Option<DiagnosticBuilder<'tcx, ErrorGuaranteed>> {
         match self
             .at(cause, self.param_env)
-            .define_opaque_types(self.defining_use_anchor)
+            .define_opaque_types(self.defining_use_anchor())
             .sup(expected, actual)
         {
             Ok(InferOk { obligations, value: () }) => {
@@ -149,7 +149,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ) -> Option<DiagnosticBuilder<'tcx, ErrorGuaranteed>> {
         match self
             .at(cause, self.param_env)
-            .define_opaque_types(self.defining_use_anchor)
+            .define_opaque_types(self.defining_use_anchor())
             .eq(expected, actual)
         {
             Ok(InferOk { obligations, value: () }) => {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -738,15 +738,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 if let ty::subst::GenericArgKind::Type(ty) = ty.unpack()
                     && let ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }) = *ty.kind()
                     && let Some(def_id) = def_id.as_local()
-                    && self.opaque_type_origin(def_id, self.defining_use_anchor).is_some() {
+                    && self.opaque_type_origin(def_id, self.defining_use_anchor()).is_some() {
                     return None;
                 }
             }
         }
 
         let expect_args = self
             .fudge_inference_if_ok(|| {
-                let ocx = ObligationCtxt::new_in_snapshot(self, self.defining_use_anchor);
+                let ocx = ObligationCtxt::new_in_snapshot(self, self.defining_use_anchor());
 
                 // Attempt to apply a subtyping relationship between the formal
                 // return type (likely containing type variables if the function
@@ -1460,7 +1460,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self.param_env,
             original_values,
             query_result,
-            self.defining_use_anchor,
+            self.defining_use_anchor(),
         )
     }
 
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).with_defining_use_anchor(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/inherited.rs b/compiler/rustc_hir_typeck/src/inherited.rs
@@ -28,13 +28,6 @@ use std::ops::Deref;
 pub struct Inherited<'tcx> {
     pub(super) infcx: InferCtxt<'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.
-    ///
-    /// Its default value is `DefiningAnchor::Error`, this way it is easier to catch errors that
-    /// might come up during inference or typeck.
-    pub(super) defining_use_anchor: DefiningAnchor,
-
     pub(super) typeck_results: RefCell<ty::TypeckResults<'tcx>>,
 
     pub(super) locals: RefCell<HirIdMap<super::LocalTy<'tcx>>>,
@@ -124,7 +117,6 @@ impl<'tcx> Inherited<'tcx> {
 
         let defining_use_anchor = DefiningAnchor::Bind(typeck_results.borrow().hir_owner.def_id);
         Inherited {
-            defining_use_anchor,
             typeck_results,
             infcx,
             fulfillment_cx: RefCell::new(<dyn TraitEngine<'_>>::new(tcx, defining_use_anchor)),
@@ -141,6 +133,10 @@ impl<'tcx> Inherited<'tcx> {
         }
     }
 
+    pub fn defining_use_anchor(&self) -> DefiningAnchor {
+        self.fulfillment_cx.borrow().defining_use_anchor()
+    }
+
     #[instrument(level = "debug", skip(self))]
     pub(super) fn register_predicate(&self, obligation: traits::PredicateObligation<'tcx>) {
         if obligation.has_escaping_bound_vars() {
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -1429,7 +1429,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         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)
+            .with_defining_use_anchor(self.defining_use_anchor())
             .select(&obligation)
     }
 
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
@@ -778,7 +778,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 Err(rustc_trait_selection::traits::fully_solve_obligation(
                     self,
                     obligation,
-                    self.defining_use_anchor,
+                    self.defining_use_anchor(),
                 ))
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -738,15 +738,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`738`	`738`	`if let ty::subst::GenericArgKind::Type(ty) = ty.unpack()`
`739`	`739`	`&& let ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }) = *ty.kind()`
`740`	`740`	`&& let Some(def_id) = def_id.as_local()`
`741`		`- && self.opaque_type_origin(def_id, self.defining_use_anchor).is_some() {`
	`741`	`+ && self.opaque_type_origin(def_id, self.defining_use_anchor()).is_some() {`
`742`	`742`	`return None;`
`743`	`743`	`}`
`744`	`744`	`}`
`745`	`745`	`}`
`746`	`746`
`747`	`747`	`let expect_args = self`
`748`	`748`	`.fudge_inference_if_ok(\|\| {`
`749`		`- let ocx = ObligationCtxt::new_in_snapshot(self, self.defining_use_anchor);`
	`749`	`+ let ocx = ObligationCtxt::new_in_snapshot(self, self.defining_use_anchor());`
`750`	`750`
`751`	`751`	`// Attempt to apply a subtyping relationship between the formal`
`752`	`752`	`// return type (likely containing type variables if the function`
`@@ -1460,7 +1460,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1460`	`1460`	`self.param_env,`
`1461`	`1461`	`original_values,`
`1462`	`1462`	`query_result,`
`1463`		`- self.defining_use_anchor,`
	`1463`	`+ self.defining_use_anchor(),`
`1464`	`1464`	`)`
`1465`	`1465`	`}`
`1466`	`1466`
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).with_defining_use_anchor(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
`@@ -1429,7 +1429,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {`
`1429`	`1429`	`let predicate = ty::Binder::dummy(trait_ref);`
`1430`	`1430`	`let obligation = traits::Obligation::new(self.tcx, cause, self.param_env, predicate);`
`1431`	`1431`	`traits::SelectionContext::new(self)`
`1432`		`- .with_defining_use_anchor(self.defining_use_anchor)`
	`1432`	`+ .with_defining_use_anchor(self.defining_use_anchor())`
`1433`	`1433`	`.select(&obligation)`
`1434`	`1434`	`}`
`1435`	`1435`
Original file line number	Diff line number	Diff line change
`@@ -778,7 +778,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`778`	`778`	`Err(rustc_trait_selection::traits::fully_solve_obligation(`
`779`	`779`	`self,`
`780`	`780`	`obligation,`
`781`		`- self.defining_use_anchor,`
	`781`	`+ self.defining_use_anchor(),`
`782`	`782`	`))`
`783`	`783`	`}`
`784`	`784`	`}`