feat: Adopt custom AllocError type for Ralf-compatibility (#536)

Co-authored-by: Martin Taillefer <mataille@microsoft.com>

Author: geeknoid

Cargo.lock

@@ -73,7 +73,7 @@ fundle_macros = { path = "crates/fundle_macros", default-features = false, versi
 fundle_macros_impl = { path = "crates/fundle_macros_impl", default-features = false, version = "0.3.4" }
 http_extensions = { path = "crates/http_extensions", default-features = false, version = "0.6.4" }
 layered = { path = "crates/layered", default-features = false, version = "0.3.5" }
-multitude = { path = "crates/multitude", default-features = false, version = "0.5.1" }
+multitude = { path = "crates/multitude", default-features = false, version = "0.6.0" }
 ohno = { path = "crates/ohno", default-features = false, version = "0.3.8" }
 ohno_macros = { path = "crates/ohno_macros", default-features = false, version = "0.3.5" }
 plurality = { path = "crates/plurality", default-features = false, version = "0.1.0" }

Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "multitude"
-version = "0.5.1"
+version = "0.6.0"
 description = "Fast and flexible arena allocator."
 readme = "README.md"
 keywords = ["arena", "memory", "allocator", "bump"]

crates/multitude/Cargo.toml

@@ -57,15 +57,17 @@ unsafe impl<A: Allocator + Clone> Allocator for &Arena<A> {
                 return Ok(NonNull::slice_from_raw_parts(ptr, layout.size()));
             }
             if self.is_oversized(refill_hint) {
-                return self.alloc_oversized_shared_with(refill_hint, |mutator, chunk_ptr| {
-                    let (slot, _chunk) = mutator
-                        .try_alloc_with_chunk(layout.size(), layout.align())
-                        .expect("dedicated oversized chunk sized to fit allocation + alignment slack");
-                    let chunk_ref = acquire_chunk_ref::<A>(chunk_ptr);
-                    let ptr = slot.as_non_null();
-                    let _ = chunk_ref.forget();
-                    NonNull::slice_from_raw_parts(ptr, layout.size())
-                });
+                return self
+                    .alloc_oversized_shared_with(refill_hint, |mutator, chunk_ptr| {
+                        let (slot, _chunk) = mutator
+                            .try_alloc_with_chunk(layout.size(), layout.align())
+                            .expect("dedicated oversized chunk sized to fit allocation + alignment slack");
+                        let chunk_ref = acquire_chunk_ref::<A>(chunk_ptr);
+                        let ptr = slot.as_non_null();
+                        let _ = chunk_ref.forget();
+                        NonNull::slice_from_raw_parts(ptr, layout.size())
+                    })
+                    .map_err(Into::into);
             }
             self.refill(refill_hint)?;
         }

crates/multitude/README.md

@@ -6,9 +6,10 @@
 //! All public methods are documented on [`Arena`] itself; this file
 //! groups the family together to keep the central `mod.rs` smaller.
 
-use allocator_api2::alloc::{AllocError, Allocator};
+use allocator_api2::alloc::Allocator;
 
 use super::Arena;
+use crate::AllocError;
 use crate::arena::ExpectAlloc;
 use crate::strings::{FromUtf16Error, String};
 use crate::vec::Vec;

crates/multitude/src/allocator_impl.rs

@@ -18,10 +18,11 @@
 use core::mem;
 use core::ptr::{self, NonNull};
 
-use allocator_api2::alloc::{AllocError, Allocator};
+use allocator_api2::alloc::Allocator;
 
 use super::Arena;
 use super::alloc_value::acquire_chunk_ref;
+use crate::AllocError;
 use crate::internal::chunk_ref::ChunkRef;
 use crate::internal::thin_dst;
 
@@ -73,8 +74,8 @@ impl<A: Allocator + Clone> Arena<A> {
         // pointer is strictly inside the chunk (never one-past-end at
         // `chunk_base + CHUNK_ALIGN`), preserving the mask-based chunk
         // recovery invariant used by the smart pointers' `Drop`.
-        let payload_bytes = len.checked_mul(elem_size).ok_or(AllocError)?.max(elem_align);
-        let total = PREFIX_BYTES.checked_add(payload_bytes).ok_or(AllocError)?;
+        let payload_bytes = len.checked_mul(elem_size).ok_or(AllocError::CAPACITY_OVERFLOW)?.max(elem_align);
+        let total = PREFIX_BYTES.checked_add(payload_bytes).ok_or(AllocError::CAPACITY_OVERFLOW)?;
         // `total` is an exact reservation size, not a worst-case hint: unlike
         // the slice paths (which permit over-aligned `T` and so add `elem_align`
         // of front-padding slack to their routing hint), the const-assert above

crates/multitude/src/arena/alloc_growable.rs

@@ -9,11 +9,12 @@ use core::mem;
 use core::pin::Pin;
 use core::ptr::NonNull;
 
-use allocator_api2::alloc::{AllocError, Allocator};
+use allocator_api2::alloc::Allocator;
 
 use super::alloc_prefixed::worst_case_strong_slice_payload;
 use super::alloc_value::{MAX_SMART_PTR_ALIGN, acquire_chunk_ref};
 use super::{Arena, ExpectAlloc};
+use crate::AllocError;
 use crate::arc::Arc;
 use crate::internal::thin_dst::{AtomicStrong, LocalStrong, Strong};
 use crate::rc::Rc;
@@ -465,7 +466,7 @@ impl<A: Allocator + Clone> Arena<A> {
 #[inline]
 fn check_slice_arc_layout<T>() -> Result<(), AllocError> {
     if mem::align_of::<T>() >= MAX_SMART_PTR_ALIGN {
-        return Err(AllocError);
+        return Err(AllocError::ALIGNMENT_TOO_LARGE);
     }
     Ok(())
 }

crates/multitude/src/arena/alloc_prefixed.rs

@@ -9,11 +9,12 @@ use core::mem;
 use core::pin::Pin;
 use core::ptr::{self, NonNull};
 
-use allocator_api2::alloc::{AllocError, Allocator};
+use allocator_api2::alloc::Allocator;
 
 use super::alloc_prefixed::worst_case_thin_slice_payload;
 use super::alloc_value::{MAX_SMART_PTR_ALIGN, acquire_chunk_ref};
 use super::{Arena, ExpectAlloc};
+use crate::AllocError;
 use crate::r#box::Box;
 
 impl<A: Allocator + Clone> Arena<A> {
@@ -181,7 +182,7 @@ impl<A: Allocator + Clone> Arena<A> {
     fn impl_alloc_slice_box_with<T, F: FnMut(usize) -> T>(&self, len: usize, mut f: F) -> Result<Box<[T], A>, AllocError> {
         check_slice_box_layout::<T>(len)?;
         // Check overflow before the refill loop.
-        let payload_bytes = mem::size_of::<T>().checked_mul(len).ok_or(AllocError)?;
+        let payload_bytes = mem::size_of::<T>().checked_mul(len).ok_or(AllocError::CAPACITY_OVERFLOW)?;
         let ptr = self.reserve_slice_box::<T>(len, payload_bytes, |slot_ptr| {
             // SAFETY: `slot_ptr` is the reservation start; we init `len` slots
             // with panic-safe rollback via `InitGuard`.
@@ -293,7 +294,7 @@ impl<A: Allocator + Clone> Arena<A> {
 #[inline]
 fn check_slice_box_layout<T>(_len: usize) -> Result<(), AllocError> {
     if mem::align_of::<T>() >= MAX_SMART_PTR_ALIGN {
-        return Err(AllocError);
+        return Err(AllocError::ALIGNMENT_TOO_LARGE);
     }
     Ok(())
 }

crates/multitude/src/arena/alloc_slice_arc.rs

@@ -16,11 +16,11 @@ use core::hint::assert_unchecked;
 use core::mem;
 use core::ptr::NonNull;
 
-use allocator_api2::alloc::{AllocError, Allocator};
+use allocator_api2::alloc::Allocator;
 
 use super::{Arena, ExpectAlloc};
-use crate::Alloc;
 use crate::internal::constants::CHUNK_ALIGN;
+use crate::{Alloc, AllocError};
 
 /// Reject over-aligned slice element types early. Simple-reference
 /// slices return a plain `&mut [T]` (no header-recovery mask), so they
@@ -30,7 +30,7 @@ use crate::internal::constants::CHUNK_ALIGN;
 #[inline(always)]
 fn reject_over_aligned<T>() -> Result<(), AllocError> {
     if const { mem::align_of::<T>() >= CHUNK_ALIGN } {
-        return Err(AllocError);
+        return Err(AllocError::ALIGNMENT_TOO_LARGE);
     }
     Ok(())
 }