bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Deny bare trait objects in src/libstd.

Browse source
This commit is contained in:
ljedrz 2018-07-10 20:35:36 +02:00
parent 77117e3836
commit 560d8079ec
20 changed files with 99 additions and 98 deletions
Download patch file Download diff file Expand all files Collapse all files

86
src/libstd/error.rs
View file

@ -138,7 +138,7 @@ pub trait Error: Debug + Display {
/// } /// }
/// ``` /// ```
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
fn cause(&self) -> Option<&Error> { None } fn cause(&self) -> Option<&dyn Error> { None }
/// Get the `TypeId` of `self` /// Get the `TypeId` of `self`
#[doc(hidden)] #[doc(hidden)]
@ -151,22 +151,22 @@ pub trait Error: Debug + Display {
} }
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
impl<'a, E: Error + 'a> From<E> for Box<Error + 'a> { impl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a> {
fn from(err: E) -> Box<Error + 'a> { fn from(err: E) -> Box<dyn Error + 'a> {
Box::new(err) Box::new(err)
} }
} }
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<Error + Send + Sync + 'a> { impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a> {
fn from(err: E) -> Box<Error + Send + Sync + 'a> { fn from(err: E) -> Box<dyn Error + Send + Sync + 'a> {
Box::new(err) Box::new(err)
} }
} }
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
impl From<String> for Box<Error + Send + Sync> { impl From<String> for Box<dyn Error + Send + Sync> {
fn from(err: String) -> Box<Error + Send + Sync> { fn from(err: String) -> Box<dyn Error + Send + Sync> {
#[derive(Debug)] #[derive(Debug)]
struct StringError(String); struct StringError(String);
@ -185,38 +185,38 @@ impl From<String> for Box<Error + Send + Sync> {
} }
#[stable(feature = "string_box_error", since = "1.6.0")] #[stable(feature = "string_box_error", since = "1.6.0")]
impl From<String> for Box<Error> { impl From<String> for Box<dyn Error> {
fn from(str_err: String) -> Box<Error> { fn from(str_err: String) -> Box<dyn Error> {
let err1: Box<Error + Send + Sync> = From::from(str_err); let err1: Box<dyn Error + Send + Sync> = From::from(str_err);
let err2: Box<Error> = err1; let err2: Box<dyn Error> = err1;
err2 err2
} }
} }
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
impl<'a, 'b> From<&'b str> for Box<Error + Send + Sync + 'a> { impl<'a, 'b> From<&'b str> for Box<dyn Error + Send + Sync + 'a> {
fn from(err: &'b str) -> Box<Error + Send + Sync + 'a> { fn from(err: &'b str) -> Box<dyn Error + Send + Sync + 'a> {
From::from(String::from(err)) From::from(String::from(err))
} }
} }
#[stable(feature = "string_box_error", since = "1.6.0")] #[stable(feature = "string_box_error", since = "1.6.0")]
impl<'a> From<&'a str> for Box<Error> { impl<'a> From<&'a str> for Box<dyn Error> {
fn from(err: &'a str) -> Box<Error> { fn from(err: &'a str) -> Box<dyn Error> {
From::from(String::from(err)) From::from(String::from(err))
} }
} }
#[stable(feature = "cow_box_error", since = "1.22.0")] #[stable(feature = "cow_box_error", since = "1.22.0")]
impl<'a, 'b> From<Cow<'b, str>> for Box<Error + Send + Sync + 'a> { impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a> {
fn from(err: Cow<'b, str>) -> Box<Error + Send + Sync + 'a> { fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a> {
From::from(String::from(err)) From::from(String::from(err))
} }
} }
#[stable(feature = "cow_box_error", since = "1.22.0")] #[stable(feature = "cow_box_error", since = "1.22.0")]
impl<'a> From<Cow<'a, str>> for Box<Error> { impl<'a> From<Cow<'a, str>> for Box<dyn Error> {
fn from(err: Cow<'a, str>) -> Box<Error> { fn from(err: Cow<'a, str>) -> Box<dyn Error> {
From::from(String::from(err)) From::from(String::from(err))
} }
} }
@ -327,7 +327,7 @@ impl<T: Error> Error for Box<T> {
Error::description(&**self) Error::description(&**self)
} }
fn cause(&self) -> Option<&Error> { fn cause(&self) -> Option<&dyn Error> {
Error::cause(&**self) Error::cause(&**self)
} }
} }
@ -368,7 +368,7 @@ impl Error for char::ParseCharError {
} }
// copied from any.rs // copied from any.rs
impl Error + 'static { impl dyn Error + 'static {
/// Returns true if the boxed type is the same as `T` /// Returns true if the boxed type is the same as `T`
#[stable(feature = "error_downcast", since = "1.3.0")] #[stable(feature = "error_downcast", since = "1.3.0")]
#[inline] #[inline]
@ -390,7 +390,7 @@ impl Error + 'static {
pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> { pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
if self.is::<T>() { if self.is::<T>() {
unsafe { unsafe {
Some(&*(self as *const Error as *const T)) Some(&*(self as *const dyn Error as *const T))
} }
} else { } else {
None None
@ -404,7 +404,7 @@ impl Error + 'static {
pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> { pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> {
if self.is::<T>() { if self.is::<T>() {
unsafe { unsafe {
Some(&mut *(self as *mut Error as *mut T)) Some(&mut *(self as *mut dyn Error as *mut T))
} }
} else { } else {
None None
@ -412,60 +412,60 @@ impl Error + 'static {
} }
} }
impl Error + 'static + Send { impl dyn Error + 'static + Send {
/// Forwards to the method defined on the type `Any`. /// Forwards to the method defined on the type `Any`.
#[stable(feature = "error_downcast", since = "1.3.0")] #[stable(feature = "error_downcast", since = "1.3.0")]
#[inline] #[inline]
pub fn is<T: Error + 'static>(&self) -> bool { pub fn is<T: Error + 'static>(&self) -> bool {
<Error + 'static>::is::<T>(self) <dyn Error + 'static>::is::<T>(self)
} }
/// Forwards to the method defined on the type `Any`. /// Forwards to the method defined on the type `Any`.
#[stable(feature = "error_downcast", since = "1.3.0")] #[stable(feature = "error_downcast", since = "1.3.0")]
#[inline] #[inline]
pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> { pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
<Error + 'static>::downcast_ref::<T>(self) <dyn Error + 'static>::downcast_ref::<T>(self)
} }
/// Forwards to the method defined on the type `Any`. /// Forwards to the method defined on the type `Any`.
#[stable(feature = "error_downcast", since = "1.3.0")] #[stable(feature = "error_downcast", since = "1.3.0")]
#[inline] #[inline]
pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> { pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> {
<Error + 'static>::downcast_mut::<T>(self) <dyn Error + 'static>::downcast_mut::<T>(self)
} }
} }
impl Error + 'static + Send + Sync { impl dyn Error + 'static + Send + Sync {
/// Forwards to the method defined on the type `Any`. /// Forwards to the method defined on the type `Any`.
#[stable(feature = "error_downcast", since = "1.3.0")] #[stable(feature = "error_downcast", since = "1.3.0")]
#[inline] #[inline]
pub fn is<T: Error + 'static>(&self) -> bool { pub fn is<T: Error + 'static>(&self) -> bool {
<Error + 'static>::is::<T>(self) <dyn Error + 'static>::is::<T>(self)
} }
/// Forwards to the method defined on the type `Any`. /// Forwards to the method defined on the type `Any`.
#[stable(feature = "error_downcast", since = "1.3.0")] #[stable(feature = "error_downcast", since = "1.3.0")]
#[inline] #[inline]
pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> { pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
<Error + 'static>::downcast_ref::<T>(self) <dyn Error + 'static>::downcast_ref::<T>(self)
} }
/// Forwards to the method defined on the type `Any`. /// Forwards to the method defined on the type `Any`.
#[stable(feature = "error_downcast", since = "1.3.0")] #[stable(feature = "error_downcast", since = "1.3.0")]
#[inline] #[inline]
pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> { pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> {
<Error + 'static>::downcast_mut::<T>(self) <dyn Error + 'static>::downcast_mut::<T>(self)
} }
} }
impl Error { impl dyn Error {
#[inline] #[inline]
#[stable(feature = "error_downcast", since = "1.3.0")] #[stable(feature = "error_downcast", since = "1.3.0")]
/// Attempt to downcast the box to a concrete type. /// Attempt to downcast the box to a concrete type.
pub fn downcast<T: Error + 'static>(self: Box<Self>) -> Result<Box<T>, Box<Error>> { pub fn downcast<T: Error + 'static>(self: Box<Self>) -> Result<Box<T>, Box<dyn Error>> {
if self.is::<T>() { if self.is::<T>() {
unsafe { unsafe {
let raw: *mut Error = Box::into_raw(self); let raw: *mut dyn Error = Box::into_raw(self);
Ok(Box::from_raw(raw as *mut T)) Ok(Box::from_raw(raw as *mut T))
} }
} else { } else {
@ -474,30 +474,30 @@ impl Error {
} }
} }
impl Error + Send { impl dyn Error + Send {
#[inline] #[inline]
#[stable(feature = "error_downcast", since = "1.3.0")] #[stable(feature = "error_downcast", since = "1.3.0")]
/// Attempt to downcast the box to a concrete type. /// Attempt to downcast the box to a concrete type.
pub fn downcast<T: Error + 'static>(self: Box<Self>) pub fn downcast<T: Error + 'static>(self: Box<Self>)
-> Result<Box<T>, Box<Error + Send>> { -> Result<Box<T>, Box<dyn Error + Send>> {
let err: Box<Error> = self; let err: Box<dyn Error> = self;
<Error>::downcast(err).map_err(|s| unsafe { <dyn Error>::downcast(err).map_err(|s| unsafe {
// reapply the Send marker // reapply the Send marker
transmute::<Box<Error>, Box<Error + Send>>(s) transmute::<Box<dyn Error>, Box<dyn Error + Send>>(s)
}) })
} }
} }
impl Error + Send + Sync { impl dyn Error + Send + Sync {
#[inline] #[inline]
#[stable(feature = "error_downcast", since = "1.3.0")] #[stable(feature = "error_downcast", since = "1.3.0")]
/// Attempt to downcast the box to a concrete type. /// Attempt to downcast the box to a concrete type.
pub fn downcast<T: Error + 'static>(self: Box<Self>) pub fn downcast<T: Error + 'static>(self: Box<Self>)
-> Result<Box<T>, Box<Self>> { -> Result<Box<T>, Box<Self>> {
let err: Box<Error> = self; let err: Box<dyn Error> = self;
<Error>::downcast(err).map_err(|s| unsafe { <dyn Error>::downcast(err).map_err(|s| unsafe {
// reapply the Send+Sync marker // reapply the Send+Sync marker
transmute::<Box<Error>, Box<Error + Send + Sync>>(s) transmute::<Box<dyn Error>, Box<dyn Error + Send + Sync>>(s)
}) })
} }
} }

2
src/libstd/ffi/c_str.rs
View file

@ -883,7 +883,7 @@ impl Error for IntoStringError {
"C string contained non-utf8 bytes" "C string contained non-utf8 bytes"
} }
fn cause(&self) -> Option<&Error> { fn cause(&self) -> Option<&dyn Error> {
Some(&self.error) Some(&self.error)
} }
} }

14
src/libstd/io/error.rs
View file

@ -83,7 +83,7 @@ enum Repr {
#[derive(Debug)] #[derive(Debug)]
struct Custom { struct Custom {
kind: ErrorKind, kind: ErrorKind,
error: Box<error::Error+Send+Sync>, error: Box<dyn error::Error+Send+Sync>,
} }
/// A list specifying general categories of I/O error. /// A list specifying general categories of I/O error.
@ -250,12 +250,12 @@ impl Error {
/// ``` /// ```
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn new<E>(kind: ErrorKind, error: E) -> Error pub fn new<E>(kind: ErrorKind, error: E) -> Error
where E: Into<Box<error::Error+Send+Sync>> where E: Into<Box<dyn error::Error+Send+Sync>>
{ {
Self::_new(kind, error.into()) Self::_new(kind, error.into())
} }
fn _new(kind: ErrorKind, error: Box<error::Error+Send+Sync>) -> Error { fn _new(kind: ErrorKind, error: Box<dyn error::Error+Send+Sync>) -> Error {
Error { Error {
repr: Repr::Custom(Box::new(Custom { repr: Repr::Custom(Box::new(Custom {
kind, kind,
@ -373,7 +373,7 @@ impl Error {
/// } /// }
/// ``` /// ```
#[stable(feature = "io_error_inner", since = "1.3.0")] #[stable(feature = "io_error_inner", since = "1.3.0")]
pub fn get_ref(&self) -> Option<&(error::Error+Send+Sync+'static)> { pub fn get_ref(&self) -> Option<&(dyn error::Error+Send+Sync+'static)> {
match self.repr { match self.repr {
Repr::Os(..) => None, Repr::Os(..) => None,
Repr::Simple(..) => None, Repr::Simple(..) => None,
@ -444,7 +444,7 @@ impl Error {
/// } /// }
/// ``` /// ```
#[stable(feature = "io_error_inner", since = "1.3.0")] #[stable(feature = "io_error_inner", since = "1.3.0")]
pub fn get_mut(&mut self) -> Option<&mut (error::Error+Send+Sync+'static)> { pub fn get_mut(&mut self) -> Option<&mut (dyn error::Error+Send+Sync+'static)> {
match self.repr { match self.repr {
Repr::Os(..) => None, Repr::Os(..) => None,
Repr::Simple(..) => None, Repr::Simple(..) => None,
@ -478,7 +478,7 @@ impl Error {
/// } /// }
/// ``` /// ```
#[stable(feature = "io_error_inner", since = "1.3.0")] #[stable(feature = "io_error_inner", since = "1.3.0")]
pub fn into_inner(self) -> Option<Box<error::Error+Send+Sync>> { pub fn into_inner(self) -> Option<Box<dyn error::Error+Send+Sync>> {
match self.repr { match self.repr {
Repr::Os(..) => None, Repr::Os(..) => None,
Repr::Simple(..) => None, Repr::Simple(..) => None,
@ -551,7 +551,7 @@ impl error::Error for Error {
} }
} }
fn cause(&self) -> Option<&error::Error> { fn cause(&self) -> Option<&dyn error::Error> {
match self.repr { match self.repr {
Repr::Os(..) => None, Repr::Os(..) => None,
Repr::Simple(..) => None, Repr::Simple(..) => None,

4
src/libstd/io/mod.rs
View file

@ -1972,7 +1972,7 @@ impl<T: BufRead> BufRead for Take<T> {
} }
} }
fn read_one_byte(reader: &mut Read) -> Option<Result<u8>> { fn read_one_byte(reader: &mut dyn Read) -> Option<Result<u8>> {
let mut buf = [0]; let mut buf = [0];
loop { loop {
return match reader.read(&mut buf) { return match reader.read(&mut buf) {
@ -2081,7 +2081,7 @@ impl std_error::Error for CharsError {
CharsError::Other(ref e) => std_error::Error::description(e), CharsError::Other(ref e) => std_error::Error::description(e),
} }
} }
fn cause(&self) -> Option<&std_error::Error> { fn cause(&self) -> Option<&dyn std_error::Error> {
match *self { match *self {
CharsError::NotUtf8 => None, CharsError::NotUtf8 => None,
CharsError::Other(ref e) => e.cause(), CharsError::Other(ref e) => e.cause(),

8
src/libstd/io/stdio.rs
View file

@ -21,7 +21,7 @@ use thread::LocalKey;
/// Stdout used by print! and println! macros /// Stdout used by print! and println! macros
thread_local! { thread_local! {
static LOCAL_STDOUT: RefCell<Option<Box<Write + Send>>> = { static LOCAL_STDOUT: RefCell<Option<Box<dyn Write + Send>>> = {
RefCell::new(None) RefCell::new(None)
} }
} }
@ -624,7 +624,7 @@ impl<'a> fmt::Debug for StderrLock<'a> {
with a more general mechanism", with a more general mechanism",
issue = "0")] issue = "0")]
#[doc(hidden)] #[doc(hidden)]
pub fn set_panic(sink: Option<Box<Write + Send>>) -> Option<Box<Write + Send>> { pub fn set_panic(sink: Option<Box<dyn Write + Send>>) -> Option<Box<dyn Write + Send>> {
use panicking::LOCAL_STDERR; use panicking::LOCAL_STDERR;
use mem; use mem;
LOCAL_STDERR.with(move |slot| { LOCAL_STDERR.with(move |slot| {
@ -648,7 +648,7 @@ pub fn set_panic(sink: Option<Box<Write + Send>>) -> Option<Box<Write + Send>> {
with a more general mechanism", with a more general mechanism",
issue = "0")] issue = "0")]
#[doc(hidden)] #[doc(hidden)]
pub fn set_print(sink: Option<Box<Write + Send>>) -> Option<Box<Write + Send>> { pub fn set_print(sink: Option<Box<dyn Write + Send>>) -> Option<Box<dyn Write + Send>> {
use mem; use mem;
LOCAL_STDOUT.with(move |slot| { LOCAL_STDOUT.with(move |slot| {
mem::replace(&mut *slot.borrow_mut(), sink) mem::replace(&mut *slot.borrow_mut(), sink)
@ -670,7 +670,7 @@ pub fn set_print(sink: Option<Box<Write + Send>>) -> Option<Box<Write + Send>> {
/// However, if the actual I/O causes an error, this function does panic. /// However, if the actual I/O causes an error, this function does panic.
fn print_to<T>( fn print_to<T>(
args: fmt::Arguments, args: fmt::Arguments,
local_s: &'static LocalKey<RefCell<Option<Box<Write+Send>>>>, local_s: &'static LocalKey<RefCell<Option<Box<dyn Write+Send>>>>,
global_s: fn() -> T, global_s: fn() -> T,
label: &str, label: &str,
) )

1
src/libstd/lib.rs
View file

@ -221,6 +221,7 @@
// Don't link to std. We are std. // Don't link to std. We are std.
#![no_std] #![no_std]
#![deny(bare_trait_objects)]
#![deny(missing_docs)] #![deny(missing_docs)]
#![deny(missing_debug_implementations)] #![deny(missing_debug_implementations)]

2
src/libstd/net/parser.rs
View file

@ -61,7 +61,7 @@ impl<'a> Parser<'a> {
} }
// Return result of first successful parser // Return result of first successful parser
fn read_or<T>(&mut self, parsers: &mut [Box<FnMut(&mut Parser) -> Option<T> + 'static>]) fn read_or<T>(&mut self, parsers: &mut [Box<dyn FnMut(&mut Parser) -> Option<T> + 'static>])
-> Option<T> { -> Option<T> {
for pf in parsers { for pf in parsers {
if let Some(r) = self.read_atomically(|p: &mut Parser| pf(p)) { if let Some(r) = self.read_atomically(|p: &mut Parser| pf(p)) {

2
src/libstd/panic.rs
View file

@ -421,6 +421,6 @@ pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
/// } /// }
/// ``` /// ```
#[stable(feature = "resume_unwind", since = "1.9.0")] #[stable(feature = "resume_unwind", since = "1.9.0")]
pub fn resume_unwind(payload: Box<Any + Send>) -> ! { pub fn resume_unwind(payload: Box<dyn Any + Send>) -> ! {
panicking::update_count_then_panic(payload) panicking::update_count_then_panic(payload)
} }

36
src/libstd/panicking.rs
View file

@ -36,7 +36,7 @@ use sys_common::util;
use thread; use thread;
thread_local! { thread_local! {
pub static LOCAL_STDERR: RefCell<Option<Box<Write + Send>>> = { pub static LOCAL_STDERR: RefCell<Option<Box<dyn Write + Send>>> = {
RefCell::new(None) RefCell::new(None)
} }
} }
@ -64,7 +64,7 @@ extern {
#[derive(Copy, Clone)] #[derive(Copy, Clone)]
enum Hook { enum Hook {
Default, Default,
Custom(*mut (Fn(&PanicInfo) + 'static + Sync + Send)), Custom(*mut (dyn Fn(&PanicInfo) + 'static + Sync + Send)),
} }
static HOOK_LOCK: RWLock = RWLock::new(); static HOOK_LOCK: RWLock = RWLock::new();
@ -104,7 +104,7 @@ static mut HOOK: Hook = Hook::Default;
/// panic!("Normal panic"); /// panic!("Normal panic");
/// ``` /// ```
#[stable(feature = "panic_hooks", since = "1.10.0")] #[stable(feature = "panic_hooks", since = "1.10.0")]
pub fn set_hook(hook: Box<Fn(&PanicInfo) + 'static + Sync + Send>) { pub fn set_hook(hook: Box<dyn Fn(&PanicInfo) + 'static + Sync + Send>) {
if thread::panicking() { if thread::panicking() {
panic!("cannot modify the panic hook from a panicking thread"); panic!("cannot modify the panic hook from a panicking thread");
} }
@ -149,7 +149,7 @@ pub fn set_hook(hook: Box<Fn(&PanicInfo) + 'static + Sync + Send>) {
/// panic!("Normal panic"); /// panic!("Normal panic");
/// ``` /// ```
#[stable(feature = "panic_hooks", since = "1.10.0")] #[stable(feature = "panic_hooks", since = "1.10.0")]
pub fn take_hook() -> Box<Fn(&PanicInfo) + 'static + Sync + Send> { pub fn take_hook() -> Box<dyn Fn(&PanicInfo) + 'static + Sync + Send> {
if thread::panicking() { if thread::panicking() {
panic!("cannot modify the panic hook from a panicking thread"); panic!("cannot modify the panic hook from a panicking thread");
} }
@ -197,7 +197,7 @@ fn default_hook(info: &PanicInfo) {
let thread = thread_info::current_thread(); let thread = thread_info::current_thread();
let name = thread.as_ref().and_then(|t| t.name()).unwrap_or("<unnamed>"); let name = thread.as_ref().and_then(|t| t.name()).unwrap_or("<unnamed>");
let write = |err: &mut ::io::Write| { let write = |err: &mut dyn (::io::Write)| {
let _ = writeln!(err, "thread '{}' panicked at '{}', {}", let _ = writeln!(err, "thread '{}' panicked at '{}', {}",
name, msg, location); name, msg, location);
@ -248,7 +248,7 @@ pub fn update_panic_count(amt: isize) -> usize {
pub use realstd::rt::update_panic_count; pub use realstd::rt::update_panic_count;
/// Invoke a closure, capturing the cause of an unwinding panic if one occurs. /// Invoke a closure, capturing the cause of an unwinding panic if one occurs.
pub unsafe fn try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<Any + Send>> { pub unsafe fn try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
#[allow(unions_with_drop_fields)] #[allow(unions_with_drop_fields)]
union Data<F, R> { union Data<F, R> {
f: F, f: F,
@ -369,12 +369,12 @@ fn continue_panic_fmt(info: &PanicInfo) -> ! {
} }
unsafe impl<'a> BoxMeUp for PanicPayload<'a> { unsafe impl<'a> BoxMeUp for PanicPayload<'a> {
fn box_me_up(&mut self) -> *mut (Any + Send) { fn box_me_up(&mut self) -> *mut (dyn Any + Send) {
let contents = mem::replace(self.fill(), String::new()); let contents = mem::replace(self.fill(), String::new());
Box::into_raw(Box::new(contents)) Box::into_raw(Box::new(contents))
} }
fn get(&mut self) -> &(Any + Send) { fn get(&mut self) -> &(dyn Any + Send) {
self.fill() self.fill()
} }
} }
@ -419,15 +419,15 @@ pub fn begin_panic<M: Any + Send>(msg: M, file_line_col: &(&'static str, u32, u3
} }
unsafe impl<A: Send + 'static> BoxMeUp for PanicPayload<A> { unsafe impl<A: Send + 'static> BoxMeUp for PanicPayload<A> {
fn box_me_up(&mut self) -> *mut (Any + Send) { fn box_me_up(&mut self) -> *mut (dyn Any + Send) {
let data = match self.inner.take() { let data = match self.inner.take() {
Some(a) => Box::new(a) as Box<Any + Send>, Some(a) => Box::new(a) as Box<dyn Any + Send>,
None => Box::new(()), None => Box::new(()),
}; };
Box::into_raw(data) Box::into_raw(data)
} }
fn get(&mut self) -> &(Any + Send) { fn get(&mut self) -> &(dyn Any + Send) {
match self.inner { match self.inner {
Some(ref a) => a, Some(ref a) => a,
None => &(), None => &(),
@ -441,7 +441,7 @@ pub fn begin_panic<M: Any + Send>(msg: M, file_line_col: &(&'static str, u32, u3
/// Executes the primary logic for a panic, including checking for recursive /// Executes the primary logic for a panic, including checking for recursive
/// panics, panic hooks, and finally dispatching to the panic runtime to either /// panics, panic hooks, and finally dispatching to the panic runtime to either
/// abort or unwind. /// abort or unwind.
fn rust_panic_with_hook(payload: &mut BoxMeUp, fn rust_panic_with_hook(payload: &mut dyn BoxMeUp,
message: Option<&fmt::Arguments>, message: Option<&fmt::Arguments>,
file_line_col: &(&str, u32, u32)) -> ! { file_line_col: &(&str, u32, u32)) -> ! {
let (file, line, col) = *file_line_col; let (file, line, col) = *file_line_col;
@ -496,17 +496,17 @@ fn rust_panic_with_hook(payload: &mut BoxMeUp,
} }
/// Shim around rust_panic. Called by resume_unwind. /// Shim around rust_panic. Called by resume_unwind.
pub fn update_count_then_panic(msg: Box<Any + Send>) -> ! { pub fn update_count_then_panic(msg: Box<dyn Any + Send>) -> ! {
update_panic_count(1); update_panic_count(1);
struct RewrapBox(Box<Any + Send>); struct RewrapBox(Box<dyn Any + Send>);
unsafe impl BoxMeUp for RewrapBox { unsafe impl BoxMeUp for RewrapBox {
fn box_me_up(&mut self) -> *mut (Any + Send) { fn box_me_up(&mut self) -> *mut (dyn Any + Send) {
Box::into_raw(mem::replace(&mut self.0, Box::new(()))) Box::into_raw(mem::replace(&mut self.0, Box::new(())))
} }
fn get(&mut self) -> &(Any + Send) { fn get(&mut self) -> &(dyn Any + Send) {
&*self.0 &*self.0
} }
} }
@ -517,9 +517,9 @@ pub fn update_count_then_panic(msg: Box<Any + Send>) -> ! {
/// A private no-mangle function on which to slap yer breakpoints. /// A private no-mangle function on which to slap yer breakpoints.
#[no_mangle] #[no_mangle]
#[allow(private_no_mangle_fns)] // yes we get it, but we like breakpoints #[allow(private_no_mangle_fns)] // yes we get it, but we like breakpoints
pub fn rust_panic(mut msg: &mut BoxMeUp) -> ! { pub fn rust_panic(mut msg: &mut dyn BoxMeUp) -> ! {
let code = unsafe { let code = unsafe {
let obj = &mut msg as *mut &mut BoxMeUp; let obj = &mut msg as *mut &mut dyn BoxMeUp;
__rust_start_panic(obj as usize) __rust_start_panic(obj as usize)
}; };
rtabort!("failed to initiate panic, error {}", code) rtabort!("failed to initiate panic, error {}", code)

4
src/libstd/process.rs
View file

@ -813,13 +813,13 @@ impl fmt::Debug for Output {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
let stdout_utf8 = str::from_utf8(&self.stdout); let stdout_utf8 = str::from_utf8(&self.stdout);
let stdout_debug: &fmt::Debug = match stdout_utf8 { let stdout_debug: &dyn fmt::Debug = match stdout_utf8 {
Ok(ref str) => str, Ok(ref str) => str,
Err(_) => &self.stdout Err(_) => &self.stdout
}; };
let stderr_utf8 = str::from_utf8(&self.stderr); let stderr_utf8 = str::from_utf8(&self.stderr);
let stderr_debug: &fmt::Debug = match stderr_utf8 { let stderr_debug: &dyn fmt::Debug = match stderr_utf8 {
Ok(ref str) => str, Ok(ref str) => str,
Err(_) => &self.stderr Err(_) => &self.stderr
}; };

2
src/libstd/rt.rs
View file

@ -29,7 +29,7 @@ pub use panicking::{begin_panic, begin_panic_fmt, update_panic_count};
// To reduce the generated code of the new `lang_start`, this function is doing // To reduce the generated code of the new `lang_start`, this function is doing
// the real work. // the real work.
#[cfg(not(test))] #[cfg(not(test))]
fn lang_start_internal(main: &(Fn() -> i32 + Sync + ::panic::RefUnwindSafe), fn lang_start_internal(main: &(dyn Fn() -> i32 + Sync + ::panic::RefUnwindSafe),
argc: isize, argv: *const *const u8) -> isize { argc: isize, argv: *const *const u8) -> isize {
use panic; use panic;
use sys; use sys;

10
src/libstd/sync/mpsc/mod.rs
View file

@ -1638,7 +1638,7 @@ impl<T: Send> error::Error for SendError<T> {
"sending on a closed channel" "sending on a closed channel"
} }
fn cause(&self) -> Option<&error::Error> { fn cause(&self) -> Option<&dyn error::Error> {
None None
} }
} }
@ -1681,7 +1681,7 @@ impl<T: Send> error::Error for TrySendError<T> {
} }
} }
fn cause(&self) -> Option<&error::Error> { fn cause(&self) -> Option<&dyn error::Error> {
None None
} }
} }
@ -1709,7 +1709,7 @@ impl error::Error for RecvError {
"receiving on a closed channel" "receiving on a closed channel"
} }
fn cause(&self) -> Option<&error::Error> { fn cause(&self) -> Option<&dyn error::Error> {
None None
} }
} }
@ -1742,7 +1742,7 @@ impl error::Error for TryRecvError {
} }
} }
fn cause(&self) -> Option<&error::Error> { fn cause(&self) -> Option<&dyn error::Error> {
None None
} }
} }
@ -1783,7 +1783,7 @@ impl error::Error for RecvTimeoutError {
} }
} }
fn cause(&self) -> Option<&error::Error> { fn cause(&self) -> Option<&dyn error::Error> {
None None
} }
} }

2
src/libstd/sync/mpsc/select.rs
View file

@ -93,7 +93,7 @@ pub struct Handle<'rx, T:Send+'rx> {
next: *mut Handle<'static, ()>, next: *mut Handle<'static, ()>,
prev: *mut Handle<'static, ()>, prev: *mut Handle<'static, ()>,
added: bool, added: bool,
packet: &'rx (Packet+'rx), packet: &'rx (dyn Packet+'rx),
// due to our fun transmutes, we be sure to place this at the end. (nothing // due to our fun transmutes, we be sure to place this at the end. (nothing
// previous relies on T) // previous relies on T)

2
src/libstd/sync/once.rs
View file

@ -301,7 +301,7 @@ impl Once {
#[cold] #[cold]
fn call_inner(&'static self, fn call_inner(&'static self,
ignore_poisoning: bool, ignore_poisoning: bool,
init: &mut FnMut(bool)) { init: &mut dyn FnMut(bool)) {
let mut state = self.state.load(Ordering::SeqCst); let mut state = self.state.load(Ordering::SeqCst);
'outer: loop { 'outer: loop {

2
src/libstd/sys/windows/thread.rs
View file

@ -28,7 +28,7 @@ pub struct Thread {
} }
impl Thread { impl Thread {
pub unsafe fn new<'a>(stack: usize, p: Box<FnBox() + 'a>) pub unsafe fn new<'a>(stack: usize, p: Box<dyn FnBox() + 'a>)
-> io::Result<Thread> { -> io::Result<Thread> {
let p = box p; let p = box p;

4
src/libstd/sys_common/at_exit_imp.rs
View file

@ -17,7 +17,7 @@ use ptr;
use mem; use mem;
use sys_common::mutex::Mutex; use sys_common::mutex::Mutex;
type Queue = Vec<Box<FnBox()>>; type Queue = Vec<Box<dyn FnBox()>>;
// NB these are specifically not types from `std::sync` as they currently rely // NB these are specifically not types from `std::sync` as they currently rely
// on poisoning and this module needs to operate at a lower level than requiring // on poisoning and this module needs to operate at a lower level than requiring
@ -68,7 +68,7 @@ pub fn cleanup() {
} }
} }
pub fn push(f: Box<FnBox()>) -> bool { pub fn push(f: Box<dyn FnBox()>) -> bool {
unsafe { unsafe {
let _guard = LOCK.lock(); let _guard = LOCK.lock();
if init() { if init() {

10
src/libstd/sys_common/backtrace.rs
View file

@ -49,7 +49,7 @@ pub struct Frame {
const MAX_NB_FRAMES: usize = 100; const MAX_NB_FRAMES: usize = 100;
/// Prints the current backtrace. /// Prints the current backtrace.
pub fn print(w: &mut Write, format: PrintFormat) -> io::Result<()> { pub fn print(w: &mut dyn Write, format: PrintFormat) -> io::Result<()> {
static LOCK: Mutex = Mutex::new(); static LOCK: Mutex = Mutex::new();
// Use a lock to prevent mixed output in multithreading context. // Use a lock to prevent mixed output in multithreading context.
@ -62,7 +62,7 @@ pub fn print(w: &mut Write, format: PrintFormat) -> io::Result<()> {
} }
} }
fn _print(w: &mut Write, format: PrintFormat) -> io::Result<()> { fn _print(w: &mut dyn Write, format: PrintFormat) -> io::Result<()> {
let mut frames = [Frame { let mut frames = [Frame {
exact_position: ptr::null(), exact_position: ptr::null(),
symbol_addr: ptr::null(), symbol_addr: ptr::null(),
@ -177,7 +177,7 @@ pub fn log_enabled() -> Option<PrintFormat> {
/// ///
/// These output functions should now be used everywhere to ensure consistency. /// These output functions should now be used everywhere to ensure consistency.
/// You may want to also use `output_fileline`. /// You may want to also use `output_fileline`.
fn output(w: &mut Write, idx: usize, frame: Frame, fn output(w: &mut dyn Write, idx: usize, frame: Frame,
s: Option<&str>, format: PrintFormat) -> io::Result<()> { s: Option<&str>, format: PrintFormat) -> io::Result<()> {
// Remove the `17: 0x0 - <unknown>` line. // Remove the `17: 0x0 - <unknown>` line.
if format == PrintFormat::Short && frame.exact_position == ptr::null() { if format == PrintFormat::Short && frame.exact_position == ptr::null() {
@ -202,7 +202,7 @@ fn output(w: &mut Write, idx: usize, frame: Frame,
/// ///
/// See also `output`. /// See also `output`.
#[allow(dead_code)] #[allow(dead_code)]
fn output_fileline(w: &mut Write, fn output_fileline(w: &mut dyn Write,
file: &[u8], file: &[u8],
line: u32, line: u32,
format: PrintFormat) -> io::Result<()> { format: PrintFormat) -> io::Result<()> {
@ -254,7 +254,7 @@ fn output_fileline(w: &mut Write,
// Note that this demangler isn't quite as fancy as it could be. We have lots // Note that this demangler isn't quite as fancy as it could be. We have lots
// of other information in our symbols like hashes, version, type information, // of other information in our symbols like hashes, version, type information,
// etc. Additionally, this doesn't handle glue symbols at all. // etc. Additionally, this doesn't handle glue symbols at all.
pub fn demangle(writer: &mut Write, mut s: &str, format: PrintFormat) -> io::Result<()> { pub fn demangle(writer: &mut dyn Write, mut s: &str, format: PrintFormat) -> io::Result<()> {
// During ThinLTO LLVM may import and rename internal symbols, so strip out // During ThinLTO LLVM may import and rename internal symbols, so strip out
// those endings first as they're one of the last manglings applied to // those endings first as they're one of the last manglings applied to
// symbol names. // symbol names.

2
src/libstd/sys_common/poison.rs
View file

@ -251,7 +251,7 @@ impl<T> Error for TryLockError<T> {
} }
} }
fn cause(&self) -> Option<&Error> { fn cause(&self) -> Option<&dyn Error> {
match *self { match *self {
TryLockError::Poisoned(ref p) => Some(p), TryLockError::Poisoned(ref p) => Some(p),
_ => None _ => None

2
src/libstd/sys_common/thread.rs
View file

@ -21,7 +21,7 @@ pub unsafe fn start_thread(main: *mut u8) {
let _handler = stack_overflow::Handler::new(); let _handler = stack_overflow::Handler::new();
// Finally, let's run some code. // Finally, let's run some code.
Box::from_raw(main as *mut Box<FnBox()>)() Box::from_raw(main as *mut Box<dyn FnBox()>)()
} }
pub fn min_stack() -> usize { pub fn min_stack() -> usize {

2
src/libstd/thread/mod.rs
View file

@ -1175,7 +1175,7 @@ impl fmt::Debug for Thread {
/// ///
/// [`Result`]: ../../std/result/enum.Result.html /// [`Result`]: ../../std/result/enum.Result.html
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub type Result<T> = ::result::Result<T, Box<Any + Send + 'static>>; pub type Result<T> = ::result::Result<T, Box<dyn Any + Send + 'static>>;
// This packet is used to communicate the return value between the child thread // This packet is used to communicate the return value between the child thread
// and the parent thread. Memory is shared through the `Arc` within and there's // and the parent thread. Memory is shared through the `Arc` within and there's