Auto merge of rust-lang#139576 - davidtwco:paramenv-multiple-fields, r=<try>

split `ParamEnv::caller_bounds` into multiple fields

This patch splits `ParamEnv::caller_bounds` into multiple fields, one for each `ClauseKind`. This is intended to be a performance optimisation, avoiding unnecessary iteration over large `ParamEnv`s when most kinds of clauses aren't relevant in any given context.

I make this change in three steps (reflected in the commits):

1. Changing the interface of `ParamEnv`
    - Replace `ParamEnv::caller_bounds` with functions returning iterators over specific kinds of clause, and then updating all users. A `ParamEnv::all_clauses` function, identical in behaviour to `ParamEnv::caller_bounds` remains for the handful of cases where iteration over all clauses is desirable.
2. Interning `ParamEnv`
    - In anticipation of changing the internals of `ParamEnv`, to avoid the type growing and to keep it `Copy`, `ParamEnv` is interned, becoming a pointer to `ParamEnvInner`.
3. Changing the internals of `ParamEnv`
    - Replacing the `caller_bounds` field with a field for each type of clause and updating the creation of `ParamEnv` to partition a sequence of `Clause`s into the appropriate fields.

This is intended to help improve the performance of rust-lang#137944, which results in many new predicates in the `ParamEnv`, and in particular, lots of new host effect predicates which can't be fast-path'd away. As part of that work, I've experimented with variations on this patch which had worse performance:

- Uninterned `ParamEnv`
- `Box<[Clause<'tcx>]>` fields rather than `Clauses<'tcx>`
- Box<[SpecificPredicateType<'tcx>]>` fields rather than `Clauses<'tcx>`

r? types

Author: bors

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_codegen_cranelift/src/abi/mod.rs

@@ -394,7 +394,7 @@ pub(crate) fn codegen_terminator_call<'tcx>(
     let instance = if let ty::FnDef(def_id, fn_args) = *func.layout().ty.kind() {
         let instance = ty::Instance::expect_resolve(
             fx.tcx,
-            ty::TypingEnv::fully_monomorphized(),
+            ty::TypingEnv::fully_monomorphized(fx.tcx),
             def_id,
             fn_args,
             source_info.span,

compiler/rustc_codegen_cranelift/src/base.rs

@@ -679,7 +679,7 @@ fn codegen_stmt<'tcx>(
                             let func_ref = fx.get_function_ref(
                                 Instance::resolve_for_fn_ptr(
                                     fx.tcx,
-                                    ty::TypingEnv::fully_monomorphized(),
+                                    ty::TypingEnv::fully_monomorphized(fx.tcx),
                                     def_id,
                                     args,
                                 )
@@ -730,8 +730,10 @@ fn codegen_stmt<'tcx>(
 
                     fn is_wide_ptr<'tcx>(fx: &FunctionCx<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool {
                         ty.builtin_deref(true).is_some_and(|pointee_ty| {
-                            fx.tcx
-                                .type_has_metadata(pointee_ty, ty::TypingEnv::fully_monomorphized())
+                            fx.tcx.type_has_metadata(
+                                pointee_ty,
+                                ty::TypingEnv::fully_monomorphized(fx.tcx),
+                            )
                         })
                     }
 
@@ -862,7 +864,7 @@ fn codegen_stmt<'tcx>(
                         NullOp::OffsetOf(fields) => fx
                             .tcx
                             .offset_of_subfield(
-                                ty::TypingEnv::fully_monomorphized(),
+                                ty::TypingEnv::fully_monomorphized(fx.tcx),
                                 layout,
                                 fields.iter(),
                             )

compiler/rustc_codegen_cranelift/src/common.rs

@@ -71,7 +71,7 @@ fn clif_type_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<types::Typ
         },
         ty::FnPtr(..) => pointer_ty(tcx),
         ty::RawPtr(pointee_ty, _) | ty::Ref(_, pointee_ty, _) => {
-            if tcx.type_has_metadata(*pointee_ty, ty::TypingEnv::fully_monomorphized()) {
+            if tcx.type_has_metadata(*pointee_ty, ty::TypingEnv::fully_monomorphized(tcx)) {
                 return None;
             } else {
                 pointer_ty(tcx)
@@ -91,7 +91,7 @@ fn clif_pair_type_from_ty<'tcx>(
             (clif_type_from_ty(tcx, types[0])?, clif_type_from_ty(tcx, types[1])?)
         }
         ty::RawPtr(pointee_ty, _) | ty::Ref(_, pointee_ty, _) => {
-            if tcx.type_has_metadata(*pointee_ty, ty::TypingEnv::fully_monomorphized()) {
+            if tcx.type_has_metadata(*pointee_ty, ty::TypingEnv::fully_monomorphized(tcx)) {
                 (pointer_ty(tcx), pointer_ty(tcx))
             } else {
                 return None;
@@ -327,7 +327,7 @@ impl<'tcx> rustc_abi::HasDataLayout for FunctionCx<'_, '_, 'tcx> {
 
 impl<'tcx> layout::HasTypingEnv<'tcx> for FunctionCx<'_, '_, 'tcx> {
     fn typing_env(&self) -> ty::TypingEnv<'tcx> {
-        ty::TypingEnv::fully_monomorphized()
+        ty::TypingEnv::fully_monomorphized(self.tcx)
     }
 }
 
@@ -344,7 +344,7 @@ impl<'tcx> FunctionCx<'_, '_, 'tcx> {
     {
         self.instance.instantiate_mir_and_normalize_erasing_regions(
             self.tcx,
-            ty::TypingEnv::fully_monomorphized(),
+            ty::TypingEnv::fully_monomorphized(self.tcx),
             ty::EarlyBinder::bind(value),
         )
     }
@@ -490,7 +490,7 @@ impl<'tcx> rustc_abi::HasDataLayout for FullyMonomorphizedLayoutCx<'tcx> {
 
 impl<'tcx> layout::HasTypingEnv<'tcx> for FullyMonomorphizedLayoutCx<'tcx> {
     fn typing_env(&self) -> ty::TypingEnv<'tcx> {
-        ty::TypingEnv::fully_monomorphized()
+        ty::TypingEnv::fully_monomorphized(self.0)
     }
 }
 

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -78,7 +78,7 @@ pub(crate) fn eval_mir_constant<'tcx>(
     let cv = fx.monomorphize(constant.const_);
     // This cannot fail because we checked all required_consts in advance.
     let val = cv
-        .eval(fx.tcx, ty::TypingEnv::fully_monomorphized(), constant.span)
+        .eval(fx.tcx, ty::TypingEnv::fully_monomorphized(fx.tcx), constant.span)
         .expect("erroneous constant missed by mono item collection");
     (val, cv.ty())
 }
@@ -267,9 +267,9 @@ fn data_id_for_static(
         assert!(!definition);
         assert!(!tcx.is_mutable_static(def_id));
 
-        let ty = instance.ty(tcx, ty::TypingEnv::fully_monomorphized());
+        let ty = instance.ty(tcx, ty::TypingEnv::fully_monomorphized(tcx));
         let align = tcx
-            .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty))
+            .layout_of(ty::TypingEnv::fully_monomorphized(tcx).as_query_input(ty))
             .unwrap()
             .align
             .abi

compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs

@@ -210,7 +210,7 @@ impl DebugContext {
 
         type_names::push_generic_params(
             tcx,
-            tcx.normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), args),
+            tcx.normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(tcx), args),
             &mut name,
         );
 
@@ -275,9 +275,10 @@ impl DebugContext {
         let span = tcx.def_span(def_id);
         let (file_id, line, _column) = self.get_span_loc(tcx, span, span);
 
-        let static_type = Instance::mono(tcx, def_id).ty(tcx, ty::TypingEnv::fully_monomorphized());
+        let static_type =
+            Instance::mono(tcx, def_id).ty(tcx, ty::TypingEnv::fully_monomorphized(tcx));
         let static_layout = tcx
-            .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(static_type))
+            .layout_of(ty::TypingEnv::fully_monomorphized(tcx).as_query_input(static_type))
             .unwrap();
         // FIXME use the actual type layout
         let type_id = self.debug_type(tcx, type_dbg, static_type);

compiler/rustc_codegen_cranelift/src/debuginfo/types.rs

@@ -129,7 +129,7 @@ impl DebugContext {
 
         let name = type_names::compute_debuginfo_type_name(tcx, ptr_type, true);
 
-        if !tcx.type_has_metadata(ptr_type, ty::TypingEnv::fully_monomorphized()) {
+        if !tcx.type_has_metadata(ptr_type, ty::TypingEnv::fully_monomorphized(tcx)) {
             let pointer_type_id =
                 self.dwarf.unit.add(self.dwarf.unit.root(), gimli::DW_TAG_pointer_type);
             let pointer_entry = self.dwarf.unit.get_mut(pointer_type_id);

compiler/rustc_codegen_cranelift/src/inline_asm.rs

@@ -92,7 +92,7 @@ pub(crate) fn codegen_inline_asm_terminator<'tcx>(
                 if let ty::FnDef(def_id, args) = *const_.ty().kind() {
                     let instance = ty::Instance::resolve_for_fn_ptr(
                         fx.tcx,
-                        ty::TypingEnv::fully_monomorphized(),
+                        ty::TypingEnv::fully_monomorphized(fx.tcx),
                         def_id,
                         args,
                     )
@@ -225,11 +225,11 @@ pub(crate) fn codegen_naked_asm<'tcx>(
             InlineAsmOperand::Const { ref value } => {
                 let cv = instance.instantiate_mir_and_normalize_erasing_regions(
                     tcx,
-                    ty::TypingEnv::fully_monomorphized(),
+                    ty::TypingEnv::fully_monomorphized(tcx),
                     ty::EarlyBinder::bind(value.const_),
                 );
                 let const_value = cv
-                    .eval(tcx, ty::TypingEnv::fully_monomorphized(), value.span)
+                    .eval(tcx, ty::TypingEnv::fully_monomorphized(tcx), value.span)
                     .expect("erroneous constant missed by mono item collection");
 
                 let value = rustc_codegen_ssa::common::asm_const_to_str(
@@ -248,13 +248,13 @@ pub(crate) fn codegen_naked_asm<'tcx>(
 
                 let const_ = instance.instantiate_mir_and_normalize_erasing_regions(
                     tcx,
-                    ty::TypingEnv::fully_monomorphized(),
+                    ty::TypingEnv::fully_monomorphized(tcx),
                     ty::EarlyBinder::bind(value.const_),
                 );
                 if let ty::FnDef(def_id, args) = *const_.ty().kind() {
                     let instance = ty::Instance::resolve_for_fn_ptr(
                         tcx,
-                        ty::TypingEnv::fully_monomorphized(),
+                        ty::TypingEnv::fully_monomorphized(tcx),
                         def_id,
                         args,
                     )

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -682,7 +682,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
                     .tcx
                     .check_validity_requirement((
                         requirement,
-                        ty::TypingEnv::fully_monomorphized().as_query_input(ty),
+                        ty::TypingEnv::fully_monomorphized(fx.tcx).as_query_input(ty),
                     ))
                     .expect("expect to have layout during codegen");
 
@@ -743,7 +743,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let const_val = fx
                 .tcx
                 .const_eval_instance(
-                    ty::TypingEnv::fully_monomorphized(),
+                    ty::TypingEnv::fully_monomorphized(fx.tcx),
                     instance,
                     source_info.span,
                 )