middle: ClauseKind-specific ParamEnv accessors

Replace the `caller_bounds` function of `ParamEnv` with
`ClauseKind`-specific accessors (i.e. `trait_clauses`,
`region_outlives_clauses`) which will make it easier to later change
the internals of `ParamEnv`.

Author: davidtwco

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -254,10 +254,8 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             let place = &self.move_data.move_paths[mpi].place;
             let ty = place.ty(self.body, self.infcx.tcx).ty;
 
-            if self.infcx.param_env.caller_bounds().iter().any(|c| {
-                c.as_trait_clause().is_some_and(|pred| {
-                    pred.skip_binder().self_ty() == ty && self.infcx.tcx.is_fn_trait(pred.def_id())
-                })
+            if self.infcx.param_env.trait_clauses().any(|pred| {
+                pred.skip_binder().self_ty() == ty && self.infcx.tcx.is_fn_trait(pred.def_id())
             }) {
                 // Suppress the next suggestion since we don't want to put more bounds onto
                 // something that already has `Fn`-like bounds (or is a closure), so we can't

compiler/rustc_borrowck/src/type_check/free_region_relations.rs

@@ -226,15 +226,13 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
         // Normalize the assumptions we use to borrowck the program.
         let mut constraints = vec![];
         let mut known_type_outlives_obligations = vec![];
-        for bound in param_env.caller_bounds() {
-            if let Some(outlives) = bound.as_type_outlives_clause() {
-                self.normalize_and_push_type_outlives_obligation(
-                    outlives,
-                    span,
-                    &mut known_type_outlives_obligations,
-                    &mut constraints,
-                );
-            };
+        for outlives in param_env.type_outlives_clauses() {
+            self.normalize_and_push_type_outlives_obligation(
+                outlives,
+                span,
+                &mut known_type_outlives_obligations,
+                &mut constraints,
+            );
         }
 
         let unnormalized_input_output_tys = self

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -235,7 +235,7 @@ fn compare_method_predicate_entailment<'tcx>(
     let normalize_cause = traits::ObligationCause::misc(impl_m_span, impl_m_def_id);
     let param_env = ty::ParamEnv::new(tcx.mk_clauses(&hybrid_preds));
     let param_env = traits::normalize_param_env_or_error(tcx, param_env, normalize_cause);
-    debug!(caller_bounds=?param_env.caller_bounds());
+    debug!(?param_env);
 
     let infcx = &tcx.infer_ctxt().build(TypingMode::non_body_analysis());
     let ocx = ObligationCtxt::new_with_diagnostics(infcx);
@@ -1990,7 +1990,7 @@ fn compare_type_predicate_entailment<'tcx>(
 
     let param_env = ty::ParamEnv::new(tcx.mk_clauses(&hybrid_preds));
     let param_env = traits::normalize_param_env_or_error(tcx, param_env, normalize_cause);
-    debug!(caller_bounds=?param_env.caller_bounds());
+    debug!(?param_env);
 
     let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());
     let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
@@ -2229,7 +2229,7 @@ fn param_env_with_gat_bounds<'tcx>(
 ) -> ty::ParamEnv<'tcx> {
     let param_env = tcx.param_env(impl_ty.def_id);
     let container_id = impl_ty.container_id(tcx);
-    let mut predicates = param_env.caller_bounds().to_vec();
+    let mut predicates = param_env.all_clauses().collect::<Vec<_>>();
 
     // for RPITITs, we should install predicates that allow us to project all
     // of the RPITITs associated with the same body. This is because checking

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -586,9 +586,8 @@ fn augment_param_env<'tcx>(
         return param_env;
     }
 
-    let bounds = tcx.mk_clauses_from_iter(
-        param_env.caller_bounds().iter().chain(new_predicates.iter().cloned()),
-    );
+    let bounds =
+        tcx.mk_clauses_from_iter(param_env.all_clauses().chain(new_predicates.iter().cloned()));
     // FIXME(compiler-errors): Perhaps there is a case where we need to normalize this
     // i.e. traits::normalize_param_env_or_error
     ty::ParamEnv::new(bounds)

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs

@@ -15,7 +15,7 @@ use rustc_hir::{self as hir, HirId, ItemLocalMap};
 use rustc_hir_analysis::hir_ty_lowering::{HirTyLowerer, RegionInferReason};
 use rustc_infer::infer;
 use rustc_infer::traits::Obligation;
-use rustc_middle::ty::{self, Const, Ty, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{self, Const, Ty, TyCtxt, TypeVisitableExt, Upcast};
 use rustc_session::Session;
 use rustc_span::{self, DUMMY_SP, ErrorGuaranteed, Ident, Span, sym};
 use rustc_trait_selection::error_reporting::TypeErrCtxt;
@@ -296,16 +296,15 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
         // HACK(eddyb) should get the original `Span`.
         let span = tcx.def_span(def_id);
 
-        ty::EarlyBinder::bind(tcx.arena.alloc_from_iter(
-            self.param_env.caller_bounds().iter().filter_map(|predicate| {
-                match predicate.kind().skip_binder() {
-                    ty::ClauseKind::Trait(data) if data.self_ty().is_param(index) => {
-                        Some((predicate, span))
-                    }
-                    _ => None,
-                }
-            }),
-        ))
+        ty::EarlyBinder::bind(tcx.arena.alloc_from_iter(self.param_env.trait_clauses().filter_map(
+            |predicate| {
+                predicate
+                    .self_ty()
+                    .skip_binder()
+                    .is_param(index)
+                    .then_some((predicate.upcast(tcx), span))
+            },
+        )))
     }
 
     fn lower_assoc_shared(

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -909,24 +909,10 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
 
     #[instrument(level = "debug", skip(self))]
     fn assemble_inherent_candidates_from_param(&mut self, param_ty: ty::ParamTy) {
-        let bounds = self.param_env.caller_bounds().iter().filter_map(|predicate| {
-            let bound_predicate = predicate.kind();
-            match bound_predicate.skip_binder() {
-                ty::ClauseKind::Trait(trait_predicate) => {
-                    match *trait_predicate.trait_ref.self_ty().kind() {
-                        ty::Param(p) if p == param_ty => {
-                            Some(bound_predicate.rebind(trait_predicate.trait_ref))
-                        }
-                        _ => None,
-                    }
-                }
-                ty::ClauseKind::RegionOutlives(_)
-                | ty::ClauseKind::TypeOutlives(_)
-                | ty::ClauseKind::Projection(_)
-                | ty::ClauseKind::ConstArgHasType(_, _)
-                | ty::ClauseKind::WellFormed(_)
-                | ty::ClauseKind::ConstEvaluatable(_)
-                | ty::ClauseKind::HostEffect(..) => None,
+        let bounds = self.param_env.trait_clauses().filter_map(|trait_predicate| {
+            match *trait_predicate.self_ty().skip_binder().kind() {
+                ty::Param(p) if p == param_ty => Some(trait_predicate.map_bound(|p| p.trait_ref)),
+                _ => None,
             }
         });
 

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

@@ -65,9 +65,9 @@ where
                 let outlives_bounds: Vec<_> = tcx
                     .item_bounds(def_id)
                     .iter_instantiated(tcx, args)
-                    .chain(param_env.caller_bounds())
-                    .filter_map(|clause| {
-                        let outlives = clause.as_type_outlives_clause()?;
+                    .filter_map(|clause| clause.as_type_outlives_clause())
+                    .chain(param_env.type_outlives_clauses())
+                    .filter_map(|outlives| {
                         if let Some(outlives) = outlives.no_bound_vars()
                             && outlives.0 == ty
                         {

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

@@ -17,14 +17,12 @@ pub mod obligations;
 pub mod test_type_match;
 pub(crate) mod verify;
 
-#[instrument(level = "debug", skip(param_env), ret)]
+#[instrument(level = "debug", skip(param_env))]
 pub fn explicit_outlives_bounds<'tcx>(
     param_env: ty::ParamEnv<'tcx>,
 ) -> impl Iterator<Item = OutlivesBound<'tcx>> {
     param_env
-        .caller_bounds()
-        .into_iter()
-        .filter_map(ty::Clause::as_region_outlives_clause)
+        .region_outlives_clauses()
         .filter_map(ty::Binder::no_bound_vars)
         .map(|ty::OutlivesPredicate(r_a, r_b)| OutlivesBound::RegionSubRegion(r_b, r_a))
 }

compiler/rustc_middle/src/query/mod.rs

@@ -2437,7 +2437,7 @@ rustc_queries! {
         desc { "resolving instance `{}`", ty::Instance::new(key.value.0, key.value.1) }
     }
 
-    query reveal_opaque_types_in_bounds(key: ty::Clauses<'tcx>) -> ty::Clauses<'tcx> {
+    query reveal_opaque_types_in_bounds(key: ty::ParamEnv<'tcx>) -> ty::ParamEnv<'tcx> {
         desc { "revealing opaque types in `{:?}`", key }
     }
 

compiler/rustc_middle/src/ty/codec.rs

@@ -209,7 +209,7 @@ impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for CtfeProvenance {
 
 impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for ty::ParamEnv<'tcx> {
     fn encode(&self, e: &mut E) {
-        self.caller_bounds().encode(e);
+        self.caller_bounds.encode(e);
     }
 }
 
@@ -340,8 +340,8 @@ impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for ty::SymbolName<'tcx> {
 
 impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for ty::ParamEnv<'tcx> {
     fn decode(d: &mut D) -> Self {
-        let caller_bounds = Decodable::decode(d);
-        ty::ParamEnv::new(caller_bounds)
+        let all_clauses = Decodable::decode(d);
+        ty::ParamEnv::new(all_clauses)
     }
 }