From a294aa8d3d7b73b7de60c629ae202194cffeb2f4 Mon Sep 17 00:00:00 2001 From: Kornel Date: Fri, 23 Jul 2021 16:40:43 +0100 Subject: Hide allocator details from TryReserveError --- library/alloc/src/collections/mod.rs | 49 ++++++++++++++++++++++---- library/alloc/src/collections/vec_deque/mod.rs | 3 +- library/alloc/src/raw_vec.rs | 20 +++++------ 3 files changed, 55 insertions(+), 17 deletions(-) (limited to 'library/alloc/src') diff --git a/library/alloc/src/collections/mod.rs b/library/alloc/src/collections/mod.rs index 97bfe2f3984..3ee857f3399 100644 --- a/library/alloc/src/collections/mod.rs +++ b/library/alloc/src/collections/mod.rs @@ -58,7 +58,31 @@ use core::fmt::Display; /// The error type for `try_reserve` methods. #[derive(Clone, PartialEq, Eq, Debug)] #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] -pub enum TryReserveError { +pub struct TryReserveError { + kind: TryReserveErrorKind, +} + +impl TryReserveError { + /// Details about the allocation that caused the error + #[inline] + #[unstable( + feature = "try_reserve_kind", + reason = "Uncertain how much info should be exposed", + issue = "48043" + )] + pub fn kind(&self) -> TryReserveErrorKind { + self.kind.clone() + } +} + +/// Details of the allocation that caused a `TryReserveError` +#[derive(Clone, PartialEq, Eq, Debug)] +#[unstable( + feature = "try_reserve_kind", + reason = "Uncertain how much info should be exposed", + issue = "48043" +)] +pub enum TryReserveErrorKind { /// Error due to the computed capacity exceeding the collection's maximum /// (usually `isize::MAX` bytes). CapacityOverflow, @@ -81,12 +105,23 @@ pub enum TryReserveError { }, } +#[unstable( + feature = "try_reserve_kind", + reason = "Uncertain how much info should be exposed", + issue = "48043" +)] +impl From for TryReserveError { + fn from(kind: TryReserveErrorKind) -> Self { + Self { kind } + } +} + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] impl From for TryReserveError { - /// Always evaluates to [`TryReserveError::CapacityOverflow`]. + /// Always evaluates to [`TryReserveErrorKind::CapacityOverflow`]. #[inline] fn from(_: LayoutError) -> Self { - TryReserveError::CapacityOverflow + TryReserveErrorKind::CapacityOverflow.into() } } @@ -97,11 +132,13 @@ impl Display for TryReserveError { fmt: &mut core::fmt::Formatter<'_>, ) -> core::result::Result<(), core::fmt::Error> { fmt.write_str("memory allocation failed")?; - let reason = match &self { - TryReserveError::CapacityOverflow => { + let reason = match self.kind { + TryReserveErrorKind::CapacityOverflow => { " because the computed capacity exceeded the collection's maximum" } - TryReserveError::AllocError { .. } => " because the memory allocator returned a error", + TryReserveErrorKind::AllocError { .. } => { + " because the memory allocator returned a error" + } }; fmt.write_str(reason) } diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 461e701be05..b8afa0d092e 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -18,6 +18,7 @@ use core::ptr::{self, NonNull}; use core::slice; use crate::collections::TryReserveError; +use crate::collections::TryReserveErrorKind; use crate::raw_vec::RawVec; use crate::vec::Vec; @@ -724,7 +725,7 @@ impl VecDeque { let new_cap = used_cap .checked_add(additional) .and_then(|needed_cap| needed_cap.checked_next_power_of_two()) - .ok_or(TryReserveError::CapacityOverflow)?; + .ok_or(TryReserveErrorKind::CapacityOverflow)?; if new_cap > old_cap { self.buf.try_reserve_exact(used_cap, new_cap - used_cap)?; diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index d11d4031f77..3caada06f6b 100644 --- a/library/alloc/src/raw_vec.rs +++ b/library/alloc/src/raw_vec.rs @@ -13,7 +13,8 @@ use core::slice; use crate::alloc::handle_alloc_error; use crate::alloc::{Allocator, Global, Layout}; use crate::boxed::Box; -use crate::collections::TryReserveError::{self, *}; +use crate::collections::TryReserveError; +use crate::collections::TryReserveErrorKind::*; #[cfg(test)] mod tests; @@ -425,7 +426,7 @@ impl RawVec { if mem::size_of::() == 0 { // Since we return a capacity of `usize::MAX` when `elem_size` is // 0, getting to here necessarily means the `RawVec` is overfull. - return Err(CapacityOverflow); + return Err(CapacityOverflow.into()); } // Nothing we can really do about these checks, sadly. @@ -451,7 +452,7 @@ impl RawVec { if mem::size_of::() == 0 { // Since we return a capacity of `usize::MAX` when the type size is // 0, getting to here necessarily means the `RawVec` is overfull. - return Err(CapacityOverflow); + return Err(CapacityOverflow.into()); } let cap = len.checked_add(additional).ok_or(CapacityOverflow)?; @@ -471,10 +472,9 @@ impl RawVec { let ptr = unsafe { let new_layout = Layout::from_size_align_unchecked(new_size, layout.align()); - self.alloc.shrink(ptr, layout, new_layout).map_err(|_| TryReserveError::AllocError { - layout: new_layout, - non_exhaustive: (), - })? + self.alloc + .shrink(ptr, layout, new_layout) + .map_err(|_| AllocError { layout: new_layout, non_exhaustive: () })? }; self.set_ptr(ptr); Ok(()) @@ -510,7 +510,7 @@ where alloc.allocate(new_layout) }; - memory.map_err(|_| AllocError { layout: new_layout, non_exhaustive: () }) + memory.map_err(|_| AllocError { layout: new_layout, non_exhaustive: () }.into()) } unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec { @@ -526,7 +526,7 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec { #[cfg(not(no_global_oom_handling))] #[inline] fn handle_reserve(result: Result<(), TryReserveError>) { - match result { + match result.map_err(|e| e.kind()) { Err(CapacityOverflow) => capacity_overflow(), Err(AllocError { layout, .. }) => handle_alloc_error(layout), Ok(()) => { /* yay */ } @@ -545,7 +545,7 @@ fn handle_reserve(result: Result<(), TryReserveError>) { #[inline] fn alloc_guard(alloc_size: usize) -> Result<(), TryReserveError> { if usize::BITS < 64 && alloc_size > isize::MAX as usize { - Err(CapacityOverflow) + Err(CapacityOverflow.into()) } else { Ok(()) } -- cgit 1.4.1-3-g733a5