OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rollup merge of #52253 - ljedrz:dyn_librustc_data_structures, r=cramertj

Browse Source 
Deny bare trait objects in in src/librustc_data_structures

Enforce `#![deny(bare_trait_objects)]` in `src/librustc_data_structures`.
This commit is contained in:
Mark Rousskov 2018-07-11 12:38:45 -06:00 committed by GitHub
commit 59fb178ad9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 30 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/librustc_data_structures/lib.rs
View File

@ -16,6 +16,8 @@
//! //!
//! This API is completely unstable and subject to change. //! This API is completely unstable and subject to change.
#![deny(bare_trait_objects)]
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "https://www.rust-lang.org/favicon.ico", html_favicon_url = "https://www.rust-lang.org/favicon.ico",
html_root_url = "https://doc.rust-lang.org/nightly/")] html_root_url = "https://doc.rust-lang.org/nightly/")]

52
src/librustc_data_structures/owning_ref/mod.rs
View File

@ -1046,7 +1046,7 @@ unsafe impl<O, T: ?Sized> Send for OwningRefMut<O, T>
unsafe impl<O, T: ?Sized> Sync for OwningRefMut<O, T> unsafe impl<O, T: ?Sized> Sync for OwningRefMut<O, T>
where O: Sync, for<'a> (&'a mut T): Sync {} where O: Sync, for<'a> (&'a mut T): Sync {}
impl Debug for Erased { impl Debug for dyn Erased {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "<Erased>",) write!(f, "<Erased>",)
} }
@ -1166,35 +1166,35 @@ pub type MutexGuardRefMut<'a, T, U = T> = OwningRefMut<MutexGuard<'a, T>, U>;
pub type RwLockWriteGuardRefMut<'a, T, U = T> = OwningRef<RwLockWriteGuard<'a, T>, U>; pub type RwLockWriteGuardRefMut<'a, T, U = T> = OwningRef<RwLockWriteGuard<'a, T>, U>;
unsafe impl<'a, T: 'a> IntoErased<'a> for Box<T> { unsafe impl<'a, T: 'a> IntoErased<'a> for Box<T> {
type Erased = Box<Erased + 'a>; type Erased = Box<dyn Erased + 'a>;
fn into_erased(self) -> Self::Erased { fn into_erased(self) -> Self::Erased {
self self
} }
} }
unsafe impl<'a, T: 'a> IntoErased<'a> for Rc<T> { unsafe impl<'a, T: 'a> IntoErased<'a> for Rc<T> {
type Erased = Rc<Erased + 'a>; type Erased = Rc<dyn Erased + 'a>;
fn into_erased(self) -> Self::Erased { fn into_erased(self) -> Self::Erased {
self self
} }
} }
unsafe impl<'a, T: 'a> IntoErased<'a> for Arc<T> { unsafe impl<'a, T: 'a> IntoErased<'a> for Arc<T> {
type Erased = Arc<Erased + 'a>; type Erased = Arc<dyn Erased + 'a>;
fn into_erased(self) -> Self::Erased { fn into_erased(self) -> Self::Erased {
self self
} }
} }
unsafe impl<'a, T: Send + 'a> IntoErasedSend<'a> for Box<T> { unsafe impl<'a, T: Send + 'a> IntoErasedSend<'a> for Box<T> {
type Erased = Box<Erased + Send + 'a>; type Erased = Box<dyn Erased + Send + 'a>;
fn into_erased_send(self) -> Self::Erased { fn into_erased_send(self) -> Self::Erased {
self self
} }
} }
unsafe impl<'a, T: Send + 'a> IntoErasedSendSync<'a> for Box<T> { unsafe impl<'a, T: Send + 'a> IntoErasedSendSync<'a> for Box<T> {
type Erased = Box<Erased + Sync + Send + 'a>; type Erased = Box<dyn Erased + Sync + Send + 'a>;
fn into_erased_send_sync(self) -> Self::Erased { fn into_erased_send_sync(self) -> Self::Erased {
let result: Box<Erased + Send + 'a> = self; let result: Box<dyn Erased + Send + 'a> = self;
// This is safe since Erased can always implement Sync // This is safe since Erased can always implement Sync
// Only the destructor is available and it takes &mut self // Only the destructor is available and it takes &mut self
unsafe { unsafe {
@ -1204,21 +1204,21 @@ unsafe impl<'a, T: Send + 'a> IntoErasedSendSync<'a> for Box<T> {
} }
unsafe impl<'a, T: Send + Sync + 'a> IntoErasedSendSync<'a> for Arc<T> { unsafe impl<'a, T: Send + Sync + 'a> IntoErasedSendSync<'a> for Arc<T> {
type Erased = Arc<Erased + Send + Sync + 'a>; type Erased = Arc<dyn Erased + Send + Sync + 'a>;
fn into_erased_send_sync(self) -> Self::Erased { fn into_erased_send_sync(self) -> Self::Erased {
self self
} }
} }
/// Typedef of a owning reference that uses an erased `Box` as the owner. /// Typedef of a owning reference that uses an erased `Box` as the owner.
pub type ErasedBoxRef<U> = OwningRef<Box<Erased>, U>; pub type ErasedBoxRef<U> = OwningRef<Box<dyn Erased>, U>;
/// Typedef of a owning reference that uses an erased `Rc` as the owner. /// Typedef of a owning reference that uses an erased `Rc` as the owner.
pub type ErasedRcRef<U> = OwningRef<Rc<Erased>, U>; pub type ErasedRcRef<U> = OwningRef<Rc<dyn Erased>, U>;
/// Typedef of a owning reference that uses an erased `Arc` as the owner. /// Typedef of a owning reference that uses an erased `Arc` as the owner.
pub type ErasedArcRef<U> = OwningRef<Arc<Erased>, U>; pub type ErasedArcRef<U> = OwningRef<Arc<dyn Erased>, U>;
/// Typedef of a mutable owning reference that uses an erased `Box` as the owner. /// Typedef of a mutable owning reference that uses an erased `Box` as the owner.
pub type ErasedBoxRefMut<U> = OwningRefMut<Box<Erased>, U>; pub type ErasedBoxRefMut<U> = OwningRefMut<Box<dyn Erased>, U>;
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
@ -1443,8 +1443,8 @@ mod tests {
let c: OwningRef<Rc<Vec<u8>>, [u8]> = unsafe {a.map_owner(Rc::new)}; let c: OwningRef<Rc<Vec<u8>>, [u8]> = unsafe {a.map_owner(Rc::new)};
let d: OwningRef<Rc<Box<[u8]>>, [u8]> = unsafe {b.map_owner(Rc::new)}; let d: OwningRef<Rc<Box<[u8]>>, [u8]> = unsafe {b.map_owner(Rc::new)};
let e: OwningRef<Rc<Erased>, [u8]> = c.erase_owner(); let e: OwningRef<Rc<dyn Erased>, [u8]> = c.erase_owner();
let f: OwningRef<Rc<Erased>, [u8]> = d.erase_owner(); let f: OwningRef<Rc<dyn Erased>, [u8]> = d.erase_owner();
let _g = e.clone(); let _g = e.clone();
let _h = f.clone(); let _h = f.clone();
@ -1460,8 +1460,8 @@ mod tests {
let c: OwningRef<Box<Vec<u8>>, [u8]> = a.map_owner_box(); let c: OwningRef<Box<Vec<u8>>, [u8]> = a.map_owner_box();
let d: OwningRef<Box<Box<[u8]>>, [u8]> = b.map_owner_box(); let d: OwningRef<Box<Box<[u8]>>, [u8]> = b.map_owner_box();
let _e: OwningRef<Box<Erased>, [u8]> = c.erase_owner(); let _e: OwningRef<Box<dyn Erased>, [u8]> = c.erase_owner();
let _f: OwningRef<Box<Erased>, [u8]> = d.erase_owner(); let _f: OwningRef<Box<dyn Erased>, [u8]> = d.erase_owner();
} }
#[test] #[test]
@ -1469,7 +1469,7 @@ mod tests {
use std::any::Any; use std::any::Any;
let x = Box::new(123_i32); let x = Box::new(123_i32);
let y: Box<Any> = x; let y: Box<dyn Any> = x;
OwningRef::new(y).try_map(|x| x.downcast_ref::<i32>().ok_or(())).is_ok(); OwningRef::new(y).try_map(|x| x.downcast_ref::<i32>().ok_or(())).is_ok();
} }
@ -1479,7 +1479,7 @@ mod tests {
use std::any::Any; use std::any::Any;
let x = Box::new(123_i32); let x = Box::new(123_i32);
let y: Box<Any> = x; let y: Box<dyn Any> = x;
OwningRef::new(y).try_map(|x| x.downcast_ref::<i32>().ok_or(())).is_err(); OwningRef::new(y).try_map(|x| x.downcast_ref::<i32>().ok_or(())).is_err();
} }
@ -1843,8 +1843,8 @@ mod tests {
let c: OwningRefMut<Box<Vec<u8>>, [u8]> = unsafe {a.map_owner(Box::new)}; let c: OwningRefMut<Box<Vec<u8>>, [u8]> = unsafe {a.map_owner(Box::new)};
let d: OwningRefMut<Box<Box<[u8]>>, [u8]> = unsafe {b.map_owner(Box::new)}; let d: OwningRefMut<Box<Box<[u8]>>, [u8]> = unsafe {b.map_owner(Box::new)};
let _e: OwningRefMut<Box<Erased>, [u8]> = c.erase_owner(); let _e: OwningRefMut<Box<dyn Erased>, [u8]> = c.erase_owner();
let _f: OwningRefMut<Box<Erased>, [u8]> = d.erase_owner(); let _f: OwningRefMut<Box<dyn Erased>, [u8]> = d.erase_owner();
} }
#[test] #[test]
@ -1857,8 +1857,8 @@ mod tests {
let c: OwningRefMut<Box<Vec<u8>>, [u8]> = a.map_owner_box(); let c: OwningRefMut<Box<Vec<u8>>, [u8]> = a.map_owner_box();
let d: OwningRefMut<Box<Box<[u8]>>, [u8]> = b.map_owner_box(); let d: OwningRefMut<Box<Box<[u8]>>, [u8]> = b.map_owner_box();
let _e: OwningRefMut<Box<Erased>, [u8]> = c.erase_owner(); let _e: OwningRefMut<Box<dyn Erased>, [u8]> = c.erase_owner();
let _f: OwningRefMut<Box<Erased>, [u8]> = d.erase_owner(); let _f: OwningRefMut<Box<dyn Erased>, [u8]> = d.erase_owner();
} }
#[test] #[test]
@ -1866,7 +1866,7 @@ mod tests {
use std::any::Any; use std::any::Any;
let x = Box::new(123_i32); let x = Box::new(123_i32);
let y: Box<Any> = x; let y: Box<dyn Any> = x;
OwningRefMut::new(y).try_map_mut(|x| x.downcast_mut::<i32>().ok_or(())).is_ok(); OwningRefMut::new(y).try_map_mut(|x| x.downcast_mut::<i32>().ok_or(())).is_ok();
} }
@ -1876,7 +1876,7 @@ mod tests {
use std::any::Any; use std::any::Any;
let x = Box::new(123_i32); let x = Box::new(123_i32);
let y: Box<Any> = x; let y: Box<dyn Any> = x;
OwningRefMut::new(y).try_map_mut(|x| x.downcast_mut::<i32>().ok_or(())).is_err(); OwningRefMut::new(y).try_map_mut(|x| x.downcast_mut::<i32>().ok_or(())).is_err();
} }
@ -1886,7 +1886,7 @@ mod tests {
use std::any::Any; use std::any::Any;
let x = Box::new(123_i32); let x = Box::new(123_i32);
let y: Box<Any> = x; let y: Box<dyn Any> = x;
OwningRefMut::new(y).try_map(|x| x.downcast_ref::<i32>().ok_or(())).is_ok(); OwningRefMut::new(y).try_map(|x| x.downcast_ref::<i32>().ok_or(())).is_ok();
} }
@ -1896,7 +1896,7 @@ mod tests {
use std::any::Any; use std::any::Any;
let x = Box::new(123_i32); let x = Box::new(123_i32);
let y: Box<Any> = x; let y: Box<dyn Any> = x;
OwningRefMut::new(y).try_map(|x| x.downcast_ref::<i32>().ok_or(())).is_err(); OwningRefMut::new(y).try_map(|x| x.downcast_ref::<i32>().ok_or(())).is_err();
} }

4
src/librustc_data_structures/sync.rs
View File

@ -88,7 +88,7 @@ cfg_if! {
t.into_iter() t.into_iter()
} }
pub type MetadataRef = OwningRef<Box<Erased>, [u8]>; pub type MetadataRef = OwningRef<Box<dyn Erased>, [u8]>;
pub use std::rc::Rc as Lrc; pub use std::rc::Rc as Lrc;
pub use std::rc::Weak as Weak; pub use std::rc::Weak as Weak;
@ -268,7 +268,7 @@ cfg_if! {
t.into_par_iter() t.into_par_iter()
} }
pub type MetadataRef = OwningRef<Box<Erased + Send + Sync>, [u8]>; pub type MetadataRef = OwningRef<Box<dyn Erased + Send + Sync>, [u8]>;
/// This makes locks panic if they are already held. /// This makes locks panic if they are already held.
/// It is only useful when you are running in a single thread /// It is only useful when you are running in a single thread