Canonicalize v2 of implied_bounds query too

Author: jackh726

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -128,7 +128,7 @@ where
     let infcx_compat = infcx.fork();
 
     debug!(?assumed_wf_types);
-    let implied_bounds = infcx.implied_bounds_tys(param_env, &assumed_wf_types);
+    let implied_bounds = infcx.implied_bounds_tys(param_env, body_def_id, &assumed_wf_types);
     let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
 
     let errors = infcx.resolve_regions(&outlives_env);

compiler/rustc_middle/src/arena.rs

@@ -53,7 +53,7 @@ macro_rules! arena_types {
                         rustc_middle::traits::query::NormalizationResult<'tcx>
                     >
                 >,
-            [] implied_outlives_bounds_compat:
+            [] implied_outlives_bounds:
                 rustc_middle::infer::canonical::Canonical<'tcx,
                     rustc_middle::infer::canonical::QueryResponse<'tcx,
                         Vec<rustc_middle::traits::query::OutlivesBound<'tcx>>

compiler/rustc_middle/src/query/mod.rs

@@ -1963,12 +1963,12 @@ rustc_queries! {
     }
 
     query implied_outlives_bounds(
-        goal: ty::ParamEnvAnd<'tcx, Ty<'tcx>>
+        goal: CanonicalTyGoal<'tcx>
     ) -> Result<
-        &'tcx [OutlivesBound<'tcx>],
+        &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, Vec<OutlivesBound<'tcx>>>>,
         NoSolution,
     > {
-        desc { "computing implied outlives bounds v2 for `{}`", goal.value }
+        desc { "computing implied outlives bounds v2 for `{}`", goal.value.value }
     }
 
     /// Do not call this query directly:

compiler/rustc_trait_selection/src/traits/outlives_bounds.rs

@@ -12,13 +12,6 @@ pub use rustc_middle::traits::query::OutlivesBound;
 pub type BoundsCompat<'a, 'tcx: 'a> = impl Iterator<Item = OutlivesBound<'tcx>> + 'a;
 pub type Bounds<'a, 'tcx: 'a> = impl Iterator<Item = OutlivesBound<'tcx>> + 'a;
 pub trait InferCtxtExt<'a, 'tcx> {
-    fn implied_outlives_bounds_compat(
-        &self,
-        param_env: ty::ParamEnv<'tcx>,
-        body_id: LocalDefId,
-        ty: Ty<'tcx>,
-    ) -> Vec<OutlivesBound<'tcx>>;
-
     fn implied_bounds_tys_compat(
         &'a self,
         param_env: ty::ParamEnv<'tcx>,
@@ -29,130 +22,127 @@ pub trait InferCtxtExt<'a, 'tcx> {
     fn implied_bounds_tys(
         &'a self,
         param_env: ty::ParamEnv<'tcx>,
+        body_id: LocalDefId,
         tys: &'a FxIndexSet<Ty<'tcx>>,
     ) -> Bounds<'a, 'tcx>;
 }
 
-impl<'a, 'tcx: 'a> InferCtxtExt<'a, 'tcx> for InferCtxt<'tcx> {
-    /// Implied bounds are region relationships that we deduce
-    /// automatically. The idea is that (e.g.) a caller must check that a
-    /// function's argument types are well-formed immediately before
-    /// calling that fn, and hence the *callee* can assume that its
-    /// argument types are well-formed. This may imply certain relationships
-    /// between generic parameters. For example:
-    /// ```
-    /// fn foo<T>(x: &T) {}
-    /// ```
-    /// can only be called with a `'a` and `T` such that `&'a T` is WF.
-    /// For `&'a T` to be WF, `T: 'a` must hold. So we can assume `T: 'a`.
-    ///
-    /// # Parameters
-    ///
-    /// - `param_env`, the where-clauses in scope
-    /// - `body_id`, the body-id to use when normalizing assoc types.
-    ///   Note that this may cause outlives obligations to be injected
-    ///   into the inference context with this body-id.
-    /// - `ty`, the type that we are supposed to assume is WF.
-    #[instrument(level = "debug", skip(self, param_env, body_id), ret)]
-    fn implied_outlives_bounds_compat(
-        &self,
-        param_env: ty::ParamEnv<'tcx>,
-        body_id: LocalDefId,
-        ty: Ty<'tcx>,
-    ) -> Vec<OutlivesBound<'tcx>> {
-        let ty = self.resolve_vars_if_possible(ty);
-        let ty = OpportunisticRegionResolver::new(self).fold_ty(ty);
-
-        // We do not expect existential variables in implied bounds.
-        // We may however encounter unconstrained lifetime variables
-        // in very rare cases.
-        //
-        // See `ui/implied-bounds/implied-bounds-unconstrained-2.rs` for
-        // an example.
-        assert!(!ty.has_non_region_infer());
-
-        let mut canonical_var_values = OriginalQueryValues::default();
-        let canonical_ty =
-            self.canonicalize_query_keep_static(param_env.and(ty), &mut canonical_var_values);
-        let Ok(canonical_result) = self.tcx.implied_outlives_bounds_compat(canonical_ty) else {
-            return vec![];
-        };
-
-        let mut constraints = QueryRegionConstraints::default();
-        let Ok(InferOk { value: mut bounds, obligations }) = self
-            .instantiate_nll_query_response_and_region_obligations(
-                &ObligationCause::dummy(),
+/// Implied bounds are region relationships that we deduce
+/// automatically. The idea is that (e.g.) a caller must check that a
+/// function's argument types are well-formed immediately before
+/// calling that fn, and hence the *callee* can assume that its
+/// argument types are well-formed. This may imply certain relationships
+/// between generic parameters. For example:
+/// ```
+/// fn foo<T>(x: &T) {}
+/// ```
+/// can only be called with a `'a` and `T` such that `&'a T` is WF.
+/// For `&'a T` to be WF, `T: 'a` must hold. So we can assume `T: 'a`.
+///
+/// # Parameters
+///
+/// - `param_env`, the where-clauses in scope
+/// - `body_id`, the body-id to use when normalizing assoc types.
+///   Note that this may cause outlives obligations to be injected
+///   into the inference context with this body-id.
+/// - `ty`, the type that we are supposed to assume is WF.
+#[instrument(level = "debug", skip(infcx, param_env, body_id), ret)]
+fn implied_outlives_bounds<'a, 'tcx>(
+    infcx: &'a InferCtxt<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+    body_id: LocalDefId,
+    ty: Ty<'tcx>,
+    compat: bool,
+) -> Vec<OutlivesBound<'tcx>> {
+    let ty = infcx.resolve_vars_if_possible(ty);
+    let ty = OpportunisticRegionResolver::new(infcx).fold_ty(ty);
+
+    // We do not expect existential variables in implied bounds.
+    // We may however encounter unconstrained lifetime variables
+    // in very rare cases.
+    //
+    // See `ui/implied-bounds/implied-bounds-unconstrained-2.rs` for
+    // an example.
+    assert!(!ty.has_non_region_infer());
+
+    let mut canonical_var_values = OriginalQueryValues::default();
+    let canonical_ty =
+        infcx.canonicalize_query_keep_static(param_env.and(ty), &mut canonical_var_values);
+    let implied_bounds_result = if compat {
+        infcx.tcx.implied_outlives_bounds_compat(canonical_ty)
+    } else {
+        infcx.tcx.implied_outlives_bounds(canonical_ty)
+    };
+    let Ok(canonical_result) = implied_bounds_result else {
+        return vec![];
+    };
+
+    let mut constraints = QueryRegionConstraints::default();
+    let Ok(InferOk { value: mut bounds, obligations }) = infcx
+        .instantiate_nll_query_response_and_region_obligations(
+            &ObligationCause::dummy(),
+            param_env,
+            &canonical_var_values,
+            canonical_result,
+            &mut constraints,
+        )
+    else {
+        return vec![];
+    };
+    assert_eq!(&obligations, &[]);
+
+    // Because of #109628, we may have unexpected placeholders. Ignore them!
+    // FIXME(#109628): panic in this case once the issue is fixed.
+    bounds.retain(|bound| !bound.has_placeholders());
+
+    if !constraints.is_empty() {
+        let span = infcx.tcx.def_span(body_id);
+
+        debug!(?constraints);
+        if !constraints.member_constraints.is_empty() {
+            span_bug!(span, "{:#?}", constraints.member_constraints);
+        }
+
+        // Instantiation may have produced new inference variables and constraints on those
+        // variables. Process these constraints.
+        let ocx = ObligationCtxt::new(infcx);
+        let cause = ObligationCause::misc(span, body_id);
+        for &constraint in &constraints.outlives {
+            ocx.register_obligation(infcx.query_outlives_constraint_to_obligation(
+                constraint,
+                cause.clone(),
                 param_env,
-                &canonical_var_values,
-                canonical_result,
-                &mut constraints,
-            )
-        else {
-            return vec![];
-        };
-        assert_eq!(&obligations, &[]);
-
-        // Because of #109628, we may have unexpected placeholders. Ignore them!
-        // FIXME(#109628): panic in this case once the issue is fixed.
-        bounds.retain(|bound| !bound.has_placeholders());
-
-        if !constraints.is_empty() {
-            let span = self.tcx.def_span(body_id);
-
-            debug!(?constraints);
-            if !constraints.member_constraints.is_empty() {
-                span_bug!(span, "{:#?}", constraints.member_constraints);
-            }
-
-            // Instantiation may have produced new inference variables and constraints on those
-            // variables. Process these constraints.
-            let ocx = ObligationCtxt::new(self);
-            let cause = ObligationCause::misc(span, body_id);
-            for &constraint in &constraints.outlives {
-                ocx.register_obligation(self.query_outlives_constraint_to_obligation(
-                    constraint,
-                    cause.clone(),
-                    param_env,
-                ));
-            }
-
-            let errors = ocx.select_all_or_error();
-            if !errors.is_empty() {
-                self.tcx.sess.span_delayed_bug(
-                    span,
-                    "implied_outlives_bounds_compat failed to solve obligations from instantiation",
-                );
-            }
-        };
-
-        bounds
-    }
+            ));
+        }
+
+        let errors = ocx.select_all_or_error();
+        if !errors.is_empty() {
+            infcx.tcx.sess.span_delayed_bug(
+                span,
+                "implied_outlives_bounds_compat failed to solve obligations from instantiation",
+            );
+        }
+    };
+
+    bounds
+}
 
+impl<'a, 'tcx: 'a> InferCtxtExt<'a, 'tcx> for InferCtxt<'tcx> {
     fn implied_bounds_tys_compat(
         &'a self,
         param_env: ParamEnv<'tcx>,
         body_id: LocalDefId,
         tys: &'a FxIndexSet<Ty<'tcx>>,
     ) -> BoundsCompat<'a, 'tcx> {
-        tys.iter().flat_map(move |ty| self.implied_outlives_bounds_compat(param_env, body_id, *ty))
+        tys.iter().flat_map(move |ty| implied_outlives_bounds(self, param_env, body_id, *ty, true))
     }
 
     fn implied_bounds_tys(
         &'a self,
         param_env: ParamEnv<'tcx>,
+        body_id: LocalDefId,
         tys: &'a FxIndexSet<Ty<'tcx>>,
     ) -> Bounds<'a, 'tcx> {
-        tys.iter()
-            .flat_map(move |&ty| {
-                let ty = self.resolve_vars_if_possible(ty);
-                let ty = OpportunisticRegionResolver::new(self).fold_ty(ty);
-
-                if ty.has_infer() {
-                    return &[] as &[OutlivesBound<'_>];
-                }
-
-                self.tcx.implied_outlives_bounds(param_env.and(ty)).unwrap_or(&[])
-            })
-            .copied()
+        tys.iter().flat_map(move |ty| implied_outlives_bounds(self, param_env, body_id, *ty, false))
     }
 }

compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs

@@ -66,15 +66,14 @@ pub fn compute_implied_outlives_bounds_inner<'tcx>(
     ocx: &ObligationCtxt<'_, 'tcx>,
     param_env: ty::ParamEnv<'tcx>,
     ty: Ty<'tcx>,
-) -> Result<&'tcx [OutlivesBound<'tcx>], NoSolution> {
+) -> Result<Vec<OutlivesBound<'tcx>>, NoSolution> {
     let normalize_op = |ty| {
         let ty = ocx.normalize(&ObligationCause::dummy(), param_env, ty);
         if !ocx.select_all_or_error().is_empty() {
             return Err(NoSolution);
         }
         let ty = ocx.infcx.resolve_vars_if_possible(ty);
         let ty = OpportunisticRegionResolver::new(&ocx.infcx).fold_ty(ty);
-        assert!(!ty.has_infer());
         Ok(ty)
     };
 
@@ -139,7 +138,7 @@ pub fn compute_implied_outlives_bounds_inner<'tcx>(
         }
     }
 
-    Ok(ocx.infcx.tcx.arena.alloc_slice(&outlives_bounds))
+    Ok(outlives_bounds)
 }
 
 pub fn compute_implied_outlives_bounds_compat_inner<'tcx>(

compiler/rustc_traits/src/implied_outlives_bounds.rs

@@ -6,13 +6,12 @@ use rustc_infer::infer::canonical::{self, Canonical};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::query::OutlivesBound;
 use rustc_middle::query::Providers;
-use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_middle::ty::TyCtxt;
 use rustc_trait_selection::infer::InferCtxtBuilderExt;
 use rustc_trait_selection::traits::query::type_op::implied_outlives_bounds::{
     compute_implied_outlives_bounds_compat_inner, compute_implied_outlives_bounds_inner,
 };
 use rustc_trait_selection::traits::query::{CanonicalTyGoal, NoSolution};
-use rustc_trait_selection::traits::ObligationCtxt;
 
 pub(crate) fn provide(p: &mut Providers) {
     *p = Providers { implied_outlives_bounds_compat, ..*p };
@@ -34,10 +33,13 @@ fn implied_outlives_bounds_compat<'tcx>(
 
 fn implied_outlives_bounds<'tcx>(
     tcx: TyCtxt<'tcx>,
-    goal: ty::ParamEnvAnd<'tcx, Ty<'tcx>>,
-) -> Result<&'tcx [OutlivesBound<'tcx>], NoSolution> {
-    let (param_env, goal_ty) = goal.into_parts();
-    let infcx = tcx.infer_ctxt().build();
-    let ocx = ObligationCtxt::new(&infcx);
-    compute_implied_outlives_bounds_inner(&ocx, param_env, goal_ty)
+    goal: CanonicalTyGoal<'tcx>,
+) -> Result<
+    &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, Vec<OutlivesBound<'tcx>>>>,
+    NoSolution,
+> {
+    tcx.infer_ctxt().enter_canonical_trait_query(&goal, |ocx, key| {
+        let (param_env, ty) = key.into_parts();
+        compute_implied_outlives_bounds_inner(&ocx, param_env, ty)
+    })
 }

tests/ui/implied-bounds/gluon_salsa.rs

@@ -0,0 +1,29 @@
+// check-pass
+
+pub trait QueryBase {
+    type Db;
+}
+
+pub trait AsyncQueryFunction<'f>: // 'f is important
+    QueryBase<Db = <Self as AsyncQueryFunction<'f>>::SendDb> // bound is important
+{
+    type SendDb;
+}
+
+pub struct QueryTable<'me, Q, DB> {
+    _q: Option<Q>,
+    _db: Option<DB>,
+    _marker: Option<&'me ()>,
+}
+
+impl<'me, Q> QueryTable<'me, Q, <Q as QueryBase>::Db> // projection is important
+//   ^^^ removing 'me (and in QueryTable) gives a different error
+where
+    Q: for<'f> AsyncQueryFunction<'f>,
+{
+    pub fn get_async<'a>(&'a mut self) {
+        panic!();
+    }
+}
+
+fn main() {}