move TypeOutlives normalization out of region checking

Author: JohnTitor

compiler/rustc_trait_selection/src/regions.rs

@@ -1,14 +1,105 @@
+use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def_id::LocalDefId;
 use rustc_infer::infer::outlives::env::OutlivesEnvironment;
-use rustc_infer::infer::{InferCtxt, RegionResolutionError};
+use rustc_infer::infer::{
+    InferCtxt, RegionResolutionError, SubregionOrigin, TypeOutlivesConstraint,
+};
 use rustc_macros::extension;
 use rustc_middle::traits::ObligationCause;
-use rustc_middle::traits::query::NoSolution;
 use rustc_middle::ty::{self, Ty, elaborate};
 
 use crate::traits::ScrubbedTraitError;
 use crate::traits::outlives_bounds::InferCtxtExt;
 
+fn normalize_higher_ranked_assumptions<'tcx>(
+    infcx: &InferCtxt<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+) -> FxHashSet<ty::ArgOutlivesPredicate<'tcx>> {
+    let assumptions = infcx.take_registered_region_assumptions();
+    if !infcx.next_trait_solver() {
+        return elaborate::elaborate_outlives_assumptions(infcx.tcx, assumptions);
+    }
+
+    let mut normalized_assumptions = vec![];
+    let mut seen_assumptions = FxHashSet::default();
+
+    for assumption in assumptions {
+        if !seen_assumptions.insert(assumption) {
+            continue;
+        }
+
+        let assumption = infcx.resolve_vars_if_possible(assumption);
+        let outlives = ty::Binder::dummy(assumption);
+        let ty::OutlivesPredicate(kind, region) =
+            match crate::solve::deeply_normalize::<_, ScrubbedTraitError<'tcx>>(
+                infcx.at(&ObligationCause::dummy(), param_env),
+                outlives,
+            ) {
+                Ok(assumption) => assumption,
+                Err(_) => {
+                    infcx.dcx().delayed_bug(format!(
+                        "could not normalize higher-ranked assumption `{assumption}`"
+                    ));
+                    outlives
+                }
+            }
+            .no_bound_vars()
+            .expect("started with no bound vars, should end with no bound vars");
+
+        normalized_assumptions.push(ty::OutlivesPredicate(kind, region));
+    }
+
+    for assumption in infcx.take_registered_region_assumptions() {
+        if seen_assumptions.insert(assumption) {
+            normalized_assumptions.push(assumption);
+        }
+    }
+
+    elaborate::elaborate_outlives_assumptions(infcx.tcx, normalized_assumptions)
+}
+
+fn normalize_registered_region_obligations<'tcx>(
+    infcx: &InferCtxt<'tcx>,
+    param_env: ty::ParamEnv<'tcx>,
+) -> Result<(), (ty::PolyTypeOutlivesPredicate<'tcx>, SubregionOrigin<'tcx>)> {
+    if !infcx.next_trait_solver() {
+        return Ok(());
+    }
+
+    let obligations = infcx.take_registered_region_obligations();
+    let mut seen_outputs = FxHashSet::default();
+    let mut normalized_obligations = vec![];
+
+    for TypeOutlivesConstraint { sup_type, sub_region, origin } in obligations {
+        let outlives = infcx.resolve_vars_if_possible(ty::Binder::dummy(ty::OutlivesPredicate(
+            sup_type, sub_region,
+        )));
+        let ty::OutlivesPredicate(sup_type, sub_region) = crate::solve::deeply_normalize(
+            infcx.at(&ObligationCause::dummy_with_span(origin.span()), param_env),
+            outlives,
+        )
+        .map_err(|_: Vec<ScrubbedTraitError<'tcx>>| (outlives, origin.clone()))?
+        .no_bound_vars()
+        .expect("started with no bound vars, should end with no bound vars");
+
+        if seen_outputs.insert((sup_type, sub_region)) {
+            normalized_obligations.push(TypeOutlivesConstraint { sup_type, sub_region, origin });
+        }
+    }
+
+    for obligation in infcx.take_registered_region_obligations() {
+        if seen_outputs.insert((obligation.sup_type, obligation.sub_region)) {
+            normalized_obligations.push(obligation);
+        }
+    }
+
+    for obligation in normalized_obligations {
+        infcx.register_type_outlives_constraint_inner(obligation);
+    }
+
+    Ok(())
+}
+
 #[extension(pub trait OutlivesEnvironmentBuildExt<'tcx>)]
 impl<'tcx> OutlivesEnvironment<'tcx> {
     fn new(
@@ -46,10 +137,7 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
             }
         }
 
-        // FIXME(-Znext-trait-solver): Normalize these.
-        let higher_ranked_assumptions = infcx.take_registered_region_assumptions();
-        let higher_ranked_assumptions =
-            elaborate::elaborate_outlives_assumptions(infcx.tcx, higher_ranked_assumptions);
+        let higher_ranked_assumptions = normalize_higher_ranked_assumptions(infcx, param_env);
 
         // FIXME: This needs to be modified so that we normalize the known type
         // outlives obligations then elaborate them into their region/type components.
@@ -98,21 +186,14 @@ impl<'tcx> InferCtxt<'tcx> {
         &self,
         outlives_env: &OutlivesEnvironment<'tcx>,
     ) -> Vec<RegionResolutionError<'tcx>> {
-        self.resolve_regions_with_normalize(&outlives_env, |ty, origin| {
-            let ty = self.resolve_vars_if_possible(ty);
-
-            if self.next_trait_solver() {
-                crate::solve::deeply_normalize(
-                    self.at(
-                        &ObligationCause::dummy_with_span(origin.span()),
-                        outlives_env.param_env,
-                    ),
-                    ty,
-                )
-                .map_err(|_: Vec<ScrubbedTraitError<'tcx>>| NoSolution)
-            } else {
-                Ok(ty)
-            }
+        if let Err((outlives, origin)) =
+            normalize_registered_region_obligations(self, outlives_env.param_env)
+        {
+            return vec![RegionResolutionError::CannotNormalize(outlives, origin)];
+        }
+
+        self.resolve_regions_with_normalize(outlives_env, |outlives, _| {
+            Ok(self.resolve_vars_if_possible(outlives))
         })
     }
 }

tests/ui/traits/next-solver/undeclared-lifetime-no-ice-issue-151461.rs

@@ -0,0 +1,15 @@
+//@ compile-flags: -Znext-solver=globally
+
+trait X<'a> {
+    type U: ?Sized;
+}
+
+impl X<'_> for u32
+where
+    for<'b> <Self as X<'b>>::U: 'a,
+    //~^ ERROR use of undeclared lifetime name `'a`
+{
+    type U = str;
+}
+
+fn main() {}

tests/ui/traits/next-solver/undeclared-lifetime-no-ice-issue-151461.stderr

@@ -0,0 +1,19 @@
+error[E0261]: use of undeclared lifetime name `'a`
+  --> $DIR/undeclared-lifetime-no-ice-issue-151461.rs:9:33
+   |
+LL |     for<'b> <Self as X<'b>>::U: 'a,
+   |                                 ^^ undeclared lifetime
+   |
+   = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
+help: consider making the bound lifetime-generic with a new `'a` lifetime
+   |
+LL |     for<'a, 'b> <Self as X<'b>>::U: 'a,
+   |         +++
+help: consider introducing lifetime `'a` here
+   |
+LL | impl<'a> X<'_> for u32
+   |     ++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0261`.