Don't look at InferCtxt::defining_use_anchor from deep inside the opaque type resolution and pass it down instead

oli-obk · oli-obk · commit 0d4017cb1659 · 2023-03-01T11:24:33.000Z
diff --git a/compiler/rustc_borrowck/src/type_check/relate_tys.rs b/compiler/rustc_borrowck/src/type_check/relate_tys.rs
@@ -87,6 +87,10 @@ impl<'tcx> TypeRelatingDelegate<'tcx> for NllTypeRelatingDelegate<'_, '_, 'tcx>
         self.locations.span(self.type_checker.body)
     }
 
+    fn defining_use_anchor(&self) -> rustc_infer::infer::DefiningAnchor {
+        self.type_checker.infcx.defining_use_anchor
+    }
+
     fn param_env(&self) -> ty::ParamEnv<'tcx> {
         self.type_checker.param_env
     }
diff --git a/compiler/rustc_hir_typeck/src/check.rs b/compiler/rustc_hir_typeck/src/check.rs
@@ -46,6 +46,7 @@ pub(super) fn check_fn<'a, 'tcx>(
             fn_def_id,
             decl.output.span(),
             fcx.param_env,
+            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(true)
+                    .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(true)
+                .define_opaque_types(self.defining_use_anchor)
                 .eq(expected_sigs.liberated_sig.output(), supplied_output_ty)?;
             all_obligations.extend(obligations);
 
@@ -735,6 +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.register_predicates(obligations);
 
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -143,7 +143,9 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
     fn unify(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> InferResult<'tcx, Ty<'tcx>> {
         debug!("unify(a: {:?}, b: {:?}, use_lub: {})", a, b, self.use_lub);
         self.commit_if_ok(|_| {
-            let at = self.at(&self.cause, self.fcx.param_env).define_opaque_types(true);
+            let at = self
+                .at(&self.cause, self.fcx.param_env)
+                .define_opaque_types(self.defining_use_anchor);
             if self.use_lub {
                 at.lub(b, a)
             } else {
@@ -175,7 +177,9 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             // so this will have the side-effect of making sure we have no ambiguities
             // due to `[type error]` and `_` not coercing together.
             let _ = self.commit_if_ok(|_| {
-                self.at(&self.cause, self.param_env).define_opaque_types(true).eq(a, b)
+                self.at(&self.cause, self.param_env)
+                    .define_opaque_types(self.defining_use_anchor)
+                    .eq(a, b)
             });
             return success(vec![], self.fcx.tcx.ty_error(guar), vec![]);
         }
@@ -1487,7 +1491,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(true)
+                .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
@@ -113,7 +113,7 @@ 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(true).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
@@ -143,7 +143,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(true).eq(expected, actual) {
+        match self
+            .at(cause, self.param_env)
+            .define_opaque_types(self.defining_use_anchor)
+            .eq(expected, actual)
+        {
             Ok(InferOk { obligations, value: () }) => {
                 self.register_predicates(obligations);
                 None
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -738,7 +738,7 @@ 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).is_some() {
+                    && self.opaque_type_origin(def_id, self.defining_use_anchor).is_some() {
                     return None;
                 }
             }
diff --git a/compiler/rustc_infer/src/infer/at.rs b/compiler/rustc_infer/src/infer/at.rs
@@ -36,10 +36,7 @@ pub struct At<'a, 'tcx> {
     pub param_env: ty::ParamEnv<'tcx>,
     /// Whether we should define opaque types
     /// or just treat them opaquely.
-    /// Currently only used to prevent predicate
-    /// matching from matching anything against opaque
-    /// types.
-    pub define_opaque_types: bool,
+    pub define_opaque_types: DefiningAnchor,
 }
 
 pub struct Trace<'a, 'tcx> {
@@ -55,7 +52,7 @@ impl<'tcx> InferCtxt<'tcx> {
         cause: &'a ObligationCause<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
     ) -> At<'a, 'tcx> {
-        At { infcx: self, cause, param_env, define_opaque_types: false }
+        At { infcx: self, cause, param_env, define_opaque_types: DefiningAnchor::Error }
     }
 
     /// Forks the inference context, creating a new inference context with the same inference
@@ -93,7 +90,7 @@ pub trait ToTrace<'tcx>: Relate<'tcx> + Copy {
 }
 
 impl<'a, 'tcx> At<'a, 'tcx> {
-    pub fn define_opaque_types(self, define_opaque_types: bool) -> Self {
+    pub fn define_opaque_types(self, define_opaque_types: DefiningAnchor) -> Self {
         Self { define_opaque_types, ..self }
     }
 
diff --git a/compiler/rustc_infer/src/infer/canonical/query_response.rs b/compiler/rustc_infer/src/infer/canonical/query_response.rs
@@ -14,7 +14,7 @@ use crate::infer::canonical::{
 };
 use crate::infer::nll_relate::{TypeRelating, TypeRelatingDelegate};
 use crate::infer::region_constraints::{Constraint, RegionConstraintData};
-use crate::infer::{InferCtxt, InferOk, InferResult, NllRegionVariableOrigin};
+use crate::infer::{DefiningAnchor, InferCtxt, InferOk, InferResult, NllRegionVariableOrigin};
 use crate::traits::query::{Fallible, NoSolution};
 use crate::traits::{Obligation, ObligationCause, PredicateObligation};
 use crate::traits::{PredicateObligations, TraitEngine, TraitEngineExt};
@@ -499,8 +499,12 @@ impl<'tcx> InferCtxt<'tcx> {
             let a = substitute_value(self.tcx, &result_subst, a);
             let b = substitute_value(self.tcx, &result_subst, b);
             debug!(?a, ?b, "constrain opaque type");
-            obligations
-                .extend(self.at(cause, param_env).define_opaque_types(true).eq(a, b)?.obligations);
+            obligations.extend(
+                self.at(cause, param_env)
+                    .define_opaque_types(self.defining_use_anchor)
+                    .eq(a, b)?
+                    .obligations,
+            );
         }
 
         Ok(InferOk { value: result_subst, obligations })
@@ -677,6 +681,10 @@ impl<'tcx> TypeRelatingDelegate<'tcx> for QueryTypeRelatingDelegate<'_, 'tcx> {
         self.param_env
     }
 
+    fn defining_use_anchor(&self) -> DefiningAnchor {
+        DefiningAnchor::Bubble
+    }
+
     fn create_next_universe(&mut self) -> ty::UniverseIndex {
         self.infcx.create_next_universe()
     }
diff --git a/compiler/rustc_infer/src/infer/combine.rs b/compiler/rustc_infer/src/infer/combine.rs
@@ -27,7 +27,7 @@ use super::glb::Glb;
 use super::lub::Lub;
 use super::sub::Sub;
 use super::type_variable::TypeVariableValue;
-use super::{InferCtxt, MiscVariable, TypeTrace};
+use super::{DefiningAnchor, InferCtxt, MiscVariable, TypeTrace};
 use crate::traits::{Obligation, PredicateObligations};
 use rustc_data_structures::sso::SsoHashMap;
 use rustc_hir::def_id::DefId;
@@ -55,10 +55,7 @@ pub struct CombineFields<'infcx, 'tcx> {
     pub obligations: PredicateObligations<'tcx>,
     /// Whether we should define opaque types
     /// or just treat them opaquely.
-    /// Currently only used to prevent predicate
-    /// matching from matching anything against opaque
-    /// types.
-    pub define_opaque_types: bool,
+    pub define_opaque_types: DefiningAnchor,
 }
 
 #[derive(Copy, Clone, Debug)]
diff --git a/compiler/rustc_infer/src/infer/equate.rs b/compiler/rustc_infer/src/infer/equate.rs
@@ -110,7 +110,7 @@ impl<'tcx> TypeRelation<'tcx> for Equate<'_, '_, 'tcx> {
             }
             (&ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }), _)
             | (_, &ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }))
-                if self.fields.define_opaque_types && def_id.is_local() =>
+                if def_id.is_local() =>
             {
                 self.fields.obligations.extend(
                     infcx
@@ -120,6 +120,7 @@ impl<'tcx> TypeRelation<'tcx> for Equate<'_, '_, 'tcx> {
                             self.a_is_expected(),
                             &self.fields.trace.cause,
                             self.param_env(),
+                            self.fields.define_opaque_types,
                         )?
                         .obligations,
                 );
diff --git a/compiler/rustc_infer/src/infer/glb.rs b/compiler/rustc_infer/src/infer/glb.rs
@@ -2,8 +2,8 @@
 
 use super::combine::{CombineFields, ObligationEmittingRelation};
 use super::lattice::{self, LatticeDir};
-use super::InferCtxt;
 use super::Subtype;
+use super::{DefiningAnchor, InferCtxt};
 
 use crate::traits::{ObligationCause, PredicateObligations};
 use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
@@ -142,7 +142,7 @@ impl<'combine, 'infcx, 'tcx> LatticeDir<'infcx, 'tcx> for Glb<'combine, 'infcx,
         Ok(())
     }
 
-    fn define_opaque_types(&self) -> bool {
+    fn define_opaque_types(&self) -> DefiningAnchor {
         self.fields.define_opaque_types
     }
 }
diff --git a/compiler/rustc_infer/src/infer/lattice.rs b/compiler/rustc_infer/src/infer/lattice.rs
@@ -19,7 +19,7 @@
 
 use super::combine::ObligationEmittingRelation;
 use super::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
-use super::InferCtxt;
+use super::{DefiningAnchor, InferCtxt};
 
 use crate::traits::ObligationCause;
 use rustc_middle::ty::relate::RelateResult;
@@ -36,7 +36,7 @@ pub trait LatticeDir<'f, 'tcx>: ObligationEmittingRelation<'tcx> {
 
     fn cause(&self) -> &ObligationCause<'tcx>;
 
-    fn define_opaque_types(&self) -> bool;
+    fn define_opaque_types(&self) -> DefiningAnchor;
 
     // Relates the type `v` to `a` and `b` such that `v` represents
     // the LUB/GLB of `a` and `b` as appropriate.
@@ -110,11 +110,18 @@ where
         ) if a_def_id == b_def_id => infcx.super_combine_tys(this, a, b),
         (&ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }), _)
         | (_, &ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }))
-            if this.define_opaque_types() && def_id.is_local() =>
+            if def_id.is_local() =>
         {
             this.register_obligations(
                 infcx
-                    .handle_opaque_type(a, b, this.a_is_expected(), this.cause(), this.param_env())?
+                    .handle_opaque_type(
+                        a,
+                        b,
+                        this.a_is_expected(),
+                        this.cause(),
+                        this.param_env(),
+                        this.define_opaque_types(),
+                    )?
                     .obligations,
             );
             Ok(a)
diff --git a/compiler/rustc_infer/src/infer/lub.rs b/compiler/rustc_infer/src/infer/lub.rs
@@ -2,8 +2,8 @@
 
 use super::combine::{CombineFields, ObligationEmittingRelation};
 use super::lattice::{self, LatticeDir};
-use super::InferCtxt;
 use super::Subtype;
+use super::{DefiningAnchor, InferCtxt};
 
 use crate::traits::{ObligationCause, PredicateObligations};
 use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
@@ -142,7 +142,7 @@ impl<'combine, 'infcx, 'tcx> LatticeDir<'infcx, 'tcx> for Lub<'combine, 'infcx,
         Ok(())
     }
 
-    fn define_opaque_types(&self) -> bool {
+    fn define_opaque_types(&self) -> DefiningAnchor {
         self.fields.define_opaque_types
     }
 }
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
@@ -726,7 +726,7 @@ impl<'tcx> InferCtxt<'tcx> {
         &'a self,
         trace: TypeTrace<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
-        define_opaque_types: bool,
+        define_opaque_types: DefiningAnchor,
     ) -> CombineFields<'a, 'tcx> {
         CombineFields {
             infcx: self,
diff --git a/compiler/rustc_infer/src/infer/nll_relate/mod.rs b/compiler/rustc_infer/src/infer/nll_relate/mod.rs
@@ -36,6 +36,7 @@ use std::fmt::Debug;
 use std::ops::ControlFlow;
 
 use super::combine::ObligationEmittingRelation;
+use super::DefiningAnchor;
 
 pub struct TypeRelating<'me, 'tcx, D>
 where
@@ -74,6 +75,7 @@ where
 
 pub trait TypeRelatingDelegate<'tcx> {
     fn param_env(&self) -> ty::ParamEnv<'tcx>;
+    fn defining_use_anchor(&self) -> DefiningAnchor;
     fn span(&self) -> Span;
 
     /// Push a constraint `sup: sub` -- this constraint must be
@@ -373,7 +375,14 @@ where
         let cause = ObligationCause::dummy_with_span(self.delegate.span());
         let obligations = self
             .infcx
-            .handle_opaque_type(a, b, true, &cause, self.delegate.param_env())?
+            .handle_opaque_type(
+                a,
+                b,
+                true,
+                &cause,
+                self.delegate.param_env(),
+                self.delegate.defining_use_anchor(),
+            )?
             .obligations;
         self.delegate.register_obligations(obligations);
         trace!(a = ?a.kind(), b = ?b.kind(), "opaque type instantiated");
diff --git a/compiler/rustc_infer/src/infer/opaque_types.rs b/compiler/rustc_infer/src/infer/opaque_types.rs
diff --git a/compiler/rustc_infer/src/infer/sub.rs b/compiler/rustc_infer/src/infer/sub.rs
diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs
diff --git a/compiler/rustc_trait_selection/src/traits/engine.rs b/compiler/rustc_trait_selection/src/traits/engine.rs
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs

Original file line number	Diff line number	Diff line change
`@@ -87,6 +87,10 @@ impl<'tcx> TypeRelatingDelegate<'tcx> for NllTypeRelatingDelegate<'_, '_, 'tcx>`
`87`	`87`	`self.locations.span(self.type_checker.body)`
`88`	`88`	`}`
`89`	`89`
	`90`	`+ fn defining_use_anchor(&self) -> rustc_infer::infer::DefiningAnchor {`
	`91`	`+ self.type_checker.infcx.defining_use_anchor`
	`92`	`+ }`
	`93`	`+`
`90`	`94`	`fn param_env(&self) -> ty::ParamEnv<'tcx> {`
`91`	`95`	`self.type_checker.param_env`
`92`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -738,7 +738,7 @@ 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).is_some() {`
	`741`	`+ && self.opaque_type_origin(def_id, self.defining_use_anchor).is_some() {`
`742`	`742`	`return None;`
`743`	`743`	`}`
`744`	`744`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,10 +36,7 @@ pub struct At<'a, 'tcx> {`
`36`	`36`	`pub param_env: ty::ParamEnv<'tcx>,`
`37`	`37`	`/// Whether we should define opaque types`
`38`	`38`	`/// or just treat them opaquely.`
`39`		`- /// Currently only used to prevent predicate`
`40`		`- /// matching from matching anything against opaque`
`41`		`- /// types.`
`42`		`- pub define_opaque_types: bool,`
	`39`	`+ pub define_opaque_types: DefiningAnchor,`
`43`	`40`	`}`
`44`	`41`
`45`	`42`	`pub struct Trace<'a, 'tcx> {`
`@@ -55,7 +52,7 @@ impl<'tcx> InferCtxt<'tcx> {`
`55`	`52`	`cause: &'a ObligationCause<'tcx>,`
`56`	`53`	`param_env: ty::ParamEnv<'tcx>,`
`57`	`54`	`) -> At<'a, 'tcx> {`
`58`		`- At { infcx: self, cause, param_env, define_opaque_types: false }`
	`55`	`+ At { infcx: self, cause, param_env, define_opaque_types: DefiningAnchor::Error }`
`59`	`56`	`}`
`60`	`57`
`61`	`58`	`/// Forks the inference context, creating a new inference context with the same inference`
`@@ -93,7 +90,7 @@ pub trait ToTrace<'tcx>: Relate<'tcx> + Copy {`
`93`	`90`	`}`
`94`	`91`
`95`	`92`	`impl<'a, 'tcx> At<'a, 'tcx> {`
`96`		`- pub fn define_opaque_types(self, define_opaque_types: bool) -> Self {`
	`93`	`+ pub fn define_opaque_types(self, define_opaque_types: DefiningAnchor) -> Self {`
`97`	`94`	`Self { define_opaque_types, ..self }`
`98`	`95`	`}`
`99`	`96`