Auto merge of #417 - zakarumych:master, r=Amanieu

Add support for allocator-api2

This change allows using hashbrown with other crates that support `allocator-api2`.
It opens possibility for any allocator that supports `allocator-api2` to be used with `hashbrown`.

`allocator-api2` mimics types and functions of unstable `allocator-api` feature but works on stable.
`hashbrown` will be using `allocator-api2` only when `"nightly" feature is not enabled.

Typical use-case for `allocator-api2` is to use it both with and without `"nightly" feature, however `hashbrown` is special-case since it is built as part of `std` and `allocator-api2` is not ready for this.

If fitzgen/bumpalo#201 is accepted, explicit support for `bumpalo` would be obsolete.

*caveat*: Either `"nightly"`, `"allocator-api2"` or both features should be enabled for `hashbrown` to compile.

Author: bors

.github/workflows/rust.yml

@@ -50,7 +50,7 @@ jobs:
           thumbv6m-none-eabi,
           x86_64-pc-windows-gnu,
         ]
-        channel: [1.61.0, nightly]
+        channel: [1.63.0, nightly]
         include:
         - os: macos-latest
           target: x86_64-apple-darwin
@@ -60,13 +60,13 @@ jobs:
           channel: nightly
         - os: macos-latest
           target: x86_64-apple-darwin
-          channel: 1.61.0
+          channel: 1.63.0
         - os: windows-latest
           target: x86_64-pc-windows-msvc
-          channel: 1.61.0
+          channel: 1.63.0
         - os: ubuntu-latest
           target: x86_64-unknown-linux-gnu
-          channel: 1.61.0
+          channel: 1.63.0
         - os: ubuntu-latest
           target: x86_64-unknown-linux-gnu
           channel: beta

CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+### Added
+
+- Support for `allocator-api2` crate
+  for interfacing with custom allocators on stable.
+
+### Changed
+
+- Bumped MSRV to 1.63.0.
+
+### Removed
+
+- Support for `bumpalo` as an allocator with custom wrapper.
+  Use `allocator-api2` feature in `bumpalo` to use it as an allocator
+  for `hashbrown` collections.
+
 ## [v0.13.2] - 2023-01-12
 
 ### Fixed

Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["hash", "no_std", "hashmap", "swisstable"]
 categories = ["data-structures", "no-std"]
 exclude = [".github", "/ci/*"]
 edition = "2021"
-rust-version = "1.61.0"
+rust-version = "1.63.0"
 
 [dependencies]
 # For the default hasher
@@ -25,8 +25,8 @@ core = { version = "1.0.0", optional = true, package = "rustc-std-workspace-core
 compiler_builtins = { version = "0.1.2", optional = true }
 alloc = { version = "1.0.0", optional = true, package = "rustc-std-workspace-alloc" }
 
-# Optional support for bumpalo
-bumpalo = { version = "3.5.0", optional = true }
+# Support for allocators that use allocator-api2
+allocator-api2 = { version = "0.2.9", optional = true, default-features = false, features = ["alloc"] }
 
 [dev-dependencies]
 lazy_static = "1.4"
@@ -35,11 +35,13 @@ rayon = "1.0"
 fnv = "1.0.7"
 serde_test = "1.0"
 doc-comment = "0.3.1"
+bumpalo = "3.6.0"
 
 [features]
-default = ["ahash", "inline-more"]
+default = ["ahash", "inline-more", "allocator-api2"]
+
+nightly = ["allocator-api2?/nightly", "bumpalo/allocator_api"]
 
-nightly = []
 rustc-internal-api = []
 rustc-dep-of-std = [
     "nightly",

README.md

@@ -4,7 +4,7 @@ hashbrown
 [![Build Status](https://github.com/rust-lang/hashbrown/actions/workflows/rust.yml/badge.svg)](https://github.com/rust-lang/hashbrown/actions)
 [![Crates.io](https://img.shields.io/crates/v/hashbrown.svg)](https://crates.io/crates/hashbrown)
 [![Documentation](https://docs.rs/hashbrown/badge.svg)](https://docs.rs/hashbrown)
-[![Rust](https://img.shields.io/badge/rust-1.61.0%2B-blue.svg?maxAge=3600)](https://github.com/rust-lang/hashbrown)
+[![Rust](https://img.shields.io/badge/rust-1.63.0%2B-blue.svg?maxAge=3600)](https://github.com/rust-lang/hashbrown)
 
 This crate is a Rust port of Google's high-performance [SwissTable] hash
 map, adapted to make it a drop-in replacement for Rust's standard `HashMap`
@@ -105,8 +105,8 @@ This crate has the following Cargo features:
 - `raw`: Enables access to the experimental and unsafe `RawTable` API.
 - `inline-more`: Adds inline hints to most functions, improving run-time performance at the cost
   of compilation time. (enabled by default)
-- `bumpalo`: Provides a `BumpWrapper` type which allows `bumpalo` to be used for memory allocation.
 - `ahash`: Compiles with ahash as default hasher. (enabled by default)
+- `allocator-api2`: Enables support for allocators that support `allocator-api2`. (enabled by default)
 
 ## License
 

ci/run.sh

@@ -9,7 +9,7 @@ if [ "${NO_STD}" = "1" ]; then
     FEATURES="rustc-internal-api"
     OP="build"
 else
-    FEATURES="rustc-internal-api,serde,rayon,raw,bumpalo"
+    FEATURES="rustc-internal-api,serde,rayon,raw"
     OP="test"
 fi
 if [ "${CHANNEL}" = "nightly" ]; then

ci/tools.sh

@@ -30,7 +30,7 @@ if retry rustup component add rustfmt ; then
 fi
 
 if retry rustup component add clippy ; then
-    cargo clippy --all --tests --features serde,rayon,bumpalo -- -D clippy::all
+    cargo clippy --all --tests --features serde,rayon -- -D clippy::all
     cargo clippy --all --tests --features raw -- -D clippy::all
 fi
 

src/lib.rs

@@ -164,21 +164,3 @@ pub enum TryReserveError {
         layout: alloc::alloc::Layout,
     },
 }
-
-/// Wrapper around `Bump` which allows it to be used as an allocator for
-/// `HashMap`, `HashSet` and `RawTable`.
-///
-/// `Bump` can be used directly without this wrapper on nightly if you enable
-/// the `allocator-api` feature of the `bumpalo` crate.
-#[cfg(feature = "bumpalo")]
-#[derive(Clone, Copy, Debug)]
-pub struct BumpWrapper<'a>(pub &'a bumpalo::Bump);
-
-#[cfg(feature = "bumpalo")]
-#[test]
-fn test_bumpalo() {
-    use bumpalo::Bump;
-    let bump = Bump::new();
-    let mut map = HashMap::new_in(BumpWrapper(&bump));
-    map.insert(0, 1);
-}

src/map.rs

@@ -368,13 +368,13 @@ impl<K, V, A: Allocator + Clone> HashMap<K, V, DefaultHashBuilder, A> {
     /// # Examples
     ///
     /// ```
-    /// # #[cfg(feature = "bumpalo")]
+    /// # #[cfg(feature = "nightly")]
     /// # fn test() {
-    /// use hashbrown::{HashMap, BumpWrapper};
+    /// use hashbrown::HashMap;
     /// use bumpalo::Bump;
     ///
     /// let bump = Bump::new();
-    /// let mut map = HashMap::new_in(BumpWrapper(&bump));
+    /// let mut map = HashMap::new_in(&bump);
     ///
     /// // The created HashMap holds none elements
     /// assert_eq!(map.len(), 0);
@@ -390,7 +390,7 @@ impl<K, V, A: Allocator + Clone> HashMap<K, V, DefaultHashBuilder, A> {
     /// assert!(map.capacity() > 1);
     /// # }
     /// # fn main() {
-    /// #     #[cfg(feature = "bumpalo")]
+    /// #     #[cfg(feature = "nightly")]
     /// #     test()
     /// # }
     /// ```
@@ -419,13 +419,13 @@ impl<K, V, A: Allocator + Clone> HashMap<K, V, DefaultHashBuilder, A> {
     /// # Examples
     ///
     /// ```
-    /// # #[cfg(feature = "bumpalo")]
+    /// # #[cfg(feature = "nightly")]
     /// # fn test() {
-    /// use hashbrown::{HashMap, BumpWrapper};
+    /// use hashbrown::HashMap;
     /// use bumpalo::Bump;
     ///
     /// let bump = Bump::new();
-    /// let mut map = HashMap::with_capacity_in(5, BumpWrapper(&bump));
+    /// let mut map = HashMap::with_capacity_in(5, &bump);
     ///
     /// // The created HashMap holds none elements
     /// assert_eq!(map.len(), 0);
@@ -446,7 +446,7 @@ impl<K, V, A: Allocator + Clone> HashMap<K, V, DefaultHashBuilder, A> {
     /// assert_eq!(map.capacity(), empty_map_capacity)
     /// # }
     /// # fn main() {
-    /// #     #[cfg(feature = "bumpalo")]
+    /// #     #[cfg(feature = "nightly")]
     /// #     test()
     /// # }
     /// ```

src/raw/alloc.rs

@@ -1,5 +1,9 @@
 pub(crate) use self::inner::{do_alloc, Allocator, Global};
 
+// Nightly-case.
+// Use unstable `allocator_api` feature.
+// This is compatible with `allocator-api2` which can be enabled or not.
+// This is used when building for `std`.
 #[cfg(feature = "nightly")]
 mod inner {
     use crate::alloc::alloc::Layout;
@@ -13,22 +17,38 @@ mod inner {
             Err(_) => Err(()),
         }
     }
+}
 
-    #[cfg(feature = "bumpalo")]
-    unsafe impl Allocator for crate::BumpWrapper<'_> {
-        #[inline]
-        fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, core::alloc::AllocError> {
-            match self.0.try_alloc_layout(layout) {
-                Ok(ptr) => Ok(NonNull::slice_from_raw_parts(ptr, layout.size())),
-                Err(_) => Err(core::alloc::AllocError),
-            }
+// Basic non-nightly case.
+// This uses `allocator-api2` enabled by default.
+// If any crate enables "nightly" in `allocator-api2`,
+// this will be equivalent to the nightly case,
+// since `allocator_api2::alloc::Allocator` would be re-export of
+// `core::alloc::Allocator`.
+#[cfg(all(not(feature = "nightly"), feature = "allocator-api2"))]
+mod inner {
+    use crate::alloc::alloc::Layout;
+    pub use allocator_api2::alloc::{Allocator, Global};
+    use core::ptr::NonNull;
+
+    #[allow(clippy::map_err_ignore)]
+    pub(crate) fn do_alloc<A: Allocator>(alloc: &A, layout: Layout) -> Result<NonNull<u8>, ()> {
+        match alloc.allocate(layout) {
+            Ok(ptr) => Ok(ptr.cast()),
+            Err(_) => Err(()),
         }
-        #[inline]
-        unsafe fn deallocate(&self, _ptr: NonNull<u8>, _layout: Layout) {}
     }
 }
 
-#[cfg(not(feature = "nightly"))]
+// No-defaults case.
+// When building with default-features turned off and
+// neither `nightly` nor `allocator-api2` is enabled,
+// this will be used.
+// Making it impossible to use any custom allocator with collections defined
+// in this crate.
+// Any crate in build-tree can enable `allocator-api2`,
+// or `nightly` without disturbing users that don't want to use it.
+#[cfg(not(any(feature = "nightly", feature = "allocator-api2")))]
 mod inner {
     use crate::alloc::alloc::{alloc, dealloc, Layout};
     use core::ptr::NonNull;
@@ -41,6 +61,7 @@ mod inner {
 
     #[derive(Copy, Clone)]
     pub struct Global;
+
     unsafe impl Allocator for Global {
         #[inline]
         fn allocate(&self, layout: Layout) -> Result<NonNull<u8>, ()> {
@@ -51,6 +72,7 @@ mod inner {
             dealloc(ptr.as_ptr(), layout);
         }
     }
+
     impl Default for Global {
         #[inline]
         fn default() -> Self {
@@ -61,13 +83,4 @@ mod inner {
     pub(crate) fn do_alloc<A: Allocator>(alloc: &A, layout: Layout) -> Result<NonNull<u8>, ()> {
         alloc.allocate(layout)
     }
-
-    #[cfg(feature = "bumpalo")]
-    unsafe impl Allocator for crate::BumpWrapper<'_> {
-        #[allow(clippy::map_err_ignore)]
-        fn allocate(&self, layout: Layout) -> Result<NonNull<u8>, ()> {
-            self.0.try_alloc_layout(layout).map_err(|_| ())
-        }
-        unsafe fn deallocate(&self, _ptr: NonNull<u8>, _layout: Layout) {}
-    }
 }