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

[PERF EXPERIMENT] thread bumpalo through rustdoc

Author: bors

Cargo.lock

@@ -373,9 +373,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.19.0"
+version = "3.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
 
 [[package]]
 name = "bytecheck"
@@ -4922,6 +4922,7 @@ dependencies = [
  "arrayvec",
  "askama",
  "base64",
+ "bumpalo",
  "expect-test",
  "indexmap",
  "itertools",
@@ -4931,6 +4932,7 @@ dependencies = [
  "regex",
  "rustdoc-json-types",
  "serde",
+ "serde_alloc",
  "serde_json",
  "sha2",
  "smallvec",
@@ -5181,6 +5183,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_alloc"
+version = "0.1.0-alpha.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "727f51fdf8729c8fbd227ab2a5745c54c76e8771c63ce1282fd9ba894a7eff78"
+dependencies = [
+ "serde_core",
+]
+
 [[package]]
 name = "serde_core"
 version = "1.0.228"

src/librustdoc/Cargo.toml

@@ -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,6 +25,7 @@ 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.1"
 serde_json = "1.0"
 smallvec = "1.8.1"
 stringdex = "=0.0.6"

src/librustdoc/clean/auto_trait.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/blanket_impl.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;

src/librustdoc/clean/inline.rs

@@ -1,5 +1,6 @@
 //! Support for inlining external documentation into the current AST.
 
+use std::alloc::Allocator;
 use std::iter::once;
 use std::sync::Arc;
 
@@ -38,15 +39,15 @@ use crate::formats::item_type::ItemType;
 ///
 /// The returned value is `None` if the definition could not be inlined,
 /// and `Some` of a vector of items if it was successfully expanded.
-pub(crate) fn try_inline(
-    cx: &mut DocContext<'_>,
+pub(crate) fn try_inline<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
     res: Res,
     name: Symbol,
     attrs: Option<(&[hir::Attribute], Option<LocalDefId>)>,
     visited: &mut DefIdSet,
 ) -> Option<Vec<clean::Item>> {
-    fn try_inline_inner(
-        cx: &mut DocContext<'_>,
+    fn try_inline_inner<A: Allocator + Copy>(
+        cx: &mut DocContext<'_, A>,
         kind: clean::ItemKind,
         did: DefId,
         name: Symbol,
@@ -178,8 +179,8 @@ pub(crate) fn try_inline(
     Some(ret)
 }
 
-pub(crate) fn try_inline_glob(
-    cx: &mut DocContext<'_>,
+pub(crate) fn try_inline_glob<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
     res: Res,
     current_mod: LocalModDefId,
     visited: &mut DefIdSet,
@@ -266,7 +267,11 @@ pub(crate) fn get_item_path(tcx: TyCtxt<'_>, def_id: DefId, kind: ItemType) -> V
 ///
 /// These names are used later on by HTML rendering to generate things like
 /// source links back to the original item.
-pub(crate) fn record_extern_fqn(cx: &mut DocContext<'_>, did: DefId, kind: ItemType) {
+pub(crate) fn record_extern_fqn<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
+    did: DefId,
+    kind: ItemType,
+) {
     if did.is_local() {
         if cx.cache.exact_paths.contains_key(&did) {
             return;
@@ -284,7 +289,10 @@ pub(crate) fn record_extern_fqn(cx: &mut DocContext<'_>, did: DefId, kind: ItemT
     }
 }
 
-pub(crate) fn build_trait(cx: &mut DocContext<'_>, did: DefId) -> clean::Trait {
+pub(crate) fn build_trait<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
+    did: DefId,
+) -> clean::Trait {
     let trait_items = cx
         .tcx
         .associated_items(did)
@@ -305,7 +313,10 @@ pub(crate) fn build_trait(cx: &mut DocContext<'_>, did: DefId) -> clean::Trait {
     clean::Trait { def_id: did, generics, items: trait_items, bounds: supertrait_bounds }
 }
 
-fn build_trait_alias(cx: &mut DocContext<'_>, did: DefId) -> clean::TraitAlias {
+fn build_trait_alias<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
+    did: DefId,
+) -> clean::TraitAlias {
     let generics = clean_ty_generics(cx, did);
     let (generics, mut bounds) = separate_self_bounds(generics);
 
@@ -318,7 +329,10 @@ fn build_trait_alias(cx: &mut DocContext<'_>, did: DefId) -> clean::TraitAlias {
     clean::TraitAlias { generics, bounds }
 }
 
-pub(super) fn build_function(cx: &mut DocContext<'_>, def_id: DefId) -> Box<clean::Function> {
+pub(super) fn build_function<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
+    def_id: DefId,
+) -> Box<clean::Function> {
     let sig = cx.tcx.fn_sig(def_id).instantiate_identity().skip_norm_wip();
     // The generics need to be cleaned before the signature.
     let mut generics = clean_ty_generics(cx, def_id);
@@ -349,14 +363,14 @@ pub(super) fn build_function(cx: &mut DocContext<'_>, def_id: DefId) -> Box<clea
     Box::new(clean::Function { decl, generics })
 }
 
-fn build_enum(cx: &mut DocContext<'_>, did: DefId) -> clean::Enum {
+fn build_enum<A: Allocator + Copy>(cx: &mut DocContext<'_, A>, did: DefId) -> clean::Enum {
     clean::Enum {
         generics: clean_ty_generics(cx, did),
         variants: cx.tcx.adt_def(did).variants().iter().map(|v| clean_variant_def(v, cx)).collect(),
     }
 }
 
-fn build_struct(cx: &mut DocContext<'_>, did: DefId) -> clean::Struct {
+fn build_struct<A: Allocator + Copy>(cx: &mut DocContext<'_, A>, did: DefId) -> clean::Struct {
     let variant = cx.tcx.adt_def(did).non_enum_variant();
 
     clean::Struct {
@@ -366,16 +380,16 @@ fn build_struct(cx: &mut DocContext<'_>, did: DefId) -> clean::Struct {
     }
 }
 
-fn build_union(cx: &mut DocContext<'_>, did: DefId) -> clean::Union {
+fn build_union<A: Allocator + Copy>(cx: &mut DocContext<'_, A>, did: DefId) -> clean::Union {
     let variant = cx.tcx.adt_def(did).non_enum_variant();
 
     let generics = clean_ty_generics(cx, did);
     let fields = variant.fields.iter().map(|x| clean_middle_field(x, cx)).collect();
     clean::Union { generics, fields }
 }
 
-fn build_type_alias(
-    cx: &mut DocContext<'_>,
+fn build_type_alias<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
     did: DefId,
     ret: &mut Vec<Item>,
 ) -> Box<clean::TypeAlias> {
@@ -392,8 +406,8 @@ fn build_type_alias(
 }
 
 /// Builds all inherent implementations of an ADT (struct/union/enum) or Trait item/path/reexport.
-pub(crate) fn build_impls(
-    cx: &mut DocContext<'_>,
+pub(crate) fn build_impls<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
     did: DefId,
     attrs: Option<(&[hir::Attribute], Option<LocalDefId>)>,
     ret: &mut Vec<clean::Item>,
@@ -452,8 +466,8 @@ pub(crate) fn merge_attrs(
 }
 
 /// Inline an `impl`, inherent or of a trait. The `did` must be for an `impl`.
-pub(crate) fn build_impl(
-    cx: &mut DocContext<'_>,
+pub(crate) fn build_impl<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
     did: DefId,
     attrs: Option<(&[hir::Attribute], Option<LocalDefId>)>,
     ret: &mut Vec<clean::Item>,
@@ -473,7 +487,7 @@ pub(crate) fn build_impl(
             .is_some_and(|stab| stab.is_unstable() && stab.feature == sym::rustc_private)
     };
     let document_compiler_internal = is_compiler_internal(LOCAL_CRATE.as_def_id());
-    let is_directly_public = |cx: &mut DocContext<'_>, did| {
+    let is_directly_public = |cx: &mut DocContext<'_, A>, did| {
         cx.cache.effective_visibilities.is_directly_public(tcx, did)
             && (document_compiler_internal || !is_compiler_internal(did))
     };
@@ -665,15 +679,19 @@ pub(crate) fn build_impl(
     ));
 }
 
-fn build_module(cx: &mut DocContext<'_>, did: DefId, visited: &mut DefIdSet) -> clean::Module {
+fn build_module<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
+    did: DefId,
+    visited: &mut DefIdSet,
+) -> clean::Module {
     let items = build_module_items(cx, did, visited, &mut FxHashSet::default(), None, None);
 
     let span = clean::Span::new(cx.tcx.def_span(did));
     clean::Module { items, span }
 }
 
-fn build_module_items(
-    cx: &mut DocContext<'_>,
+fn build_module_items<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
     did: DefId,
     visited: &mut DefIdSet,
     inlined_names: &mut FxHashSet<(ItemType, Symbol)>,
@@ -755,7 +773,10 @@ pub(crate) fn print_inlined_const(tcx: TyCtxt<'_>, did: DefId) -> String {
     }
 }
 
-fn build_const_item(cx: &mut DocContext<'_>, def_id: DefId) -> clean::Constant {
+fn build_const_item<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
+    def_id: DefId,
+) -> clean::Constant {
     let mut generics = clean_ty_generics(cx, def_id);
     clean::simplify::move_bounds_to_generic_parameters(&mut generics);
     let ty = clean_middle_ty(
@@ -767,7 +788,11 @@ fn build_const_item(cx: &mut DocContext<'_>, def_id: DefId) -> clean::Constant {
     clean::Constant { generics, type_: ty, kind: clean::ConstantKind::Extern { def_id } }
 }
 
-fn build_static(cx: &mut DocContext<'_>, did: DefId, mutable: bool) -> clean::Static {
+fn build_static<A: Allocator + Copy>(
+    cx: &mut DocContext<'_, A>,
+    did: DefId,
+    mutable: bool,
+) -> clean::Static {
     clean::Static {
         type_: Box::new(clean_middle_ty(
             ty::Binder::dummy(cx.tcx.type_of(did).instantiate_identity().skip_norm_wip()),
@@ -829,7 +854,7 @@ fn separate_self_bounds(mut g: clean::Generics) -> (clean::Generics, Vec<clean::
     (g, ty_bounds)
 }
 
-pub(crate) fn record_extern_trait(cx: &mut DocContext<'_>, did: DefId) {
+pub(crate) fn record_extern_trait<A: Allocator + Copy>(cx: &mut DocContext<'_, A>, did: DefId) {
     if did.is_local()
         || cx.external_traits.contains_key(&did)
         || cx.active_extern_traits.contains(&did)