Auto merge of #159649 - adwinwhite:norm-before-regionck, r=<try>

Normalize region obligations before regionck

Author: bors

compiler/rustc_borrowck/src/type_check/constraint_conversion.rs

@@ -5,14 +5,11 @@ use rustc_infer::infer::canonical::{QueryRegionConstraint, QueryRegionConstraint
 use rustc_infer::infer::outlives::env::RegionBoundPairs;
 use rustc_infer::infer::outlives::obligations::{TypeOutlives, TypeOutlivesDelegate};
 use rustc_infer::infer::region_constraints::{GenericKind, VerifyBound};
-use rustc_infer::traits::query::type_op::Normalize;
-use rustc_middle::bug;
 use rustc_middle::ty::{
-    self, GenericArgKind, RegionExt, RegionUtilitiesExt, Ty, TyCtxt, TypeFoldable,
-    TypeVisitableExt, elaborate, fold_regions,
+    self, GenericArgKind, RegionExt, RegionUtilitiesExt, TyCtxt, TypeFoldable, TypeVisitableExt,
+    elaborate, fold_regions,
 };
 use rustc_span::Span;
-use rustc_trait_selection::traits::query::type_op::TypeOpOutput;
 use tracing::{debug, instrument};
 
 use crate::constraints::OutlivesConstraint;
@@ -137,83 +134,49 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
 
         // Extract out various useful fields we'll need below.
         let ConstraintConversion {
-            infcx,
+            infcx: _,
             universal_regions,
             region_bound_pairs,
             known_type_outlives_obligations,
             ..
         } = *self;
 
-        let mut outlives_predicates = vec![(predicate, constraint_category)];
-        for iteration in 0.. {
-            if outlives_predicates.is_empty() {
-                break;
-            }
+        let pred = predicate;
+        // Constraint is implied by a coroutine's well-formedness.
+        if self.infcx.tcx.sess.opts.unstable_opts.higher_ranked_assumptions
+            && higher_ranked_assumptions.contains(&pred)
+        {
+            return;
+        }
 
-            if !tcx.recursion_limit().value_within_limit(iteration) {
-                // This may actually be reachable. If so, we should convert
-                // this to a proper error/consider whether we should detect
-                // this somewhere else.
-                bug!(
-                    "unexpected overflowed when processing region obligations: {outlives_predicates:#?}"
-                );
+        let ty::OutlivesPredicate(k1, r2) = pred;
+        match k1.kind() {
+            GenericArgKind::Lifetime(r1) => {
+                let r1_vid = self.to_region_vid(r1);
+                let r2_vid = self.to_region_vid(r2);
+                self.add_outlives(r1_vid, r2_vid, constraint_category);
             }
 
-            let mut next_outlives_predicates = vec![];
-            for (pred, constraint_category) in outlives_predicates {
-                // Constraint is implied by a coroutine's well-formedness.
-                if self.infcx.tcx.sess.opts.unstable_opts.higher_ranked_assumptions
-                    && higher_ranked_assumptions.contains(&pred)
-                {
-                    continue;
-                }
-
-                let ty::OutlivesPredicate(k1, r2) = pred;
-                match k1.kind() {
-                    GenericArgKind::Lifetime(r1) => {
-                        let r1_vid = self.to_region_vid(r1);
-                        let r2_vid = self.to_region_vid(r2);
-                        self.add_outlives(r1_vid, r2_vid, constraint_category);
-                    }
-
-                    GenericArgKind::Type(mut t1) => {
-                        // Scraped constraints may have had inference vars.
-                        t1 = self.infcx.resolve_vars_if_possible(t1);
-
-                        // Normalize the type we receive from a `TypeOutlives` obligation
-                        // in the new trait solver.
-                        if infcx.next_trait_solver() {
-                            t1 = self.normalize_and_add_type_outlives_constraints(
-                                ty::Unnormalized::new_wip(t1),
-                                &mut next_outlives_predicates,
-                            );
-                        }
+            GenericArgKind::Type(mut t1) => {
+                // Scraped constraints may have had inference vars.
+                t1 = self.infcx.resolve_vars_if_possible(t1);
 
-                        let implicit_region_bound =
-                            ty::Region::new_var(tcx, universal_regions.implicit_region_bound());
-                        // we don't actually use this for anything, but
-                        // the `TypeOutlives` code needs an origin.
-                        let origin = SubregionOrigin::RelateParamBound(self.span, t1, None);
-                        TypeOutlives::new(
-                            &mut *self,
-                            tcx,
-                            region_bound_pairs,
-                            Some(implicit_region_bound),
-                            known_type_outlives_obligations,
-                        )
-                        .type_must_outlive(
-                            origin,
-                            t1,
-                            r2,
-                            constraint_category,
-                        );
-                    }
-
-                    GenericArgKind::Const(_) => unreachable!(),
-                }
+                let implicit_region_bound =
+                    ty::Region::new_var(tcx, universal_regions.implicit_region_bound());
+                // we don't actually use this for anything, but
+                // the `TypeOutlives` code needs an origin.
+                let origin = SubregionOrigin::RelateParamBound(self.span, t1, None);
+                TypeOutlives::new(
+                    &mut *self,
+                    tcx,
+                    region_bound_pairs,
+                    Some(implicit_region_bound),
+                    known_type_outlives_obligations,
+                )
+                .type_must_outlive(origin, t1, r2, constraint_category);
             }
 
-            outlives_predicates = next_outlives_predicates;
+            GenericArgKind::Const(_) => unreachable!(),
         }
     }
 
@@ -279,32 +242,6 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
         debug!("add_type_test(type_test={:?})", type_test);
         self.constraints.type_tests.push(type_test);
     }
-
-    // FIXME(trait-refactor-initiative#260): This function should be
-    // removed.
-    fn normalize_and_add_type_outlives_constraints(
-        &self,
-        ty: ty::Unnormalized<'tcx, Ty<'tcx>>,
-        next_outlives_predicates: &mut Vec<(
-            ty::ArgOutlivesPredicate<'tcx>,
-            ConstraintCategory<'tcx>,
-        )>,
-    ) -> Ty<'tcx> {
-        match self.infcx.fully_perform(Normalize { value: ty }, self.span) {
-            Ok(TypeOpOutput { output: ty, constraints, .. }) => {
-                // FIXME(higher_ranked_auto): What should we do with the assumptions here?
-                if let Some(QueryRegionConstraints { constraints, assumptions: _ }) = constraints {
-                    next_outlives_predicates.extend(constraints.iter().flat_map(
-                        |QueryRegionConstraint { constraint, category, .. }| {
-                            constraint.iter_outlives().map(|outlives| (outlives, *category))
-                        },
-                    ));
-                }
-                ty
-            }
-            Err(_) => ty.skip_norm_wip(),
-        }
-    }
 }
 
 impl<'a, 'b, 'tcx> TypeOutlivesDelegate<'tcx> for &'a mut ConstraintConversion<'b, 'tcx> {

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -31,7 +31,7 @@ use rustc_session::diagnostics::feature_err;
 use rustc_span::{DUMMY_SP, Span, sym};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::regions::{
-    InferCtxtRegionExt, OutlivesEnvironmentBuildExt, region_known_to_outlive, ty_known_to_outlive,
+    OutlivesEnvironmentBuildExt, region_known_to_outlive, ty_known_to_outlive,
 };
 use rustc_trait_selection::traits::misc::{
     ConstParamTyImplementationError, type_allowed_to_implement_const_param_ty,

compiler/rustc_infer/src/infer/outlives/mod.rs

@@ -3,14 +3,14 @@
 use std::iter;
 
 use rustc_data_structures::undo_log::UndoLogs;
-use rustc_middle::traits::query::{NoSolution, OutlivesBound};
+use rustc_middle::traits::query::OutlivesBound;
 use rustc_middle::ty;
 use rustc_span::Span;
 use tracing::instrument;
 
 use self::env::OutlivesEnvironment;
 use super::region_constraints::{RegionConstraintData, UndoLog};
-use super::{InferCtxt, RegionResolutionError, SubregionOrigin};
+use super::{InferCtxt, RegionResolutionError};
 use crate::infer::free_regions::RegionRelations;
 use crate::infer::lexical_region_resolve;
 use crate::infer::region_constraints::ConstraintKind;
@@ -38,25 +38,15 @@ impl<'tcx> InferCtxt<'tcx> {
     /// done -- or the compiler will panic -- but it is legal to use
     /// `resolve_vars_if_possible` as well as `fully_resolve`.
     ///
-    /// If you are in a crate that has access to `rustc_trait_selection`,
-    /// then it's probably better to use `resolve_regions`,
-    /// which knows how to normalize registered region obligations.
+    /// Don't call this directly unless you know what you're doing.
+    /// You probably want to use `resolve_regions` instead.
     #[must_use]
-    pub fn resolve_regions_with_normalize(
+    pub fn resolve_regions_with_outlives_env(
         &self,
         outlives_env: &OutlivesEnvironment<'tcx>,
-        deeply_normalize_ty: impl Fn(
-            ty::PolyTypeOutlivesPredicate<'tcx>,
-            SubregionOrigin<'tcx>,
-        ) -> Result<ty::PolyTypeOutlivesPredicate<'tcx>, NoSolution>,
         span: Span,
     ) -> Vec<RegionResolutionError<'tcx>> {
-        match self.process_registered_region_obligations(outlives_env, deeply_normalize_ty, span) {
-            Ok(()) => {}
-            Err((clause, origin)) => {
-                return vec![RegionResolutionError::CannotNormalize(clause, origin)];
-            }
-        };
+        self.process_registered_region_obligations(outlives_env, span);
 
         let mut storage = {
             let mut inner = self.inner.borrow_mut();

compiler/rustc_infer/src/infer/outlives/obligations.rs

@@ -63,11 +63,10 @@ use rustc_data_structures::transitive_relation::TransitiveRelation;
 use rustc_data_structures::undo_log::UndoLogs;
 use rustc_middle::bug;
 use rustc_middle::mir::ConstraintCategory;
-use rustc_middle::traits::query::NoSolution;
 use rustc_middle::ty::outlives::{Component, push_outlives_components};
 use rustc_middle::ty::{
     self, GenericArgKind, GenericArgsRef, PolyTypeOutlivesPredicate, Region, RegionExt, RegionVid,
-    Ty, TyCtxt, TypeFoldable as _, TypeVisitableExt,
+    Ty, TyCtxt, TypeVisitableExt, eager_resolve_vars,
 };
 use rustc_span::Span;
 use smallvec::smallvec;
@@ -76,7 +75,6 @@ use tracing::{debug, instrument};
 use super::env::OutlivesEnvironment;
 use crate::infer::outlives::env::RegionBoundPairs;
 use crate::infer::outlives::verify::VerifyBoundCx;
-use crate::infer::resolve::OpportunisticRegionResolver;
 use crate::infer::snapshot::undo_log::UndoLog;
 use crate::infer::{
     self, GenericKind, InferCtxt, SubregionOrigin, TypeOutlivesConstraint, VerifyBound,
@@ -288,17 +286,12 @@ impl<'tcx> InferCtxt<'tcx> {
     /// flow of the inferencer. The key point is that it is
     /// invoked after all type-inference variables have been bound --
     /// right before lexical region resolution.
-    #[instrument(level = "debug", skip(self, outlives_env, deeply_normalize_ty))]
+    #[instrument(level = "debug", skip(self, outlives_env))]
     pub fn process_registered_region_obligations(
         &self,
         outlives_env: &OutlivesEnvironment<'tcx>,
-        mut deeply_normalize_ty: impl FnMut(
-            PolyTypeOutlivesPredicate<'tcx>,
-            SubregionOrigin<'tcx>,
-        )
-            -> Result<PolyTypeOutlivesPredicate<'tcx>, NoSolution>,
         span: Span,
-    ) -> Result<(), (PolyTypeOutlivesPredicate<'tcx>, SubregionOrigin<'tcx>)> {
+    ) {
         assert!(!self.in_snapshot(), "cannot process registered region obligations in a snapshot");
 
         if self.tcx.assumptions_on_binders() {
@@ -322,17 +315,10 @@ impl<'tcx> InferCtxt<'tcx> {
             }
 
             for TypeOutlivesConstraint { sup_type, sub_region, origin } in my_region_obligations {
-                let outlives = ty::Binder::dummy(ty::OutlivesPredicate(sup_type, sub_region));
-                let ty::OutlivesPredicate(sup_type, sub_region) =
-                    deeply_normalize_ty(outlives, origin.clone())
-                        .map_err(|NoSolution| (outlives, origin.clone()))?
-                        .no_bound_vars()
-                        .expect("started with no bound vars, should end with no bound vars");
                 // `TypeOutlives` is structural, so we should try to opportunistically resolve all
                 // region vids before processing regions, so we have a better chance to match clauses
                 // in our param-env.
-                let (sup_type, sub_region) =
-                    (sup_type, sub_region).fold_with(&mut OpportunisticRegionResolver::new(self));
+                let (sup_type, sub_region) = eager_resolve_vars(self, (sup_type, sub_region));
 
                 if self.tcx.sess.opts.unstable_opts.higher_ranked_assumptions
                     && outlives_env
@@ -355,8 +341,6 @@ impl<'tcx> InferCtxt<'tcx> {
                 outlives.type_must_outlive(origin, sup_type, sub_region, category);
             }
         }
-
-        Ok(())
     }
 }
 
@@ -435,6 +419,8 @@ where
         category: ConstraintCategory<'tcx>,
     ) {
         assert!(!ty.has_escaping_bound_vars());
+        debug_assert!(!ty.has_non_region_infer());
+        debug_assert!(!self.tcx.next_trait_solver_globally() || !ty.has_non_rigid_aliases());
 
         let mut components = smallvec![];
         push_outlives_components(self.tcx, ty, &mut components);

compiler/rustc_next_trait_solver/src/canonical/mod.rs

@@ -19,12 +19,11 @@ use rustc_type_ir::relate::{
 };
 use rustc_type_ir::{
     self as ty, Canonical, CanonicalVarKind, CanonicalVarValues, InferCtxtLike, Interner, Region,
-    TypeFoldable, TypingMode, TypingModeEqWrapper,
+    TypeFoldable, TypingMode, TypingModeEqWrapper, eager_resolve_vars,
 };
 use tracing::instrument;
 
 use crate::delegate::SolverDelegate;
-use crate::resolve::eager_resolve_vars;
 use crate::solve::{
     CanonicalInput, CanonicalResponse, Certainty, ExternalConstraintsData,
     ExternalRegionConstraints, Goal, NestedNormalizationGoals, QueryInput, Response,

compiler/rustc_next_trait_solver/src/lib.rs

@@ -15,5 +15,4 @@ pub mod coherence;
 pub mod delegate;
 pub mod normalize;
 pub mod placeholder;
-pub mod resolve;
 pub mod solve;

compiler/rustc_next_trait_solver/src/normalize.rs

@@ -4,7 +4,7 @@ use rustc_type_ir::data_structures::ensure_sufficient_stack;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::{
     self as ty, AliasTerm, Binder, FallibleTypeFolder, InferCtxtLike, Interner, TypeFoldable,
-    TypeSuperFoldable, TypeVisitableExt, UniverseIndex,
+    TypeSuperFoldable, TypeVisitableExt, UniverseIndex, eager_resolve_vars,
 };
 use tracing::instrument;
 
@@ -143,8 +143,8 @@ where
 
         if self.cx().renormalize_rigid_aliases() && orig_is_rigid == ty::IsRigid::Yes {
             // find out missing typing env change.
-            let original = crate::resolve::eager_resolve_vars(infcx, original);
-            let normalized = crate::resolve::eager_resolve_vars(infcx, normalized);
+            let original = eager_resolve_vars(infcx, original);
+            let normalized = eager_resolve_vars(infcx, normalized);
             assert_eq!(original, normalized, "rigid alias is further normalized");
         }
         Ok(normalized)
@@ -196,8 +196,8 @@ where
 
         if self.cx().renormalize_rigid_aliases() && orig_is_rigid == ty::IsRigid::Yes {
             // find out missing typing env change.
-            let original = crate::resolve::eager_resolve_vars(infcx, original);
-            let normalized = crate::resolve::eager_resolve_vars(infcx, normalized);
+            let original = eager_resolve_vars(infcx, original);
+            let normalized = eager_resolve_vars(infcx, normalized);
             assert_eq!(original, normalized, "rigid alias is further normalized");
         }