Auto merge of #156869 - yotamofek:wip/rustdoc-bumpalo, r=<try>

[PERF EXPERIMENT] thread bumpalo through rustdoc

Author: bors

Cargo.lock

@@ -1,7 +1,10 @@
-pub use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet, FxHasher};
+use std::alloc::Global;
+
+pub use rustc_hash::{FxBuildHasher, FxHashSet, FxHasher};
 
 pub type StdEntry<'a, K, V> = std::collections::hash_map::Entry<'a, K, V>;
 
+pub type FxHashMap<K, V, A = Global> = std::collections::HashMap<K, V, FxBuildHasher, A>;
 pub type FxIndexMap<K, V> = indexmap::IndexMap<K, V, FxBuildHasher>;
 pub type FxIndexSet<V> = indexmap::IndexSet<V, FxBuildHasher>;
 pub type IndexEntry<'a, K, V> = indexmap::map::Entry<'a, K, V>;

compiler/rustc_data_structures/src/fx.rs

@@ -2,7 +2,9 @@
 //! ordering. This is a useful property for deterministic computations, such
 //! as required by the query system.
 
+use std::alloc::{Allocator, Global};
 use std::borrow::{Borrow, BorrowMut};
+use std::collections::HashMap;
 use std::collections::hash_map::{Entry, OccupiedError};
 use std::hash::Hash;
 use std::iter::{Product, Sum};
@@ -450,11 +452,11 @@ impl<V: Hash + Eq + StableHash> StableHash for UnordSet<V> {
 /// See [MCP 533](https://github.com/rust-lang/compiler-team/issues/533)
 /// for more information.
 #[derive(Debug, Eq, PartialEq, Clone, Encodable_NoContext, Decodable_NoContext)]
-pub struct UnordMap<K: Eq + Hash, V> {
-    inner: FxHashMap<K, V>,
+pub struct UnordMap<K: Eq + Hash, V, A: Allocator = Global> {
+    inner: HashMap<K, V, FxBuildHasher, A>,
 }
 
-impl<K: Eq + Hash, V> UnordCollection for UnordMap<K, V> {}
+impl<K: Eq + Hash, V, A: Allocator> UnordCollection for UnordMap<K, V, A> {}
 
 impl<K: Eq + Hash, V> const Default for UnordMap<K, V> {
     #[inline]
@@ -463,7 +465,7 @@ impl<K: Eq + Hash, V> const Default for UnordMap<K, V> {
     }
 }
 
-impl<K: Hash + Eq, V> Extend<(K, V)> for UnordMap<K, V> {
+impl<K: Hash + Eq, V, A: Allocator> Extend<(K, V)> for UnordMap<K, V, A> {
     #[inline]
     fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
         self.inner.extend(iter)
@@ -487,7 +489,19 @@ impl<K: Hash + Eq, V, I: Iterator<Item = (K, V)>> From<UnordItems<(K, V), I>> fo
 impl<K: Eq + Hash, V> UnordMap<K, V> {
     #[inline]
     pub fn with_capacity(capacity: usize) -> Self {
-        Self { inner: FxHashMap::with_capacity_and_hasher(capacity, Default::default()) }
+        Self::with_capacity_in(capacity, Global)
+    }
+}
+
+impl<K: Eq + Hash, V, A: Allocator> UnordMap<K, V, A> {
+    #[inline]
+    pub fn new_in(alloc: A) -> Self {
+        Self::with_capacity_in(0, alloc)
+    }
+
+    #[inline]
+    pub fn with_capacity_in(capacity: usize, alloc: A) -> Self {
+        Self { inner: HashMap::with_capacity_and_hasher_in(capacity, Default::default(), alloc) }
     }
 
     #[inline]
@@ -501,7 +515,7 @@ impl<K: Eq + Hash, V> UnordMap<K, V> {
     }
 
     #[inline]
-    pub fn try_insert(&mut self, k: K, v: V) -> Result<&mut V, OccupiedError<'_, K, V>> {
+    pub fn try_insert(&mut self, k: K, v: V) -> Result<&mut V, OccupiedError<'_, K, V, A>> {
         self.inner.try_insert(k, v)
     }
 
@@ -520,7 +534,7 @@ impl<K: Eq + Hash, V> UnordMap<K, V> {
     }
 
     #[inline]
-    pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
+    pub fn entry(&mut self, key: K) -> Entry<'_, K, V, A> {
         self.inner.entry(key)
     }
 

compiler/rustc_data_structures/src/unord.rs

@@ -40,6 +40,7 @@ pub static CRATES: &[&str] = &[
     "memchr",
     "minimal-lexical",
     "nom",
+    "num-conv",
     "pest",
     "pest_generator",
     "pest_meta",
@@ -61,6 +62,7 @@ pub static CRATES: &[&str] = &[
     "syn",
     "synstructure",
     "thiserror",
+    "time-core",
     "tinystr",
     "type-map",
     "typenum",

src/bootstrap/src/utils/proc_macro_deps.rs

@@ -10,8 +10,13 @@ path = "lib.rs"
 [dependencies]
 # tidy-alphabetical-start
 arrayvec = { version = "0.7", default-features = false }
-askama = { version = "0.16.0", default-features = false, features = ["alloc", "config", "derive"] }
+askama = { version = "0.16.0", default-features = false, features = [
+    "alloc",
+    "config",
+    "derive",
+] }
 base64 = "0.21.7"
+bumpalo = { version = "3", features = ["allocator_api"] }
 indexmap = { version = "2", features = ["serde"] }
 itertools = "0.12"
 minifier = { version = "0.3.5", default-features = false }
@@ -20,7 +25,9 @@ pulldown-cmark-escape = { version = "0.11.0", features = ["simd"] }
 regex = "1"
 rustdoc-json-types = { path = "../rustdoc-json-types" }
 serde = { version = "1.0", features = ["derive"] }
+serde_alloc = "0.1.0-alpha.3"
 serde_json = "1.0"
+serde_with = "3.20.0"
 smallvec = "1.8.1"
 stringdex = "=0.0.6"
 tempfile = "3"

src/librustdoc/Cargo.toml

@@ -0,0 +1,67 @@
+use std::alloc::Allocator;
+use std::marker::PhantomData;
+
+use serde_with::SerializeAs;
+
+#[macro_export]
+macro_rules! vec_in {
+    (in: $alloc:expr $(,)?) => (
+        ::std::vec::Vec::new_in($alloc)
+    );
+    (in: $alloc:expr, $elem:expr; $n:expr) => (
+        ::std::vec::from_elem_in($elem, $n, $alloc)
+    );
+    (in: $alloc:expr, $($x:expr),+ $(,)?) => ({
+        let alloc = $alloc;
+        let mut v = ::std::vec::Vec::with_capacity_in(
+            const { [$($crate::vec_in!(@count $x)),+].len() },
+            alloc,
+        );
+        $(v.push($x);)+
+        v
+    });
+    (@count $_x:expr) => { () };
+}
+
+pub(crate) trait FromIteratorWithAlloc<A: Allocator, E>: Sized {
+    fn from_iter_with_alloc<T>(iter: T, alloc: A) -> Self
+    where
+        T: IntoIterator<Item = E>;
+}
+
+impl<A: Allocator, E> FromIteratorWithAlloc<A, E> for Vec<E, A> {
+    fn from_iter_with_alloc<T>(iter: T, alloc: A) -> Self
+    where
+        T: IntoIterator<Item = E>,
+    {
+        let mut vec = Vec::new_in(alloc);
+        iter.into_iter().collect_into(&mut vec);
+        vec
+    }
+}
+
+pub(crate) trait CollectIn: Iterator {
+    fn collect_in<A: Allocator + Copy, B: FromIteratorWithAlloc<A, Self::Item>>(self, alloc: A) -> B
+    where
+        Self: Sized,
+    {
+        FromIteratorWithAlloc::from_iter_with_alloc(self, alloc)
+    }
+}
+
+impl<T> CollectIn for T where T: Iterator {}
+
+pub struct AsSlice<T>(PhantomData<fn() -> [T]>);
+
+impl<T, U, A> SerializeAs<Vec<T, A>> for AsSlice<U>
+where
+    U: SerializeAs<T>,
+    A: Allocator,
+{
+    fn serialize_as<S>(source: &Vec<T, A>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        <[U]>::serialize_as(source, serializer)
+    }
+}

src/librustdoc/alloc.rs

@@ -1,3 +1,5 @@
+use std::alloc::Allocator;
+
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet, IndexEntry};
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir as hir;
@@ -16,8 +18,8 @@ use crate::clean::{
 use crate::core::DocContext;
 
 #[instrument(level = "debug", skip(cx))]
-pub(crate) fn synthesize_auto_trait_impls<'tcx>(
-    cx: &mut DocContext<'tcx>,
+pub(crate) fn synthesize_auto_trait_impls<'tcx, A: Allocator + Copy>(
+    cx: &mut DocContext<'tcx, A>,
     item_def_id: DefId,
 ) -> Vec<clean::Item> {
     let tcx = cx.tcx;
@@ -60,8 +62,8 @@ pub(crate) fn synthesize_auto_trait_impls<'tcx>(
 }
 
 #[instrument(level = "debug", skip(cx, finder))]
-fn synthesize_auto_trait_impl<'tcx>(
-    cx: &mut DocContext<'tcx>,
+fn synthesize_auto_trait_impl<'tcx, A: Allocator + Copy>(
+    cx: &mut DocContext<'tcx, A>,
     ty: Ty<'tcx>,
     trait_def_id: DefId,
     typing_env: ty::TypingEnv<'tcx>,
@@ -142,8 +144,8 @@ enum DiscardPositiveImpls {
 }
 
 #[instrument(level = "debug", skip(cx, region_data, vid_to_region))]
-fn clean_param_env<'tcx>(
-    cx: &mut DocContext<'tcx>,
+fn clean_param_env<'tcx, A: Allocator + Copy>(
+    cx: &mut DocContext<'tcx, A>,
     item_def_id: DefId,
     param_env: ty::ParamEnv<'tcx>,
     region_data: RegionConstraintData<'tcx>,

src/librustdoc/clean/auto_trait.rs

@@ -1,3 +1,5 @@
+use std::alloc::Allocator;
+
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_hir as hir;
 use rustc_infer::infer::{DefineOpaqueTypes, InferOk, TyCtxtInferExt};
@@ -15,8 +17,8 @@ use crate::clean::{
 use crate::core::DocContext;
 
 #[instrument(level = "debug", skip(cx))]
-pub(crate) fn synthesize_blanket_impls(
-    cx: &mut DocContext<'_>,
+pub(crate) fn synthesize_blanket_impls<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
     item_def_id: DefId,
 ) -> Vec<clean::Item> {
     let tcx = cx.tcx;