Do what the machine tells me to do

Author: infinity0

Cargo.lock.ci

@@ -6,11 +6,11 @@ homepage = "https://rust-lang-nursery.github.io/failure/"
 license = "MIT OR Apache-2.0"
 name = "failure"
 repository = "https://github.com/rust-lang-nursery/failure"
-version = "0.1.5"
+version = "0.1.6"
 
 [dependencies.failure_derive]
 optional = true
-version = "0.1.5"
+version = "0.1.6"
 path = "./failure_derive"
 
 [dependencies.backtrace]

Cargo.toml

@@ -8,20 +8,20 @@ use Fail;
 /// custom cause.
 pub trait AsFail {
     /// Converts a reference to `Self` into a dynamic trait object of `Fail`.
-    fn as_fail(&self) -> &Fail;
+    fn as_fail(&self) -> &dyn Fail;
 }
 
 impl<T> AsFail for T
 where
     T: Fail,
 {
-    fn as_fail(&self) -> &Fail {
+    fn as_fail(&self) -> &dyn Fail {
         self
     }
 }
 
-impl AsFail for Fail {
-    fn as_fail(&self) -> &Fail {
+impl AsFail for dyn Fail {
+    fn as_fail(&self) -> &dyn Fail {
         self
     }
 }
@@ -30,7 +30,7 @@ with_std! {
     use error::Error;
 
     impl AsFail for Error {
-        fn as_fail(&self) -> &Fail {
+        fn as_fail(&self) -> &dyn Fail {
             self.as_fail()
         }
     }

src/as_fail.rs

@@ -2,7 +2,7 @@ use std::error::Error;
 use std::fmt;
 use Fail;
 
-pub struct BoxStd(pub Box<Error + Send + Sync + 'static>);
+pub struct BoxStd(pub Box<dyn Error + Send + Sync + 'static>);
 
 impl fmt::Display for BoxStd {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

src/box_std.rs

@@ -39,14 +39,14 @@ with_std! {
         }
     }
 
-    impl From<Error> for Box<StdError> {
-        fn from(error: Error) -> Box<StdError> {
+    impl From<Error> for Box<dyn StdError> {
+        fn from(error: Error) -> Box<dyn StdError> {
             Box::new(Compat { error })
         }
     }
 
-    impl From<Error> for Box<StdError + Send + Sync> {
-        fn from(error: Error) -> Box<StdError + Send + Sync> {
+    impl From<Error> for Box<dyn StdError + Send + Sync> {
+        fn from(error: Error) -> Box<dyn StdError + Send + Sync> {
             Box::new(Compat { error })
         }
     }

src/compat.rs

@@ -112,7 +112,7 @@ with_std! {
             self.failure.as_cause().and_then(|x| x.name())
         }
 
-        fn cause(&self) -> Option<&Fail> {
+        fn cause(&self) -> Option<&dyn Fail> {
             self.failure.as_cause()
         }
 
@@ -146,7 +146,7 @@ with_std! {
             }
         }
 
-        fn as_cause(&self) -> Option<&Fail> {
+        fn as_cause(&self) -> Option<&dyn Fail> {
             match *self {
                 Either::This(_)         => None,
                 Either::That(ref error) => Some(error.as_fail())

src/context.rs

@@ -4,7 +4,7 @@ use Fail;
 use backtrace::Backtrace;
 
 pub(crate) struct ErrorImpl {
-    inner: Box<Inner<Fail>>,
+    inner: Box<Inner<dyn Fail>>,
 }
 
 struct Inner<F: ?Sized + Fail> {
@@ -25,11 +25,11 @@ impl<F: Fail> From<F> for ErrorImpl {
 }
 
 impl ErrorImpl {
-    pub(crate) fn failure(&self) -> &Fail {
+    pub(crate) fn failure(&self) -> &dyn Fail {
         &self.inner.failure
     }
 
-    pub(crate) fn failure_mut(&mut self) -> &mut Fail {
+    pub(crate) fn failure_mut(&mut self) -> &mut dyn Fail {
         &mut self.inner.failure
     }
 

src/error/error_impl.rs

@@ -60,13 +60,13 @@ impl Error {
     /// }
     /// ```
     #[cfg(feature = "std")]
-    pub fn from_boxed_compat(err: Box<StdError + Sync + Send + 'static>) -> Error {
+    pub fn from_boxed_compat(err: Box<dyn StdError + Sync + Send + 'static>) -> Error {
         Error::from(BoxStd(err))
     }
 
     /// Return a reference to the underlying failure that this `Error`
     /// contains.
-    pub fn as_fail(&self) -> &Fail {
+    pub fn as_fail(&self) -> &dyn Fail {
         self.imp.failure()
     }
 
@@ -82,7 +82,7 @@ impl Error {
     /// This method has been deprecated in favor of the [Error::as_fail] method,
     /// which does the same thing.
     #[deprecated(since = "0.1.2", note = "please use 'as_fail()' method instead")]
-    pub fn cause(&self) -> &Fail {
+    pub fn cause(&self) -> &dyn Fail {
         self.as_fail()
     }
 
@@ -133,7 +133,7 @@ impl Error {
 
     /// Returns the "root cause" of this error - the last value in the
     /// cause chain which does not return an underlying `cause`.
-    pub fn find_root_cause(&self) -> &Fail {
+    pub fn find_root_cause(&self) -> &dyn Fail {
         self.as_fail().find_root_cause()
     }
 
@@ -173,7 +173,7 @@ impl Error {
 
     /// Deprecated alias to `find_root_cause`.
     #[deprecated(since = "0.1.2", note = "please use the 'find_root_cause()' method instead")]
-    pub fn root_cause(&self) -> &Fail {
+    pub fn root_cause(&self) -> &dyn Fail {
         ::find_root_cause(self.as_fail())
     }
 
@@ -201,8 +201,8 @@ impl Debug for Error {
     }
 }
 
-impl AsRef<Fail> for Error {
-    fn as_ref(&self) -> &Fail {
+impl AsRef<dyn Fail> for Error {
+    fn as_ref(&self) -> &dyn Fail {
         self.as_fail()
     }
 }

src/error/mod.rs

@@ -126,7 +126,7 @@ pub trait Fail: Display + Debug + Send + Sync + 'static {
     /// `Some` when it can return a **different** failure. Users may loop
     /// over the cause chain, and returning `self` would result in an infinite
     /// loop.
-    fn cause(&self) -> Option<&Fail> {
+    fn cause(&self) -> Option<&dyn Fail> {
         None
     }
 
@@ -186,7 +186,7 @@ pub trait Fail: Display + Debug + Send + Sync + 'static {
         since = "0.1.2",
         note = "please use the 'find_root_cause()' method instead"
     )]
-    fn root_cause(&self) -> &Fail
+    fn root_cause(&self) -> &dyn Fail
     where
         Self: Sized,
     {
@@ -199,13 +199,13 @@ pub trait Fail: Display + Debug + Send + Sync + 'static {
     }
 }
 
-impl Fail {
+impl dyn Fail {
     /// Attempts to downcast this failure to a concrete type by reference.
     ///
     /// If the underlying error is not of type `T`, this will return `None`.
     pub fn downcast_ref<T: Fail>(&self) -> Option<&T> {
         if self.__private_get_type_id__() == TypeId::of::<T>() {
-            unsafe { Some(&*(self as *const Fail as *const T)) }
+            unsafe { Some(&*(self as *const dyn Fail as *const T)) }
         } else {
             None
         }
@@ -217,7 +217,7 @@ impl Fail {
     /// If the underlying error is not of type `T`, this will return `None`.
     pub fn downcast_mut<T: Fail>(&mut self) -> Option<&mut T> {
         if self.__private_get_type_id__() == TypeId::of::<T>() {
-            unsafe { Some(&mut *(self as *mut Fail as *mut T)) }
+            unsafe { Some(&mut *(self as *mut dyn Fail as *mut T)) }
         } else {
             None
         }
@@ -231,7 +231,7 @@ impl Fail {
     ///
     /// This is equivalent to iterating over `iter_causes()` and taking
     /// the last item.
-    pub fn find_root_cause(&self) -> &Fail {
+    pub fn find_root_cause(&self) -> &dyn Fail {
         find_root_cause(self)
     }
 
@@ -258,7 +258,7 @@ impl Fail {
         since = "0.1.2",
         note = "please use the 'find_root_cause()' method instead"
     )]
-    pub fn root_cause(&self) -> &Fail {
+    pub fn root_cause(&self) -> &dyn Fail {
         find_root_cause(self)
     }
 
@@ -273,8 +273,8 @@ impl Fail {
 impl<E: StdError + Send + Sync + 'static> Fail for E {}
 
 #[cfg(feature = "std")]
-impl Fail for Box<Fail> {
-    fn cause(&self) -> Option<&Fail> {
+impl Fail for Box<dyn Fail> {
+    fn cause(&self) -> Option<&dyn Fail> {
         (**self).cause()
     }
 
@@ -285,20 +285,20 @@ impl Fail for Box<Fail> {
 
 /// A iterator over the causes of a `Fail`
 pub struct Causes<'f> {
-    fail: Option<&'f Fail>,
+    fail: Option<&'f dyn Fail>,
 }
 
 impl<'f> Iterator for Causes<'f> {
-    type Item = &'f Fail;
-    fn next(&mut self) -> Option<&'f Fail> {
+    type Item = &'f dyn Fail;
+    fn next(&mut self) -> Option<&'f dyn Fail> {
         self.fail.map(|fail| {
             self.fail = fail.cause();
             fail
         })
     }
 }
 
-fn find_root_cause(mut fail: &Fail) -> &Fail {
+fn find_root_cause(mut fail: &dyn Fail) -> &dyn Fail {
     while let Some(cause) = fail.cause() {
         fail = cause;
     }

src/lib.rs

@@ -12,12 +12,12 @@ fn return_failure() -> Result<(), failure::Error> {
     Err(err.into())
 }
 
-fn return_error() -> Result<(), Box<std::error::Error>> {
+fn return_error() -> Result<(), Box<dyn std::error::Error>> {
     return_failure()?;
     Ok(())
 }
 
-fn return_error_send_sync() -> Result<(), Box<std::error::Error + Send + Sync>> {
+fn return_error_send_sync() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     return_failure()?;
     Ok(())
 }