more

Author: yotamofek

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

@@ -25,8 +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.1"
+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

@@ -235,32 +235,52 @@ pub(crate) fn load_attrs<'hir>(tcx: TyCtxt<'hir>, did: DefId) -> &'hir [hir::Att
     tcx.get_all_attrs(did)
 }
 
-pub(crate) fn item_relative_path(tcx: TyCtxt<'_>, def_id: DefId) -> Vec<Symbol> {
-    tcx.def_path(def_id).data.into_iter().filter_map(|elem| elem.data.get_opt_name()).collect()
+pub(crate) fn item_relative_path<A: Allocator + Copy>(
+    tcx: TyCtxt<'_>,
+    def_id: DefId,
+    alloc: A,
+) -> Vec<Symbol, A> {
+    let mut vec = Vec::new_in(alloc);
+    tcx.def_path(def_id)
+        .data
+        .into_iter()
+        .filter_map(|elem| elem.data.get_opt_name())
+        .collect_into(&mut vec);
+    vec
 }
 
 /// Get the public Rust path to an item. This is used to generate the URL to the item's page.
 ///
 /// In particular: we handle macro differently: if it's not a macro 2.0 oe a built-in macro, then
 /// it is generated at the top-level of the crate and its path will be `[crate_name, macro_name]`.
-pub(crate) fn get_item_path(tcx: TyCtxt<'_>, def_id: DefId, kind: ItemType) -> Vec<Symbol> {
+pub(crate) fn get_item_path<A: Allocator + Copy>(
+    tcx: TyCtxt<'_>,
+    def_id: DefId,
+    kind: ItemType,
+    alloc: A,
+) -> Vec<Symbol, A> {
     let crate_name = tcx.crate_name(def_id.krate);
-    let relative = item_relative_path(tcx, def_id);
+    let relative = item_relative_path(tcx, def_id, alloc);
 
+    let mut vec = Vec::new_in(alloc);
     if let ItemType::Macro = kind {
         // Check to see if it is a macro 2.0 or built-in macro
         // More information in <https://rust-lang.github.io/rfcs/1584-macros.html>.
         if matches!(
             CStore::from_tcx(tcx).load_macro_untracked(tcx, def_id),
             LoadedMacro::MacroDef { def, .. } if !def.macro_rules
         ) {
-            once(crate_name).chain(relative).collect()
+            once(crate_name).chain(relative).collect_into(&mut vec);
         } else {
-            vec![crate_name, *relative.last().expect("relative was empty")]
+            [crate_name, *relative.last().expect("relative was empty")]
+                .into_iter()
+                .collect_into(&mut vec);
         }
     } else {
-        once(crate_name).chain(relative).collect()
+        once(crate_name).chain(relative).collect_into(&mut vec);
     }
+
+    vec
 }
 
 /// Record an external fully qualified name in the external_paths cache.
@@ -280,7 +300,9 @@ pub(crate) fn record_extern_fqn<A: Allocator + Copy>(
         return;
     }
 
-    let item_path = get_item_path(cx.tcx, did, kind);
+    let alloc = *cx.cache.search_index.allocator();
+
+    let item_path = get_item_path(cx.tcx, did, kind, alloc);
 
     if did.is_local() {
         cx.cache.exact_paths.insert(did, item_path);