Don't overuse the tcx arena

Author: Nadrieril

frontend/exporter/src/state.rs

@@ -357,7 +357,7 @@ impl ImplInfos {
                 .impl_trait_ref(did)
                 .map(|trait_ref| trait_ref.instantiate_identity())
                 .sinto(s),
-            clauses: predicates_defined_on(tcx, did).predicates.sinto(s),
+            clauses: predicates_defined_on(tcx, did).as_ref().sinto(s),
         }
     }
 }

frontend/exporter/src/traits.rs

@@ -7,7 +7,7 @@ mod utils;
 #[cfg(feature = "rustc")]
 pub use utils::{
     erase_and_norm, implied_predicates, predicates_defined_on, required_predicates, self_predicate,
-    ToPolyTraitRef,
+    Predicates, ToPolyTraitRef,
 };
 
 #[cfg(feature = "rustc")]
@@ -358,12 +358,11 @@ pub fn solve_item_implied_traits<'tcx, S: UnderOwnerState<'tcx>>(
 fn solve_item_traits_inner<'tcx, S: UnderOwnerState<'tcx>>(
     s: &S,
     generics: ty::GenericArgsRef<'tcx>,
-    predicates: ty::GenericPredicates<'tcx>,
+    predicates: utils::Predicates<'tcx>,
 ) -> Vec<ImplExpr> {
     let tcx = s.base().tcx;
     let typing_env = s.typing_env();
     predicates
-        .predicates
         .iter()
         .map(|(clause, _span)| *clause)
         .filter_map(|clause| clause.as_trait_clause())

frontend/exporter/src/traits/resolution.rs

@@ -11,9 +11,10 @@ use rustc_middle::traits::CodegenObligationError;
 use rustc_middle::ty::{self, *};
 use rustc_trait_selection::traits::ImplSource;
 
-use crate::{self_predicate, traits::utils::erase_and_norm};
-
-use super::utils::{implied_predicates, normalize_bound_val, required_predicates, ToPolyTraitRef};
+use super::utils::{
+    self, erase_and_norm, implied_predicates, normalize_bound_val, required_predicates,
+    self_predicate, ToPolyTraitRef,
+};
 
 #[derive(Debug, Clone)]
 pub enum PathChunk<'tcx> {
@@ -179,7 +180,6 @@ fn initial_search_predicates<'tcx>(
         }
         predicates.extend(
             required_predicates(tcx, def_id, add_drop)
-                .predicates
                 .iter()
                 .map(|(clause, _span)| *clause)
                 .filter_map(|clause| {
@@ -204,7 +204,6 @@ fn parents_trait_predicates<'tcx>(
 ) -> Vec<PolyTraitPredicate<'tcx>> {
     let self_trait_ref = pred.to_poly_trait_ref();
     implied_predicates(tcx, pred.def_id(), add_drop)
-        .predicates
         .iter()
         .map(|(clause, _span)| *clause)
         // Substitute with the `self` args so that the clause makes sense in the
@@ -342,8 +341,8 @@ impl<'tcx> PredicateSearcher<'tcx> {
         };
 
         // The bounds that hold on the associated type.
-        let item_bounds = implied_predicates(tcx, alias_ty.def_id, self.add_drop)
-            .predicates
+        let item_bounds = implied_predicates(tcx, alias_ty.def_id, self.add_drop);
+        let item_bounds = item_bounds
             .iter()
             .map(|(clause, _span)| *clause)
             .filter_map(|pred| pred.as_trait_clause())
@@ -642,13 +641,12 @@ impl<'tcx> PredicateSearcher<'tcx> {
     pub fn resolve_predicates(
         &mut self,
         generics: GenericArgsRef<'tcx>,
-        predicates: GenericPredicates<'tcx>,
+        predicates: utils::Predicates<'tcx>,
         // Call back into hax-related code to display a nice warning.
         warn: &impl Fn(&str),
     ) -> Result<Vec<ImplExpr<'tcx>>, String> {
         let tcx = self.tcx;
         predicates
-            .predicates
             .iter()
             .map(|(clause, _span)| *clause)
             .filter_map(|clause| clause.as_trait_clause())

frontend/exporter/src/traits/utils.rs

@@ -29,23 +29,21 @@
 use rustc_hir::def::DefKind;
 use rustc_middle::ty::*;
 use rustc_span::def_id::DefId;
-use rustc_span::DUMMY_SP;
+use rustc_span::{Span, DUMMY_SP};
+use std::borrow::Cow;
+
+pub type Predicates<'tcx> = Cow<'tcx, [(Clause<'tcx>, Span)]>;
 
 /// Returns a list of type predicates for the definition with ID `def_id`, including inferred
 /// lifetime constraints. This is the basic list of predicates we use for essentially all items.
-pub fn predicates_defined_on(tcx: TyCtxt<'_>, def_id: DefId) -> GenericPredicates<'_> {
-    let mut result = tcx.explicit_predicates_of(def_id);
+pub fn predicates_defined_on(tcx: TyCtxt<'_>, def_id: DefId) -> Predicates<'_> {
+    let mut result = Cow::Borrowed(tcx.explicit_predicates_of(def_id).predicates);
     let inferred_outlives = tcx.inferred_outlives_of(def_id);
     if !inferred_outlives.is_empty() {
-        let inferred_outlives_iter = inferred_outlives
-            .iter()
-            .map(|(clause, span)| ((*clause).upcast(tcx), *span));
-        result.predicates = tcx.arena.alloc_from_iter(
-            result
-                .predicates
-                .into_iter()
-                .copied()
-                .chain(inferred_outlives_iter),
+        result.to_mut().extend(
+            inferred_outlives
+                .iter()
+                .map(|(clause, span)| ((*clause).upcast(tcx), *span)),
         );
     }
     result
@@ -66,7 +64,7 @@ pub fn required_predicates<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: DefId,
     add_drop: bool,
-) -> GenericPredicates<'tcx> {
+) -> Predicates<'tcx> {
     use DefKind::*;
     let def_kind = tcx.def_kind(def_id);
     let mut predicates = match def_kind {
@@ -103,9 +101,7 @@ pub fn required_predicates<'tcx>(
                 .map(|ty| Binder::dummy(TraitRef::new(tcx, drop_trait, [ty])))
                 .map(|tref| tref.upcast(tcx))
                 .map(|clause| (clause, DUMMY_SP));
-            predicates.predicates = tcx
-                .arena
-                .alloc_from_iter(predicates.predicates.iter().copied().chain(extra_bounds));
+            predicates.to_mut().extend(extra_bounds);
         }
     }
     predicates
@@ -134,36 +130,26 @@ pub fn implied_predicates<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: DefId,
     add_drop: bool,
-) -> GenericPredicates<'tcx> {
+) -> Predicates<'tcx> {
     use DefKind::*;
     let parent = tcx.opt_parent(def_id);
     match tcx.def_kind(def_id) {
         // We consider all predicates on traits to be outputs
         Trait | TraitAlias => predicates_defined_on(tcx, def_id),
         AssocTy if matches!(tcx.def_kind(parent.unwrap()), Trait) => {
-            let mut predicates = GenericPredicates {
-                parent,
-                // `skip_binder` is for the GAT `EarlyBinder`
-                predicates: tcx.explicit_item_bounds(def_id).skip_binder(),
-                ..GenericPredicates::default()
-            };
+            // `skip_binder` is for the GAT `EarlyBinder`
+            let mut predicates = Cow::Borrowed(tcx.explicit_item_bounds(def_id).skip_binder());
             if add_drop {
                 // Add a `Drop` bound to the assoc item.
                 let drop_trait = tcx.lang_items().drop_trait().unwrap();
                 let ty =
                     Ty::new_projection(tcx, def_id, GenericArgs::identity_for_item(tcx, def_id));
                 let tref = Binder::dummy(TraitRef::new(tcx, drop_trait, [ty]));
-                predicates.predicates = tcx.arena.alloc_from_iter(
-                    predicates
-                        .predicates
-                        .iter()
-                        .copied()
-                        .chain([(tref.upcast(tcx), DUMMY_SP)]),
-                );
+                predicates.to_mut().push((tref.upcast(tcx), DUMMY_SP));
             }
             predicates
         }
-        _ => GenericPredicates::default(),
+        _ => Predicates::default(),
     }
 }
 

frontend/exporter/src/types/hir.rs

@@ -830,7 +830,6 @@ fn region_bounds_at_current_owner<'tcx, S: UnderOwnerState<'tcx>>(s: &S) -> Gene
             .instantiate_identity()
     } else {
         predicates_defined_on(tcx, s.owner_id())
-            .predicates
             .iter()
             .map(|(x, _span)| x)
             .copied()

frontend/exporter/src/types/ty.rs

@@ -1337,6 +1337,17 @@ pub struct GenericPredicates {
     pub predicates: Vec<(Clause, Span)>,
 }
 
+#[cfg(feature = "rustc")]
+impl<'tcx, S: UnderOwnerState<'tcx>> SInto<S, GenericPredicates>
+    for crate::traits::Predicates<'tcx>
+{
+    fn sinto(&self, s: &S) -> GenericPredicates {
+        GenericPredicates {
+            predicates: self.as_ref().sinto(s),
+        }
+    }
+}
+
 #[cfg(feature = "rustc")]
 impl<'tcx, S: UnderOwnerState<'tcx>, T1, T2> SInto<S, Binder<T2>> for ty::Binder<'tcx, T1>
 where