Skip to content

Commit 6c1975d

Browse files
rust-timerrust-timer
authored
Unrolled build for rust-lang#124981
Rollup merge of rust-lang#124981 - zachs18:rc-allocator-generalize-1, r=Mark-Simulacrum Relax allocator requirements on some Rc/Arc APIs. Split out from rust-lang#119761 * Remove `A: Clone` bound from `Rc::assume_init`(s), `Rc::downcast`, and `Rc::downcast_unchecked` (`Arc` methods were already relaxed by rust-lang#120445) * Make `From<Rc<[T; N]>> for Rc<[T]>` allocator-aware (`Arc`'s already is). * Remove `A: Clone` from `Rc/Arc::unwrap_or_clone` Internal changes: * Made `Arc::internal_into_inner_with_allocator` method into `Arc::into_inner_with_allocator` associated fn. * Add private `Rc::into_inner_with_allocator` (to match Arc), so other fns don't have to juggle `ManuallyDrop`.
2 parents 78a7751 + 8d8eb50 commit 6c1975d

File tree

2 files changed

+33
-32
lines changed

2 files changed

+33
-32
lines changed

‎library/alloc/src/rc.rs

+24-25
Original file line numberDiff line numberDiff line change
@@ -365,6 +365,12 @@ impl<T: ?Sized, A: Allocator> Rc<T, A> {
365365
unsafe { self.ptr.as_ref() }
366366
}
367367

368+
#[inline]
369+
fn into_inner_with_allocator(this: Self) -> (NonNull<RcBox<T>>, A) {
370+
let this = mem::ManuallyDrop::new(this);
371+
(this.ptr, unsafe { ptr::read(&this.alloc) })
372+
}
373+
368374
#[inline]
369375
unsafe fn from_inner_in(ptr: NonNull<RcBox<T>>, alloc: A) -> Self {
370376
Self { ptr, phantom: PhantomData, alloc }
@@ -1145,12 +1151,9 @@ impl<T, A: Allocator> Rc<mem::MaybeUninit<T>, A> {
11451151
/// ```
11461152
#[unstable(feature = "new_uninit", issue = "63291")]
11471153
#[inline]
1148-
pub unsafe fn assume_init(self) -> Rc<T, A>
1149-
where
1150-
A: Clone,
1151-
{
1152-
let md_self = mem::ManuallyDrop::new(self);
1153-
unsafe { Rc::from_inner_in(md_self.ptr.cast(), md_self.alloc.clone()) }
1154+
pub unsafe fn assume_init(self) -> Rc<T, A> {
1155+
let (ptr, alloc) = Rc::into_inner_with_allocator(self);
1156+
unsafe { Rc::from_inner_in(ptr.cast(), alloc) }
11541157
}
11551158
}
11561159

@@ -1189,12 +1192,9 @@ impl<T, A: Allocator> Rc<[mem::MaybeUninit<T>], A> {
11891192
/// ```
11901193
#[unstable(feature = "new_uninit", issue = "63291")]
11911194
#[inline]
1192-
pub unsafe fn assume_init(self) -> Rc<[T], A>
1193-
where
1194-
A: Clone,
1195-
{
1196-
let md_self = mem::ManuallyDrop::new(self);
1197-
unsafe { Rc::from_ptr_in(md_self.ptr.as_ptr() as _, md_self.alloc.clone()) }
1195+
pub unsafe fn assume_init(self) -> Rc<[T], A> {
1196+
let (ptr, alloc) = Rc::into_inner_with_allocator(self);
1197+
unsafe { Rc::from_ptr_in(ptr.as_ptr() as _, alloc) }
11981198
}
11991199
}
12001200

@@ -1809,7 +1809,9 @@ impl<T: Clone, A: Allocator + Clone> Rc<T, A> {
18091809
// reference to the allocation.
18101810
unsafe { &mut this.ptr.as_mut().value }
18111811
}
1812+
}
18121813

1814+
impl<T: Clone, A: Allocator> Rc<T, A> {
18131815
/// If we have the only reference to `T` then unwrap it. Otherwise, clone `T` and return the
18141816
/// clone.
18151817
///
@@ -1845,7 +1847,7 @@ impl<T: Clone, A: Allocator + Clone> Rc<T, A> {
18451847
}
18461848
}
18471849

1848-
impl<A: Allocator + Clone> Rc<dyn Any, A> {
1850+
impl<A: Allocator> Rc<dyn Any, A> {
18491851
/// Attempt to downcast the `Rc<dyn Any>` to a concrete type.
18501852
///
18511853
/// # Examples
@@ -1869,10 +1871,8 @@ impl<A: Allocator + Clone> Rc<dyn Any, A> {
18691871
pub fn downcast<T: Any>(self) -> Result<Rc<T, A>, Self> {
18701872
if (*self).is::<T>() {
18711873
unsafe {
1872-
let ptr = self.ptr.cast::<RcBox<T>>();
1873-
let alloc = self.alloc.clone();
1874-
forget(self);
1875-
Ok(Rc::from_inner_in(ptr, alloc))
1874+
let (ptr, alloc) = Rc::into_inner_with_allocator(self);
1875+
Ok(Rc::from_inner_in(ptr.cast(), alloc))
18761876
}
18771877
} else {
18781878
Err(self)
@@ -1909,10 +1909,8 @@ impl<A: Allocator + Clone> Rc<dyn Any, A> {
19091909
#[unstable(feature = "downcast_unchecked", issue = "90850")]
19101910
pub unsafe fn downcast_unchecked<T: Any>(self) -> Rc<T, A> {
19111911
unsafe {
1912-
let ptr = self.ptr.cast::<RcBox<T>>();
1913-
let alloc = self.alloc.clone();
1914-
mem::forget(self);
1915-
Rc::from_inner_in(ptr, alloc)
1912+
let (ptr, alloc) = Rc::into_inner_with_allocator(self);
1913+
Rc::from_inner_in(ptr.cast(), alloc)
19161914
}
19171915
}
19181916
}
@@ -2661,12 +2659,13 @@ impl From<Rc<str>> for Rc<[u8]> {
26612659
}
26622660

26632661
#[stable(feature = "boxed_slice_try_from", since = "1.43.0")]
2664-
impl<T, const N: usize> TryFrom<Rc<[T]>> for Rc<[T; N]> {
2665-
type Error = Rc<[T]>;
2662+
impl<T, A: Allocator, const N: usize> TryFrom<Rc<[T], A>> for Rc<[T; N], A> {
2663+
type Error = Rc<[T], A>;
26662664

2667-
fn try_from(boxed_slice: Rc<[T]>) -> Result<Self, Self::Error> {
2665+
fn try_from(boxed_slice: Rc<[T], A>) -> Result<Self, Self::Error> {
26682666
if boxed_slice.len() == N {
2669-
Ok(unsafe { Rc::from_raw(Rc::into_raw(boxed_slice) as *mut [T; N]) })
2667+
let (ptr, alloc) = Rc::into_inner_with_allocator(boxed_slice);
2668+
Ok(unsafe { Rc::from_inner_in(ptr.cast(), alloc) })
26702669
} else {
26712670
Err(boxed_slice)
26722671
}

‎library/alloc/src/sync.rs

+9-7
Original file line numberDiff line numberDiff line change
@@ -280,8 +280,8 @@ impl<T: ?Sized> Arc<T> {
280280

281281
impl<T: ?Sized, A: Allocator> Arc<T, A> {
282282
#[inline]
283-
fn internal_into_inner_with_allocator(self) -> (NonNull<ArcInner<T>>, A) {
284-
let this = mem::ManuallyDrop::new(self);
283+
fn into_inner_with_allocator(this: Self) -> (NonNull<ArcInner<T>>, A) {
284+
let this = mem::ManuallyDrop::new(this);
285285
(this.ptr, unsafe { ptr::read(&this.alloc) })
286286
}
287287

@@ -1290,7 +1290,7 @@ impl<T, A: Allocator> Arc<mem::MaybeUninit<T>, A> {
12901290
#[must_use = "`self` will be dropped if the result is not used"]
12911291
#[inline]
12921292
pub unsafe fn assume_init(self) -> Arc<T, A> {
1293-
let (ptr, alloc) = self.internal_into_inner_with_allocator();
1293+
let (ptr, alloc) = Arc::into_inner_with_allocator(self);
12941294
unsafe { Arc::from_inner_in(ptr.cast(), alloc) }
12951295
}
12961296
}
@@ -1332,7 +1332,7 @@ impl<T, A: Allocator> Arc<[mem::MaybeUninit<T>], A> {
13321332
#[must_use = "`self` will be dropped if the result is not used"]
13331333
#[inline]
13341334
pub unsafe fn assume_init(self) -> Arc<[T], A> {
1335-
let (ptr, alloc) = self.internal_into_inner_with_allocator();
1335+
let (ptr, alloc) = Arc::into_inner_with_allocator(self);
13361336
unsafe { Arc::from_ptr_in(ptr.as_ptr() as _, alloc) }
13371337
}
13381338
}
@@ -2227,7 +2227,9 @@ impl<T: Clone, A: Allocator + Clone> Arc<T, A> {
22272227
// either unique to begin with, or became one upon cloning the contents.
22282228
unsafe { Self::get_mut_unchecked(this) }
22292229
}
2230+
}
22302231

2232+
impl<T: Clone, A: Allocator> Arc<T, A> {
22312233
/// If we have the only reference to `T` then unwrap it. Otherwise, clone `T` and return the
22322234
/// clone.
22332235
///
@@ -2499,7 +2501,7 @@ impl<A: Allocator> Arc<dyn Any + Send + Sync, A> {
24992501
{
25002502
if (*self).is::<T>() {
25012503
unsafe {
2502-
let (ptr, alloc) = self.internal_into_inner_with_allocator();
2504+
let (ptr, alloc) = Arc::into_inner_with_allocator(self);
25032505
Ok(Arc::from_inner_in(ptr.cast(), alloc))
25042506
}
25052507
} else {
@@ -2540,7 +2542,7 @@ impl<A: Allocator> Arc<dyn Any + Send + Sync, A> {
25402542
T: Any + Send + Sync,
25412543
{
25422544
unsafe {
2543-
let (ptr, alloc) = self.internal_into_inner_with_allocator();
2545+
let (ptr, alloc) = Arc::into_inner_with_allocator(self);
25442546
Arc::from_inner_in(ptr.cast(), alloc)
25452547
}
25462548
}
@@ -3506,7 +3508,7 @@ impl<T, A: Allocator, const N: usize> TryFrom<Arc<[T], A>> for Arc<[T; N], A> {
35063508

35073509
fn try_from(boxed_slice: Arc<[T], A>) -> Result<Self, Self::Error> {
35083510
if boxed_slice.len() == N {
3509-
let (ptr, alloc) = boxed_slice.internal_into_inner_with_allocator();
3511+
let (ptr, alloc) = Arc::into_inner_with_allocator(boxed_slice);
35103512
Ok(unsafe { Arc::from_inner_in(ptr.cast(), alloc) })
35113513
} else {
35123514
Err(boxed_slice)

0 commit comments

Comments
 (0)