Normalize param-env used by lexical region checking in new solver

Author: compiler-errors

compiler/rustc_borrowck/src/type_check/free_region_relations.rs

@@ -199,7 +199,8 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
 
         // Insert the facts we know from the predicates. Why? Why not.
         let param_env = self.param_env;
-        self.add_outlives_bounds(outlives::explicit_outlives_bounds(param_env));
+        // FIXME(-Znext-solver): This param-env is not normalized!
+        self.add_outlives_bounds(outlives::explicit_outlives_bounds(param_env.caller_bounds()));
 
         // - outlives is reflexive, so `'r: 'r` for every region `'r`
         // - `'static: 'r` for every region `'r`

compiler/rustc_hir_analysis/src/check/check.rs

@@ -10,6 +10,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind};
 use rustc_hir::def_id::LocalModDefId;
 use rustc_hir::Node;
+use rustc_infer::infer::outlives::env::RegionCheckingAssumptions;
 use rustc_infer::infer::{RegionVariableOrigin, TyCtxtInferExt};
 use rustc_infer::traits::{Obligation, TraitEngineExt as _};
 use rustc_lint_defs::builtin::REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS;
@@ -353,8 +354,8 @@ fn check_opaque_meets_bounds<'tcx>(
         hir::OpaqueTyOrigin::TyAlias { .. } => {
             let wf_tys = ocx.assumed_wf_types_and_report_errors(param_env, def_id)?;
             let implied_bounds = infcx.implied_bounds_tys(param_env, def_id, wf_tys);
-            let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
-            ocx.resolve_regions_and_report_errors(defining_use_anchor, &outlives_env)?;
+            let assumptions = RegionCheckingAssumptions::with_bounds(param_env, implied_bounds);
+            ocx.resolve_regions_and_report_errors(defining_use_anchor, &assumptions)?;
         }
     }
     // Check that any hidden types found during wf checking match the hidden types that `type_of` sees.

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -7,7 +7,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit;
 use rustc_hir::{GenericParamKind, ImplItemKind};
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
+use rustc_infer::infer::outlives::env::RegionCheckingAssumptions;
 use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
 use rustc_infer::traits::util;
@@ -377,11 +377,11 @@ fn compare_method_predicate_entailment<'tcx>(
 
     // Finally, resolve all regions. This catches wily misuses of
     // lifetime parameters.
-    let outlives_env = OutlivesEnvironment::with_bounds(
+    let assumptions = RegionCheckingAssumptions::with_bounds(
         param_env,
         infcx.implied_bounds_tys(param_env, impl_m_def_id, wf_tys),
     );
-    let errors = infcx.resolve_regions_normalizing_outlives_obligations(&outlives_env);
+    let errors = infcx.resolve_regions_normalizing_outlives_obligations(&assumptions);
     if !errors.is_empty() {
         return Err(infcx
             .tainted_by_errors()
@@ -701,11 +701,11 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
 
     // Finally, resolve all regions. This catches wily misuses of
     // lifetime parameters.
-    let outlives_env = OutlivesEnvironment::with_bounds(
+    let assumptions = RegionCheckingAssumptions::with_bounds(
         param_env,
         infcx.implied_bounds_tys(param_env, impl_m_def_id, wf_tys),
     );
-    ocx.resolve_regions_and_report_errors(impl_m_def_id, &outlives_env)?;
+    ocx.resolve_regions_and_report_errors(impl_m_def_id, &assumptions)?;
 
     let mut remapped_types = FxHashMap::default();
     for (def_id, (ty, args)) in collected_types {
@@ -1873,8 +1873,8 @@ fn compare_const_predicate_entailment<'tcx>(
         return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
     }
 
-    let outlives_env = OutlivesEnvironment::new(param_env);
-    ocx.resolve_regions_and_report_errors(impl_ct_def_id, &outlives_env)
+    let assumptions = RegionCheckingAssumptions::new(param_env);
+    ocx.resolve_regions_and_report_errors(impl_ct_def_id, &assumptions)
 }
 
 pub(super) fn compare_impl_ty<'tcx>(
@@ -1969,8 +1969,8 @@ fn compare_type_predicate_entailment<'tcx>(
 
     // Finally, resolve all regions. This catches wily misuses of
     // lifetime parameters.
-    let outlives_env = OutlivesEnvironment::new(param_env);
-    ocx.resolve_regions_and_report_errors(impl_ty_def_id, &outlives_env)
+    let assumptions = RegionCheckingAssumptions::new(param_env);
+    ocx.resolve_regions_and_report_errors(impl_ty_def_id, &assumptions)
 }
 
 /// Validate that `ProjectionCandidate`s created for this associated type will
@@ -2075,8 +2075,8 @@ pub(super) fn check_type_bounds<'tcx>(
     // Finally, resolve all regions. This catches wily misuses of
     // lifetime parameters.
     let implied_bounds = infcx.implied_bounds_tys(param_env, impl_ty_def_id, assumed_wf_types);
-    let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
-    ocx.resolve_regions_and_report_errors(impl_ty_def_id, &outlives_env)
+    let assumptions = RegionCheckingAssumptions::with_bounds(param_env, implied_bounds);
+    ocx.resolve_regions_and_report_errors(impl_ty_def_id, &assumptions)
 }
 
 /// Install projection predicates that allow GATs to project to their own

compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs

@@ -1,7 +1,8 @@
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
-use rustc_infer::infer::{outlives::env::OutlivesEnvironment, TyCtxtInferExt};
+use rustc_infer::infer::outlives::env::RegionCheckingAssumptions;
+use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint_defs::builtin::REFINING_IMPL_TRAIT;
 use rustc_middle::traits::{ObligationCause, Reveal};
 use rustc_middle::ty::{
@@ -160,11 +161,11 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
         );
         return;
     }
-    let outlives_env = OutlivesEnvironment::with_bounds(
+    let assumptions = RegionCheckingAssumptions::with_bounds(
         param_env,
         infcx.implied_bounds_tys(param_env, impl_m.def_id.expect_local(), implied_wf_types),
     );
-    let errors = infcx.resolve_regions_normalizing_outlives_obligations(&outlives_env);
+    let errors = infcx.resolve_regions_normalizing_outlives_obligations(&assumptions);
     if !errors.is_empty() {
         tcx.sess.span_delayed_bug(
             DUMMY_SP,

compiler/rustc_hir_analysis/src/check/dropck.rs

@@ -3,7 +3,7 @@
 // We don't do any drop checking during hir typeck.
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{struct_span_err, ErrorGuaranteed};
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
+use rustc_infer::infer::outlives::env::RegionCheckingAssumptions;
 use rustc_infer::infer::{RegionResolutionError, TyCtxtInferExt};
 use rustc_middle::ty::util::CheckRegions;
 use rustc_middle::ty::GenericArgsRef;
@@ -170,9 +170,9 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
         return Err(guar.unwrap());
     }
 
-    let errors = ocx
-        .infcx
-        .resolve_regions_normalizing_outlives_obligations(&OutlivesEnvironment::new(param_env));
+    let errors = ocx.infcx.resolve_regions_normalizing_outlives_obligations(
+        &RegionCheckingAssumptions::new(param_env),
+    );
     if !errors.is_empty() {
         let mut guar = None;
         for error in errors {

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -82,7 +82,7 @@ use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::Visitor;
 use rustc_index::bit_set::BitSet;
 use rustc_infer::infer::error_reporting::ObligationCauseExt as _;
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
+use rustc_infer::infer::outlives::env::RegionCheckingAssumptions;
 use rustc_infer::infer::{self, TyCtxtInferExt as _};
 use rustc_infer::traits::ObligationCause;
 use rustc_middle::query::Providers;
@@ -615,8 +615,8 @@ pub fn check_function_signature<'tcx>(
         }
     }
 
-    let outlives_env = OutlivesEnvironment::new(param_env);
-    let _ = ocx.resolve_regions_and_report_errors(local_id, &outlives_env);
+    let assumptions = RegionCheckingAssumptions::new(param_env);
+    let _ = ocx.resolve_regions_and_report_errors(local_id, &assumptions);
 
     fn extract_span_for_error_reporting<'tcx>(
         tcx: TyCtxt<'tcx>,

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -8,7 +8,7 @@ use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId};
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::ItemKind;
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
+use rustc_infer::infer::outlives::env::RegionCheckingAssumptions;
 use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
 use rustc_middle::query::Providers;
 use rustc_middle::ty::trait_def::TraitSpecializationKind;
@@ -125,9 +125,9 @@ where
         }
     }
 
-    let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
+    let assumptions = RegionCheckingAssumptions::with_bounds(param_env, implied_bounds);
 
-    wfcx.ocx.resolve_regions_and_report_errors(body_def_id, &outlives_env)?;
+    wfcx.ocx.resolve_regions_and_report_errors(body_def_id, &assumptions)?;
     infcx.tainted_by_errors().error_reported()
 }
 
@@ -713,7 +713,7 @@ fn test_region_obligations<'tcx>(
 
     add_constraints(&infcx);
 
-    let outlives_environment = OutlivesEnvironment::with_bounds(
+    let outlives_environment = RegionCheckingAssumptions::with_bounds(
         param_env,
         infcx.implied_bounds_tys(param_env, id, wf_tys.clone()),
     );

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -9,7 +9,7 @@ use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::ItemKind;
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
+use rustc_infer::infer::outlives::env::RegionCheckingAssumptions;
 use rustc_infer::infer::{self, RegionResolutionError};
 use rustc_infer::infer::{DefineOpaqueTypes, TyCtxtInferExt};
 use rustc_infer::traits::Obligation;
@@ -265,8 +265,8 @@ fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: LocalDef
                 }
 
                 // Finally, resolve all regions.
-                let outlives_env = OutlivesEnvironment::new(param_env);
-                let _ = ocx.resolve_regions_and_report_errors(impl_did, &outlives_env);
+                let assumptions = RegionCheckingAssumptions::new(param_env);
+                let _ = ocx.resolve_regions_and_report_errors(impl_did, &assumptions);
             }
         }
         _ => {
@@ -474,8 +474,8 @@ pub fn coerce_unsized_info<'tcx>(tcx: TyCtxt<'tcx>, impl_did: LocalDefId) -> Coe
     }
 
     // Finally, resolve all regions.
-    let outlives_env = OutlivesEnvironment::new(param_env);
-    let _ = ocx.resolve_regions_and_report_errors(impl_did, &outlives_env);
+    let assumptions = RegionCheckingAssumptions::new(param_env);
+    let _ = ocx.resolve_regions_and_report_errors(impl_did, &assumptions);
 
     CoerceUnsizedInfo { custom_kind: kind }
 }

compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs

@@ -71,7 +71,7 @@ use crate::{constrained_generic_params as cgp, errors};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
+use rustc_infer::infer::outlives::env::RegionCheckingAssumptions;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::specialization_graph::Node;
 use rustc_middle::ty::trait_def::TraitSpecializationKind;
@@ -203,8 +203,8 @@ fn get_impl_args(
     }
 
     let implied_bounds = infcx.implied_bounds_tys(param_env, impl1_def_id, assumed_wf_types);
-    let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
-    let _ = ocx.resolve_regions_and_report_errors(impl1_def_id, &outlives_env);
+    let assumptions = RegionCheckingAssumptions::with_bounds(param_env, implied_bounds);
+    let _ = ocx.resolve_regions_and_report_errors(impl1_def_id, &assumptions);
     let Ok(impl2_args) = infcx.fully_resolve(impl2_args) else {
         let span = tcx.def_span(impl1_def_id);
         let guar = tcx.sess.emit_err(SubstsOnOverriddenImpl { span });

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

@@ -1,11 +1,29 @@
-use crate::infer::free_regions::FreeRegionMap;
 use crate::infer::GenericKind;
+use crate::infer::{free_regions::FreeRegionMap, outlives::explicit_outlives_bounds};
 use crate::traits::query::OutlivesBound;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_data_structures::transitive_relation::TransitiveRelationBuilder;
 use rustc_middle::ty::{self, Region};
 
-use super::explicit_outlives_bounds;
+pub struct RegionCheckingAssumptions<'tcx> {
+    pub param_env: ty::ParamEnv<'tcx>,
+    pub extra_bounds: FxIndexSet<OutlivesBound<'tcx>>,
+}
+
+impl<'tcx> RegionCheckingAssumptions<'tcx> {
+    /// Create a new `RegionCheckingAssumptions` without extra outlives bounds.
+    pub fn new(param_env: ty::ParamEnv<'tcx>) -> RegionCheckingAssumptions<'tcx> {
+        RegionCheckingAssumptions { param_env, extra_bounds: Default::default() }
+    }
+
+    /// Create a new `RegionCheckingAssumptions` with extra outlives bounds.
+    pub fn with_bounds(
+        param_env: ty::ParamEnv<'tcx>,
+        extra_bounds: impl IntoIterator<Item = OutlivesBound<'tcx>>,
+    ) -> RegionCheckingAssumptions<'tcx> {
+        RegionCheckingAssumptions { param_env, extra_bounds: extra_bounds.into_iter().collect() }
+    }
+}
 
 /// The `OutlivesEnvironment` collects information about what outlives
 /// what in a given type-checking setting. For example, if we have a
@@ -28,7 +46,7 @@ use super::explicit_outlives_bounds;
 /// interested in the `OutlivesEnvironment`. -nmatsakis
 #[derive(Clone)]
 pub struct OutlivesEnvironment<'tcx> {
-    pub param_env: ty::ParamEnv<'tcx>,
+    pub clauses: Vec<ty::Clause<'tcx>>,
     free_region_map: FreeRegionMap<'tcx>,
 
     // Contains the implied region bounds in scope for our current body.
@@ -54,8 +72,8 @@ pub struct OutlivesEnvironment<'tcx> {
 
 /// Builder of OutlivesEnvironment.
 #[derive(Debug)]
-struct OutlivesEnvironmentBuilder<'tcx> {
-    param_env: ty::ParamEnv<'tcx>,
+pub struct OutlivesEnvironmentBuilder<'tcx> {
+    clauses: Vec<ty::Clause<'tcx>>,
     region_relation: TransitiveRelationBuilder<Region<'tcx>>,
     region_bound_pairs: RegionBoundPairs<'tcx>,
 }
@@ -68,32 +86,12 @@ pub type RegionBoundPairs<'tcx> =
 
 impl<'tcx> OutlivesEnvironment<'tcx> {
     /// Create a builder using `ParamEnv` and add explicit outlives bounds into it.
-    fn builder(param_env: ty::ParamEnv<'tcx>) -> OutlivesEnvironmentBuilder<'tcx> {
-        let mut builder = OutlivesEnvironmentBuilder {
-            param_env,
+    pub fn builder() -> OutlivesEnvironmentBuilder<'tcx> {
+        OutlivesEnvironmentBuilder {
+            clauses: vec![],
             region_relation: Default::default(),
             region_bound_pairs: Default::default(),
-        };
-
-        builder.add_outlives_bounds(explicit_outlives_bounds(param_env));
-
-        builder
-    }
-
-    #[inline]
-    /// Create a new `OutlivesEnvironment` without extra outlives bounds.
-    pub fn new(param_env: ty::ParamEnv<'tcx>) -> Self {
-        Self::builder(param_env).build()
-    }
-
-    /// Create a new `OutlivesEnvironment` with extra outlives bounds.
-    pub fn with_bounds(
-        param_env: ty::ParamEnv<'tcx>,
-        extra_bounds: impl IntoIterator<Item = OutlivesBound<'tcx>>,
-    ) -> Self {
-        let mut builder = Self::builder(param_env);
-        builder.add_outlives_bounds(extra_bounds);
-        builder.build()
+        }
     }
 
     /// Borrows current value of the `free_region_map`.
@@ -110,16 +108,21 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
 impl<'tcx> OutlivesEnvironmentBuilder<'tcx> {
     #[inline]
     #[instrument(level = "debug")]
-    fn build(self) -> OutlivesEnvironment<'tcx> {
+    pub fn build(self) -> OutlivesEnvironment<'tcx> {
         OutlivesEnvironment {
-            param_env: self.param_env,
+            clauses: self.clauses,
             free_region_map: FreeRegionMap { relation: self.region_relation.freeze() },
             region_bound_pairs: self.region_bound_pairs,
         }
     }
 
+    pub fn add_clauses(&mut self, clauses: &[ty::Clause<'tcx>]) {
+        self.add_outlives_bounds(explicit_outlives_bounds(clauses));
+        self.clauses.extend(clauses.iter().copied());
+    }
+
     /// Processes outlives bounds that are known to hold, whether from implied or other sources.
-    fn add_outlives_bounds<I>(&mut self, outlives_bounds: I)
+    pub fn add_outlives_bounds<I>(&mut self, outlives_bounds: I)
     where
         I: IntoIterator<Item = OutlivesBound<'tcx>>,
     {