middle: split caller_bounds into multiple fields

Instead of filtering on `caller_bounds` at every use, instead filter
them once when creating the `ParamEnv`. This will avoid unnecessary
iteration over irrelevant bounds and improve performance.

Author: davidtwco

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -233,7 +233,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, tcx.mk_clauses(&hybrid_preds));
+    let param_env = ty::ParamEnv::from_iter(tcx, hybrid_preds.iter().copied());
     let param_env = traits::normalize_param_env_or_error(tcx, param_env, normalize_cause);
     debug!(?param_env);
 
@@ -523,7 +523,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
         .into_iter()
         .chain(tcx.predicates_of(trait_m.def_id).instantiate_own(tcx, trait_to_impl_args))
         .map(|(clause, _)| clause);
-    let param_env = ty::ParamEnv::new(tcx, tcx.mk_clauses_from_iter(hybrid_preds));
+    let param_env = ty::ParamEnv::from_iter(tcx, hybrid_preds);
     let param_env = traits::normalize_param_env_or_error(
         tcx,
         param_env,
@@ -1837,7 +1837,7 @@ fn compare_const_predicate_entailment<'tcx>(
             .map(|(predicate, _)| predicate),
     );
 
-    let param_env = ty::ParamEnv::new(tcx, tcx.mk_clauses(&hybrid_preds));
+    let param_env = ty::ParamEnv::from_iter(tcx, hybrid_preds.iter().copied());
     let param_env = traits::normalize_param_env_or_error(
         tcx,
         param_env,
@@ -1988,7 +1988,7 @@ fn compare_type_predicate_entailment<'tcx>(
         );
     }
 
-    let param_env = ty::ParamEnv::new(tcx, tcx.mk_clauses(&hybrid_preds));
+    let param_env = ty::ParamEnv::from_iter(tcx, hybrid_preds.iter().copied());
     let param_env = traits::normalize_param_env_or_error(tcx, param_env, normalize_cause);
     debug!(?param_env);
 
@@ -2336,7 +2336,7 @@ fn param_env_with_gat_bounds<'tcx>(
         };
     }
 
-    ty::ParamEnv::new(tcx, tcx.mk_clauses(&predicates))
+    ty::ParamEnv::from_iter(tcx, predicates.iter().copied())
 }
 
 /// Manually check here that `async fn foo()` wasn't matched against `fn foo()`,

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

@@ -132,7 +132,7 @@ pub(crate) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
         .into_iter()
         .chain(tcx.predicates_of(trait_m.def_id).instantiate_own(tcx, trait_m_to_impl_m_args))
         .map(|(clause, _)| clause);
-    let param_env = ty::ParamEnv::new(tcx, tcx.mk_clauses_from_iter(hybrid_preds));
+    let param_env = ty::ParamEnv::from_iter(tcx, hybrid_preds);
     let param_env = normalize_param_env_or_error(tcx, param_env, ObligationCause::dummy());
 
     let ref infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -586,11 +586,9 @@ fn augment_param_env<'tcx>(
         return param_env;
     }
 
-    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(tcx, bounds)
+    ty::ParamEnv::from_iter(tcx, param_env.all_clauses().chain(new_predicates.iter().cloned()))
 }
 
 /// We use the following trait as an example throughout this function.

compiler/rustc_middle/src/ty/codec.rs

@@ -209,7 +209,14 @@ impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for CtfeProvenance {
 
 impl<'tcx, E: TyEncoder<'tcx>> Encodable<E> for ty::ParamEnvInner<'tcx> {
     fn encode(&self, e: &mut E) {
-        self.caller_bounds.encode(e);
+        self.trait_clauses.encode(e);
+        self.region_outlives_clauses.encode(e);
+        self.type_outlives_clauses.encode(e);
+        self.projection_clauses.encode(e);
+        self.const_arg_has_type_clauses.encode(e);
+        self.well_formed_clauses.encode(e);
+        self.const_evaluatable_clauses.encode(e);
+        self.host_effect_clauses.encode(e);
     }
 }
 
@@ -340,8 +347,24 @@ impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for ty::SymbolName<'tcx> {
 
 impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for ty::ParamEnvInner<'tcx> {
     fn decode(d: &mut D) -> Self {
-        let caller_bounds = Decodable::decode(d);
-        ty::ParamEnvInner { caller_bounds }
+        let trait_clauses = Decodable::decode(d);
+        let region_outlives_clauses = Decodable::decode(d);
+        let type_outlives_clauses = Decodable::decode(d);
+        let projection_clauses = Decodable::decode(d);
+        let const_arg_has_type_clauses = Decodable::decode(d);
+        let well_formed_clauses = Decodable::decode(d);
+        let const_evaluatable_clauses = Decodable::decode(d);
+        let host_effect_clauses = Decodable::decode(d);
+        ty::ParamEnvInner {
+            trait_clauses,
+            region_outlives_clauses,
+            type_outlives_clauses,
+            projection_clauses,
+            const_arg_has_type_clauses,
+            well_formed_clauses,
+            const_evaluatable_clauses,
+            host_effect_clauses,
+        }
     }
 }
 

compiler/rustc_middle/src/ty/mod.rs

@@ -971,18 +971,39 @@ impl<'tcx> rustc_type_ir::Flags for Clauses<'tcx> {
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 #[derive(HashStable, TypeVisitable, TypeFoldable)]
 pub struct ParamEnvInner<'tcx> {
-    /// Caller bounds are `Obligation`s that the caller must satisfy. This is
-    /// basically the set of bounds on the in-scope type parameters, translated
-    /// into `Obligation`s, and elaborated and normalized.
-    ///
-    /// Use the `caller_bounds()` method to access.
-    caller_bounds: Clauses<'tcx>,
-}
-
-/// When interacting with the type system we must provide information about the
-/// environment. `ParamEnv` is the type that represents this information. See the
+    /// Corresponds to `where Foo: Bar<A, B, C>`. `Foo` here would be
+    /// the `Self` type of the trait reference and `A`, `B`, and `C`
+    /// would be the type parameters.
+    trait_clauses: Clauses<'tcx>,
+    /// `where 'a: 'r`
+    region_outlives_clauses: Clauses<'tcx>,
+    /// `where T: 'r`
+    type_outlives_clauses: Clauses<'tcx>,
+    /// `where <T as TraitRef>::Name == X`, approximately.
+    /// See the `ProjectionPredicate` struct for details.
+    projection_clauses: Clauses<'tcx>,
+    /// Ensures that a const generic argument to a parameter `const N: u8`
+    /// is of type `u8`.
+    const_arg_has_type_clauses: Clauses<'tcx>,
+    /// No syntax: `T` well-formed.
+    well_formed_clauses: Clauses<'tcx>,
+    /// Constant initializer must evaluate successfully.
+    const_evaluatable_clauses: Clauses<'tcx>,
+    /// Enforces the constness of the predicate we're calling. Like a projection
+    /// goal from a where clause, it's always going to be paired with a
+    /// corresponding trait clause; this just enforces the *constness* of that
+    /// implementation.
+    host_effect_clauses: Clauses<'tcx>,
+}
+
+/// When interacting with the type system we must provide information about the environment.
+/// `ParamEnv` is the type that represents this information. See the
 /// [dev guide chapter][param_env_guide] for more information.
 ///
+/// Contains various kinds of caller bounds - `Obligation`s that the caller must satisfy. This is
+/// basically the set of bounds on the in-scope type parameters, translated into `Obligation`s,
+/// and elaborated and normalized.
+///
 /// [param_env_guide]: https://rustc-dev-guide.rust-lang.org/typing_parameter_envs.html
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 #[derive(HashStable)]
@@ -997,64 +1018,117 @@ impl<'tcx> ParamEnv<'tcx> {
     /// [param_env_guide]: https://rustc-dev-guide.rust-lang.org/typing_parameter_envs.html
     #[inline]
     pub fn empty(tcx: TyCtxt<'tcx>) -> Self {
-        tcx.mk_param_env(ParamEnvInner { caller_bounds: ListWithCachedTypeInfo::empty() })
+        tcx.mk_param_env(ParamEnvInner {
+            trait_clauses: ListWithCachedTypeInfo::empty(),
+            region_outlives_clauses: ListWithCachedTypeInfo::empty(),
+            type_outlives_clauses: ListWithCachedTypeInfo::empty(),
+            projection_clauses: ListWithCachedTypeInfo::empty(),
+            const_arg_has_type_clauses: ListWithCachedTypeInfo::empty(),
+            well_formed_clauses: ListWithCachedTypeInfo::empty(),
+            const_evaluatable_clauses: ListWithCachedTypeInfo::empty(),
+            host_effect_clauses: ListWithCachedTypeInfo::empty(),
+        })
     }
 
     #[inline]
     pub fn all_clauses(self) -> impl Iterator<Item = Clause<'tcx>> {
-        self.0.0.caller_bounds.iter()
+        let trait_clauses = self.0.0.trait_clauses.iter();
+        let region_outlives_clauses = self.0.0.region_outlives_clauses.iter();
+        let type_outlives_clauses = self.0.0.type_outlives_clauses.iter();
+        let projection_clauses = self.0.0.projection_clauses.iter();
+        let const_arg_has_type_clauses = self.0.0.const_arg_has_type_clauses.iter();
+        let well_formed_clauses = self.0.0.well_formed_clauses.iter();
+        let const_evaluatable_clauses = self.0.0.const_evaluatable_clauses.iter();
+        let host_effect_clauses = self.0.0.host_effect_clauses.iter();
+
+        trait_clauses.chain(region_outlives_clauses.chain(type_outlives_clauses.chain(
+            projection_clauses.chain(const_arg_has_type_clauses.chain(
+                well_formed_clauses.chain(const_evaluatable_clauses.chain(host_effect_clauses)),
+            )),
+        )))
     }
 
     #[inline]
     pub fn trait_clauses(self) -> impl Iterator<Item = PolyTraitPredicate<'tcx>> {
-        self.0.0.caller_bounds.iter().filter_map(|c| c.as_trait_clause())
+        self.0.0.trait_clauses.iter().filter_map(|c| c.as_trait_clause())
     }
 
     #[inline]
     pub fn region_outlives_clauses(
         self,
     ) -> impl Iterator<Item = PolyRegionOutlivesPredicate<'tcx>> {
-        self.0.0.caller_bounds.iter().filter_map(|c| c.as_region_outlives_clause())
+        self.0.0.region_outlives_clauses.iter().filter_map(|c| c.as_region_outlives_clause())
     }
 
     #[inline]
     pub fn type_outlives_clauses(self) -> impl Iterator<Item = PolyTypeOutlivesPredicate<'tcx>> {
-        self.0.0.caller_bounds.iter().filter_map(|c| c.as_type_outlives_clause())
+        self.0.0.type_outlives_clauses.iter().filter_map(|c| c.as_type_outlives_clause())
     }
 
     #[inline]
     pub fn projection_clauses(self) -> impl Iterator<Item = PolyProjectionPredicate<'tcx>> {
-        self.0.0.caller_bounds.iter().filter_map(|c| c.as_projection_clause())
+        self.0.0.projection_clauses.iter().filter_map(|c| c.as_projection_clause())
     }
 
     #[inline]
     pub fn const_arg_has_type_clauses(
         self,
     ) -> impl Iterator<Item = PolyConstArgHasTypePredicate<'tcx>> {
-        self.0.0.caller_bounds.iter().filter_map(|c| c.as_const_arg_has_type_clause())
+        self.0.0.const_arg_has_type_clauses.iter().filter_map(|c| c.as_const_arg_has_type_clause())
     }
 
     #[inline]
     pub fn well_formed_clauses(self) -> impl Iterator<Item = PolyWellFormedPredicate<'tcx>> {
-        self.0.0.caller_bounds.iter().filter_map(|c| c.as_well_formed_clause())
+        self.0.0.well_formed_clauses.iter().filter_map(|c| c.as_well_formed_clause())
     }
 
     #[inline]
     pub fn const_evaluatable_clauses(
         self,
     ) -> impl Iterator<Item = PolyConstEvaluatablePredicate<'tcx>> {
-        self.0.0.caller_bounds.iter().filter_map(|c| c.as_const_evaluatable_clause())
+        self.0.0.const_evaluatable_clauses.iter().filter_map(|c| c.as_const_evaluatable_clause())
     }
 
     #[inline]
     pub fn host_effect_clauses(self) -> impl Iterator<Item = PolyHostEffectPredicate<'tcx>> {
-        self.0.0.caller_bounds.iter().filter_map(|c| c.as_host_effect_clause())
+        self.0.0.host_effect_clauses.iter().filter_map(|c| c.as_host_effect_clause())
     }
 
     /// Construct a trait environment with the given set of predicates.
     #[inline]
-    pub fn new(tcx: TyCtxt<'tcx>, caller_bounds: Clauses<'tcx>) -> Self {
-        tcx.mk_param_env(ParamEnvInner { caller_bounds })
+    pub fn from_iter(tcx: TyCtxt<'tcx>, clauses: impl Iterator<Item = Clause<'tcx>>) -> Self {
+        let mut trait_clauses = Vec::new();
+        let mut region_outlives_clauses = Vec::new();
+        let mut type_outlives_clauses = Vec::new();
+        let mut projection_clauses = Vec::new();
+        let mut const_arg_has_type_clauses = Vec::new();
+        let mut well_formed_clauses = Vec::new();
+        let mut const_evaluatable_clauses = Vec::new();
+        let mut host_effect_clauses = Vec::new();
+
+        for clause in clauses {
+            match clause.kind().skip_binder() {
+                ClauseKind::Trait(..) => trait_clauses.push(clause),
+                ClauseKind::RegionOutlives(..) => region_outlives_clauses.push(clause),
+                ClauseKind::TypeOutlives(..) => type_outlives_clauses.push(clause),
+                ClauseKind::Projection(..) => projection_clauses.push(clause),
+                ClauseKind::ConstArgHasType(..) => const_arg_has_type_clauses.push(clause),
+                ClauseKind::WellFormed(..) => well_formed_clauses.push(clause),
+                ClauseKind::ConstEvaluatable(..) => const_evaluatable_clauses.push(clause),
+                ClauseKind::HostEffect(..) => host_effect_clauses.push(clause),
+            }
+        }
+
+        tcx.mk_param_env(ParamEnvInner {
+            trait_clauses: tcx.mk_clauses(&trait_clauses),
+            region_outlives_clauses: tcx.mk_clauses(&region_outlives_clauses),
+            type_outlives_clauses: tcx.mk_clauses(&type_outlives_clauses),
+            projection_clauses: tcx.mk_clauses(&projection_clauses),
+            const_arg_has_type_clauses: tcx.mk_clauses(&const_arg_has_type_clauses),
+            well_formed_clauses: tcx.mk_clauses(&well_formed_clauses),
+            const_evaluatable_clauses: tcx.mk_clauses(&const_evaluatable_clauses),
+            host_effect_clauses: tcx.mk_clauses(&host_effect_clauses),
+        })
     }
 
     /// Creates a pair of param-env and value for use in queries.
@@ -1065,35 +1139,35 @@ impl<'tcx> ParamEnv<'tcx> {
 
 impl<'tcx> rustc_type_ir::inherent::ParamEnv<TyCtxt<'tcx>> for ParamEnv<'tcx> {
     fn trait_clauses(self) -> impl Iterator<Item = Clause<'tcx>> {
-        self.all_clauses().filter(|c| c.as_trait_clause().is_some())
+        self.0.0.trait_clauses.iter()
     }
 
     fn region_outlives_clauses(self) -> impl Iterator<Item = Clause<'tcx>> {
-        self.all_clauses().filter(|c| c.as_region_outlives_clause().is_some())
+        self.0.0.region_outlives_clauses.iter()
     }
 
     fn type_outlives_clauses(self) -> impl Iterator<Item = Clause<'tcx>> {
-        self.all_clauses().filter(|c| c.as_type_outlives_clause().is_some())
+        self.0.0.type_outlives_clauses.iter()
     }
 
     fn projection_clauses(self) -> impl Iterator<Item = Clause<'tcx>> {
-        self.all_clauses().filter(|c| c.as_projection_clause().is_some())
+        self.0.0.projection_clauses.iter()
     }
 
     fn const_arg_has_type_clauses(self) -> impl Iterator<Item = Clause<'tcx>> {
-        self.all_clauses().filter(|c| c.as_const_arg_has_type_clause().is_some())
+        self.0.0.const_arg_has_type_clauses.iter()
     }
 
     fn well_formed_clauses(self) -> impl Iterator<Item = Clause<'tcx>> {
-        self.all_clauses().filter(|c| c.as_well_formed_clause().is_some())
+        self.0.0.well_formed_clauses.iter()
     }
 
     fn const_evaluatable_clauses(self) -> impl Iterator<Item = Clause<'tcx>> {
-        self.all_clauses().filter(|c| c.as_const_evaluatable_clause().is_some())
+        self.0.0.const_evaluatable_clauses.iter()
     }
 
     fn host_effect_clauses(self) -> impl Iterator<Item = Clause<'tcx>> {
-        self.all_clauses().filter(|c| c.as_host_effect_clause().is_some())
+        self.0.0.host_effect_clauses.iter()
     }
 }
 

compiler/rustc_trait_selection/src/traits/auto_trait.rs

@@ -319,15 +319,12 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                 .map(|c| c.as_predicate())
                 .chain(user_computed_preds.iter().cloned());
             let normalized_preds = elaborate(tcx, computed_preds);
-            new_env = ty::ParamEnv::new(
-                tcx,
-                tcx.mk_clauses_from_iter(normalized_preds.filter_map(|p| p.as_clause())),
-            );
+            new_env = ty::ParamEnv::from_iter(tcx, normalized_preds.filter_map(|p| p.as_clause()));
         }
 
-        let final_user_env = ty::ParamEnv::new(
+        let final_user_env = ty::ParamEnv::from_iter(
             tcx,
-            tcx.mk_clauses_from_iter(user_computed_preds.into_iter().filter_map(|p| p.as_clause())),
+            user_computed_preds.into_iter().filter_map(|p| p.as_clause()),
         );
         debug!(
             "evaluate_nested_obligations(ty={:?}, trait_did={:?}): succeeded with '{:?}' \

compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs

@@ -612,7 +612,7 @@ fn receiver_is_dispatchable<'tcx>(
 
         normalize_param_env_or_error(
             tcx,
-            ty::ParamEnv::new(tcx, tcx.mk_clauses(&predicates)),
+            ty::ParamEnv::from_iter(tcx, predicates.iter().copied()),
             ObligationCause::dummy_with_span(tcx.def_span(method.def_id)),
         )
     };

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -414,7 +414,7 @@ pub fn normalize_param_env_or_error<'tcx>(
 
     debug!("normalize_param_env_or_error: elaborated-predicates={:?}", predicates);
 
-    let elaborated_env = ty::ParamEnv::new(tcx, tcx.mk_clauses(&predicates));
+    let elaborated_env = ty::ParamEnv::from_iter(tcx, predicates.iter().copied());
     if !elaborated_env.has_aliases() {
         return elaborated_env;
     }
@@ -461,7 +461,7 @@ pub fn normalize_param_env_or_error<'tcx>(
     // here. I believe they should not matter, because we are ignoring TypeOutlives param-env
     // predicates here anyway. Keeping them here anyway because it seems safer.
     let outlives_env = non_outlives_predicates.iter().chain(&outlives_predicates).cloned();
-    let outlives_env = ty::ParamEnv::new(tcx, tcx.mk_clauses_from_iter(outlives_env));
+    let outlives_env = ty::ParamEnv::from_iter(tcx, outlives_env);
     let Ok(outlives_predicates) =
         do_normalize_predicates(tcx, cause, outlives_env, outlives_predicates)
     else {
@@ -474,7 +474,7 @@ pub fn normalize_param_env_or_error<'tcx>(
     let mut predicates = non_outlives_predicates;
     predicates.extend(outlives_predicates);
     debug!("normalize_param_env_or_error: final predicates={:?}", predicates);
-    ty::ParamEnv::new(tcx, tcx.mk_clauses(&predicates))
+    ty::ParamEnv::from_iter(tcx, predicates.iter().copied())
 }
 
 #[derive(Debug)]

compiler/rustc_ty_utils/src/ty.rs

@@ -163,7 +163,7 @@ fn param_env(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ParamEnv<'_> {
 
     let local_did = def_id.as_local();
 
-    let unnormalized_env = ty::ParamEnv::new(tcx, tcx.mk_clauses(&predicates));
+    let unnormalized_env = ty::ParamEnv::from_iter(tcx, predicates.iter().copied());
 
     let body_id = local_did.unwrap_or(CRATE_DEF_ID);
     let cause = traits::ObligationCause::misc(tcx.def_span(def_id), body_id);