Normalize known type outlives within creation of OutlivesEnvironment

compiler-errors · compiler-errors · commit 8f63b793fa56 · 2025-01-25T05:35:34.000Z
diff --git a/compiler/rustc_infer/src/infer/outlives/env.rs b/compiler/rustc_infer/src/infer/outlives/env.rs
@@ -1,12 +1,9 @@
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_data_structures::transitive_relation::TransitiveRelationBuilder;
 use rustc_middle::{bug, ty};
-use tracing::debug;
 
-use super::explicit_outlives_bounds;
 use crate::infer::GenericKind;
 use crate::infer::free_regions::FreeRegionMap;
-use crate::traits::query::OutlivesBound;
 
 /// The `OutlivesEnvironment` collects information about what outlives
 /// what in a given type-checking setting. For example, if we have a
@@ -31,26 +28,7 @@ use crate::traits::query::OutlivesBound;
 pub struct OutlivesEnvironment<'tcx> {
     pub param_env: ty::ParamEnv<'tcx>,
     free_region_map: FreeRegionMap<'tcx>,
-
-    // Contains the implied region bounds in scope for our current body.
-    //
-    // Example:
-    //
-    // ```
-    // fn foo<'a, 'b, T>(x: &'a T, y: &'b ()) {
-    //   bar(x, y, |y: &'b T| { .. } // body B1)
-    // } // body B0
-    // ```
-    //
-    // Here, when checking the body B0, the list would be `[T: 'a]`, because we
-    // infer that `T` must outlive `'a` from the implied bounds on the
-    // fn declaration.
-    //
-    // For the body B1 however, the list would be `[T: 'a, T: 'b]`, because we
-    // also can see that -- within the closure body! -- `T` must
-    // outlive `'b`. This is not necessarily true outside the closure
-    // body, since the closure may never be called.
-    region_bound_pairs: RegionBoundPairs<'tcx>,
+    known_type_outlives: Vec<ty::PolyTypeOutlivesPredicate<'tcx>>,
 }
 
 /// "Region-bound pairs" tracks outlives relations that are known to
@@ -59,45 +37,54 @@ pub struct OutlivesEnvironment<'tcx> {
 pub type RegionBoundPairs<'tcx> = FxIndexSet<ty::OutlivesPredicate<'tcx, GenericKind<'tcx>>>;
 
 impl<'tcx> OutlivesEnvironment<'tcx> {
-    /// Create a new `OutlivesEnvironment` with extra outlives bounds.
-    pub fn with_bounds(
+    /// Create a new `OutlivesEnvironment` from normalized outlives bounds.
+    pub fn from_normalized_bounds(
         param_env: ty::ParamEnv<'tcx>,
-        extra_bounds: impl IntoIterator<Item = OutlivesBound<'tcx>>,
+        bounds: impl IntoIterator<
+            Item = ty::Binder<'tcx, ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>>,
+        >,
     ) -> Self {
+        let mut known_type_outlives = vec![];
         let mut region_relation = TransitiveRelationBuilder::default();
-        let mut region_bound_pairs = RegionBoundPairs::default();
 
         // Record relationships such as `T:'x` that don't go into the
         // free-region-map but which we use here.
-        for outlives_bound in explicit_outlives_bounds(param_env).chain(extra_bounds) {
-            debug!("add_outlives_bounds: outlives_bound={:?}", outlives_bound);
-            match outlives_bound {
-                OutlivesBound::RegionSubParam(r_a, param_b) => {
-                    region_bound_pairs
-                        .insert(ty::OutlivesPredicate(GenericKind::Param(param_b), r_a));
+        for bound in bounds {
+            let ty::OutlivesPredicate(arg_b, r_a) = bound.skip_binder();
+            match arg_b.unpack() {
+                ty::GenericArgKind::Lifetime(r_b) => {
+                    match (*r_a, *r_b) {
+                        (
+                            ty::ReStatic | ty::ReEarlyParam(_) | ty::ReLateParam(_),
+                            ty::ReStatic | ty::ReEarlyParam(_) | ty::ReLateParam(_),
+                        ) => region_relation.add(r_a, r_b),
+                        // Do nothing for higher-ranked region predicates.
+                        (
+                            ty::ReBound(..),
+                            ty::ReStatic | ty::ReEarlyParam(_) | ty::ReLateParam(_),
+                        )
+                        | (
+                            ty::ReStatic | ty::ReEarlyParam(_) | ty::ReLateParam(_),
+                            ty::ReBound(..),
+                        ) => {}
+                        (ty::ReError(_), _) | (_, ty::ReError(_)) => {}
+                        // FIXME(#109628): We shouldn't have existential variables in implied bounds.
+                        // Panic here once the linked issue is resolved!
+                        (ty::ReVar(_), _) | (_, ty::ReVar(_)) => {}
+                        _ => bug!("add_outlives_bounds: unexpected regions: ({r_a:?}, {r_b:?})"),
+                    }
                 }
-                OutlivesBound::RegionSubAlias(r_a, alias_b) => {
-                    region_bound_pairs
-                        .insert(ty::OutlivesPredicate(GenericKind::Alias(alias_b), r_a));
+                ty::GenericArgKind::Type(ty_b) => {
+                    known_type_outlives.push(bound.rebind(ty::OutlivesPredicate(ty_b, r_a)));
                 }
-                OutlivesBound::RegionSubRegion(r_a, r_b) => match (*r_a, *r_b) {
-                    (
-                        ty::ReStatic | ty::ReEarlyParam(_) | ty::ReLateParam(_),
-                        ty::ReStatic | ty::ReEarlyParam(_) | ty::ReLateParam(_),
-                    ) => region_relation.add(r_a, r_b),
-                    (ty::ReError(_), _) | (_, ty::ReError(_)) => {}
-                    // FIXME(#109628): We shouldn't have existential variables in implied bounds.
-                    // Panic here once the linked issue is resolved!
-                    (ty::ReVar(_), _) | (_, ty::ReVar(_)) => {}
-                    _ => bug!("add_outlives_bounds: unexpected regions: ({r_a:?}, {r_b:?})"),
-                },
+                ty::GenericArgKind::Const(_) => unreachable!(),
             }
         }
 
         OutlivesEnvironment {
             param_env,
+            known_type_outlives,
             free_region_map: FreeRegionMap { relation: region_relation.freeze() },
-            region_bound_pairs,
         }
     }
 
@@ -107,7 +94,7 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
     }
 
     /// Borrows current `region_bound_pairs`.
-    pub fn region_bound_pairs(&self) -> &RegionBoundPairs<'tcx> {
-        &self.region_bound_pairs
+    pub fn known_type_outlives(&self) -> &[ty::PolyTypeOutlivesPredicate<'tcx>] {
+        &self.known_type_outlives
     }
 }
diff --git a/compiler/rustc_infer/src/infer/outlives/obligations.rs b/compiler/rustc_infer/src/infer/outlives/obligations.rs
@@ -67,7 +67,6 @@ use rustc_middle::ty::{
     self, GenericArgKind, GenericArgsRef, PolyTypeOutlivesPredicate, Region, Ty, TyCtxt,
     TypeFoldable as _, TypeVisitableExt,
 };
-use rustc_span::DUMMY_SP;
 use rustc_type_ir::outlives::{Component, push_outlives_components};
 use smallvec::smallvec;
 use tracing::{debug, instrument};
@@ -142,25 +141,6 @@ impl<'tcx> InferCtxt<'tcx> {
     ) -> Result<(), (PolyTypeOutlivesPredicate<'tcx>, SubregionOrigin<'tcx>)> {
         assert!(!self.in_snapshot(), "cannot process registered region obligations in a snapshot");
 
-        let normalized_caller_bounds: Vec<_> = outlives_env
-            .param_env
-            .caller_bounds()
-            .iter()
-            .filter_map(|clause| {
-                let outlives = clause.as_type_outlives_clause()?;
-                Some(
-                    deeply_normalize_ty(
-                        outlives,
-                        SubregionOrigin::AscribeUserTypeProvePredicate(DUMMY_SP),
-                    )
-                    // FIXME(-Znext-solver): How do we accurately report an error span here :(
-                    .map_err(|NoSolution| {
-                        (outlives, SubregionOrigin::AscribeUserTypeProvePredicate(DUMMY_SP))
-                    }),
-                )
-            })
-            .try_collect()?;
-
         // Must loop since the process of normalizing may itself register region obligations.
         for iteration in 0.. {
             let my_region_obligations = self.take_registered_region_obligations();
@@ -189,12 +169,14 @@ impl<'tcx> InferCtxt<'tcx> {
 
                 debug!(?sup_type, ?sub_region, ?origin);
 
+                let region_bound_pairs = &Default::default();
                 let outlives = &mut TypeOutlives::new(
                     self,
                     self.tcx,
-                    outlives_env.region_bound_pairs(),
+                    // TODO:
+                    region_bound_pairs,
                     None,
-                    &normalized_caller_bounds,
+                    outlives_env.known_type_outlives(),
                 );
                 let category = origin.to_constraint_category();
                 outlives.type_must_outlive(origin, sup_type, sub_region, category);
diff --git a/compiler/rustc_trait_selection/src/regions.rs b/compiler/rustc_trait_selection/src/regions.rs
@@ -1,6 +1,7 @@
 use rustc_hir::def_id::LocalDefId;
 use rustc_infer::infer::outlives::env::OutlivesEnvironment;
 use rustc_infer::infer::{InferCtxt, RegionResolutionError};
+use rustc_infer::traits::query::OutlivesBound;
 use rustc_macros::extension;
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::traits::query::NoSolution;
@@ -33,19 +34,57 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
         assumed_wf_tys: impl IntoIterator<Item = Ty<'tcx>>,
         implied_bounds_compat: bool,
     ) -> Self {
+        let mut bounds = vec![];
+
+        for bound in param_env.caller_bounds() {
+            if let Some(region_outlives) = bound.as_region_outlives_clause() {
+                bounds.push(region_outlives.map_bound(|o| ty::OutlivesPredicate(o.0.into(), o.1)));
+            } else if let Some(mut type_outlives) = bound.as_type_outlives_clause() {
+                if infcx.next_trait_solver() {
+                    match crate::solve::deeply_normalize::<_, ScrubbedTraitError<'tcx>>(
+                        infcx.at(&ObligationCause::dummy(), param_env),
+                        type_outlives,
+                    ) {
+                        Ok(new) => type_outlives = new,
+                        Err(_) => {
+                            infcx.dcx().delayed_bug(format!("could not normalize `{bound}`"));
+                        }
+                    }
+                }
+                bounds.push(type_outlives.map_bound(|o| ty::OutlivesPredicate(o.0.into(), o.1)));
+            }
+        }
+
+        for bound in infcx.implied_bounds_tys_with_compat(
+            body_id,
+            param_env,
+            assumed_wf_tys,
+            implied_bounds_compat,
+        ) {
+            match bound {
+                OutlivesBound::RegionSubRegion(r_a, r_b) => {
+                    bounds.push(ty::Binder::dummy(ty::OutlivesPredicate(r_b.into(), r_a)));
+                }
+                OutlivesBound::RegionSubParam(r_a, param) => {
+                    bounds.push(ty::Binder::dummy(ty::OutlivesPredicate(
+                        Ty::new_param(infcx.tcx, param.index, param.name).into(),
+                        r_a,
+                    )));
+                }
+                OutlivesBound::RegionSubAlias(r_a, alias) => {
+                    bounds.push(ty::Binder::dummy(ty::OutlivesPredicate(
+                        Ty::new_alias(infcx.tcx, alias.kind(infcx.tcx), alias).into(),
+                        r_a,
+                    )));
+                }
+            }
+        }
+
         // FIXME: This needs to be modified so that we normalize the known type
         // outlives obligations then elaborate them into their region/type components.
         // Otherwise, `<W<'a> as Mirror>::Assoc: 'b` will not imply `'a: 'b` even
         // if we can normalize `'a`.
-        OutlivesEnvironment::with_bounds(
-            param_env,
-            infcx.implied_bounds_tys_with_compat(
-                body_id,
-                param_env,
-                assumed_wf_tys,
-                implied_bounds_compat,
-            ),
-        )
+        OutlivesEnvironment::from_normalized_bounds(param_env, bounds)
     }
 }
 
