Add 2 different conversions to Box<dyn Error + Send + Sync + 'static>

Author: dtolnay

src/error.rs

@@ -158,6 +158,7 @@ impl Error {
             #[cfg(anyhow_no_ptr_addr_of)]
             object_mut: object_mut::<E>,
             object_boxed: object_boxed::<E>,
+            object_reallocate_boxed: object_reallocate_boxed::<E>,
             object_downcast: object_downcast::<E>,
             #[cfg(anyhow_no_ptr_addr_of)]
             object_downcast_mut: object_downcast_mut::<E>,
@@ -186,6 +187,7 @@ impl Error {
             #[cfg(all(any(feature = "std", not(anyhow_no_core_error)), anyhow_no_ptr_addr_of))]
             object_mut: object_mut::<MessageError<M>>,
             object_boxed: object_boxed::<MessageError<M>>,
+            object_reallocate_boxed: object_reallocate_boxed::<MessageError<M>>,
             object_downcast: object_downcast::<M>,
             #[cfg(anyhow_no_ptr_addr_of)]
             object_downcast_mut: object_downcast_mut::<M>,
@@ -215,6 +217,7 @@ impl Error {
             #[cfg(all(any(feature = "std", not(anyhow_no_core_error)), anyhow_no_ptr_addr_of))]
             object_mut: object_mut::<DisplayError<M>>,
             object_boxed: object_boxed::<DisplayError<M>>,
+            object_reallocate_boxed: object_reallocate_boxed::<DisplayError<M>>,
             object_downcast: object_downcast::<M>,
             #[cfg(anyhow_no_ptr_addr_of)]
             object_downcast_mut: object_downcast_mut::<M>,
@@ -250,6 +253,7 @@ impl Error {
             #[cfg(anyhow_no_ptr_addr_of)]
             object_mut: object_mut::<ContextError<C, E>>,
             object_boxed: object_boxed::<ContextError<C, E>>,
+            object_reallocate_boxed: object_reallocate_boxed::<ContextError<C, E>>,
             object_downcast: context_downcast::<C, E>,
             #[cfg(anyhow_no_ptr_addr_of)]
             object_downcast_mut: context_downcast_mut::<C, E>,
@@ -279,6 +283,7 @@ impl Error {
             #[cfg(anyhow_no_ptr_addr_of)]
             object_mut: object_mut::<BoxedError>,
             object_boxed: object_boxed::<BoxedError>,
+            object_reallocate_boxed: object_reallocate_boxed::<BoxedError>,
             object_downcast: object_downcast::<Box<dyn StdError + Send + Sync>>,
             #[cfg(anyhow_no_ptr_addr_of)]
             object_downcast_mut: object_downcast_mut::<Box<dyn StdError + Send + Sync>>,
@@ -395,6 +400,7 @@ impl Error {
             #[cfg(all(any(feature = "std", not(anyhow_no_core_error)), anyhow_no_ptr_addr_of))]
             object_mut: object_mut::<ContextError<C, Error>>,
             object_boxed: object_boxed::<ContextError<C, Error>>,
+            object_reallocate_boxed: object_reallocate_boxed::<ContextError<C, Error>>,
             object_downcast: context_chain_downcast::<C>,
             #[cfg(anyhow_no_ptr_addr_of)]
             object_downcast_mut: context_chain_downcast_mut::<C>,
@@ -603,6 +609,94 @@ impl Error {
         }
     }
 
+    /// Convert to a standard library error trait object.
+    ///
+    /// This is implemented as a cheap pointer cast that does not allocate or
+    /// deallocate memory. Like [`anyhow::Error::from_boxed`], it's useful for
+    /// interop with other error libraries.
+    ///
+    /// The same conversion is also available as
+    /// <code style="display:inline;white-space:normal;">impl From&lt;anyhow::Error&gt;
+    /// for Box&lt;dyn Error + Send + Sync + &apos;static&gt;</code>.
+    ///
+    /// If a backtrace was collected during construction of the `anyhow::Error`,
+    /// that backtrace remains accessible using the standard library `Error`
+    /// trait's provider API, but as a consequence, the resulting boxed error
+    /// can no longer be downcast to its original underlying type.
+    ///
+    /// ```
+    #[cfg_attr(not(error_generic_member_access), doc = "# const _: &str = stringify! {")]
+    /// #![feature(error_generic_member_access)]
+    ///
+    /// use anyhow::anyhow;
+    /// use std::backtrace::Backtrace;
+    /// use thiserror::Error;
+    ///
+    /// #[derive(Error, Debug)]
+    /// #[error("...")]
+    /// struct MyError;
+    ///
+    /// let anyhow_error = anyhow!(MyError);
+    /// println!("{}", anyhow_error.backtrace());  // has Backtrace
+    /// assert!(anyhow_error.downcast_ref::<MyError>().is_some());  // can downcast
+    ///
+    /// let boxed_dyn_error = anyhow_error.into_boxed_dyn_error();
+    /// assert!(std::error::request_ref::<Backtrace>(&*boxed_dyn_error).is_some());  // has Backtrace
+    /// assert!(boxed_dyn_error.downcast_ref::<MyError>().is_none());  // can no longer downcast
+    #[cfg_attr(not(error_generic_member_access), doc = "# };")]
+    /// ```
+    ///
+    /// [`anyhow::Error::from_boxed`]: Self::from_boxed
+    pub fn into_boxed_dyn_error(self) -> Box<dyn StdError + Send + Sync + 'static> {
+        let outer = ManuallyDrop::new(self);
+        unsafe {
+            // Use vtable to attach ErrorImpl<E>'s native StdError vtable for
+            // the right original type E.
+            (vtable(outer.inner.ptr).object_boxed)(outer.inner)
+        }
+    }
+
+    /// Convert to a standard library error trait object.
+    ///
+    /// Unlike `self.into_boxed_dyn_error()`, this method relocates the
+    /// underlying error into a new allocation in order to make it downcastable
+    /// to `&E` or `Box<E>` for its original underlying error type. Any
+    /// backtrace collected during construction of the `anyhow::Error` is
+    /// discarded.
+    ///
+    /// ```
+    #[cfg_attr(not(error_generic_member_access), doc = "# const _: &str = stringify! {")]
+    /// #![feature(error_generic_member_access)]
+    ///
+    /// use anyhow::anyhow;
+    /// use std::backtrace::Backtrace;
+    /// use thiserror::Error;
+    ///
+    /// #[derive(Error, Debug)]
+    /// #[error("...")]
+    /// struct MyError;
+    ///
+    /// let anyhow_error = anyhow!(MyError);
+    /// println!("{}", anyhow_error.backtrace());  // has Backtrace
+    /// assert!(anyhow_error.downcast_ref::<MyError>().is_some());  // can downcast
+    ///
+    /// let boxed_dyn_error = anyhow_error.reallocate_into_boxed_dyn_error_without_backtrace();
+    /// assert!(std::error::request_ref::<Backtrace>(&*boxed_dyn_error).is_none());  // Backtrace lost
+    /// assert!(boxed_dyn_error.downcast_ref::<MyError>().is_some());  // can downcast to &MyError
+    /// assert!(boxed_dyn_error.downcast::<MyError>().is_ok());  // can downcast to Box<MyError>
+    #[cfg_attr(not(error_generic_member_access), doc = "# };")]
+    /// ```
+    pub fn reallocate_into_boxed_dyn_error_without_backtrace(
+        self,
+    ) -> Box<dyn StdError + Send + Sync + 'static> {
+        let outer = ManuallyDrop::new(self);
+        unsafe {
+            // Use vtable to attach E's native StdError vtable for the right
+            // original type E.
+            (vtable(outer.inner.ptr).object_reallocate_boxed)(outer.inner)
+        }
+    }
+
     #[cfg(error_generic_member_access)]
     pub(crate) fn provide<'a>(&'a self, request: &mut Request<'a>) {
         unsafe { ErrorImpl::provide(self.inner.by_ref(), request) }
@@ -675,6 +769,7 @@ struct ErrorVTable {
     #[cfg(all(any(feature = "std", not(anyhow_no_core_error)), anyhow_no_ptr_addr_of))]
     object_mut: unsafe fn(Mut<ErrorImpl>) -> &mut (dyn StdError + Send + Sync + 'static),
     object_boxed: unsafe fn(Own<ErrorImpl>) -> Box<dyn StdError + Send + Sync + 'static>,
+    object_reallocate_boxed: unsafe fn(Own<ErrorImpl>) -> Box<dyn StdError + Send + Sync + 'static>,
     object_downcast: unsafe fn(Ref<ErrorImpl>, TypeId) -> Option<Ref<()>>,
     #[cfg(anyhow_no_ptr_addr_of)]
     object_downcast_mut: unsafe fn(Mut<ErrorImpl>, TypeId) -> Option<Mut<()>>,
@@ -744,6 +839,16 @@ where
     unsafe { unerased_own.boxed() }
 }
 
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_reallocate_boxed<E>(e: Own<ErrorImpl>) -> Box<dyn StdError + Send + Sync + 'static>
+where
+    E: StdError + Send + Sync + 'static,
+{
+    // Attach E's native StdError vtable.
+    let unerased_own = e.cast::<ErrorImpl<E>>();
+    Box::new(unsafe { unerased_own.boxed() }._object)
+}
+
 // Safety: requires layout of *e to match ErrorImpl<E>.
 unsafe fn object_downcast<E>(e: Ref<ErrorImpl>, target: TypeId) -> Option<Ref<()>>
 where
@@ -1051,24 +1156,21 @@ where
 impl From<Error> for Box<dyn StdError + Send + Sync + 'static> {
     #[cold]
     fn from(error: Error) -> Self {
-        let outer = ManuallyDrop::new(error);
-        unsafe {
-            // Use vtable to attach ErrorImpl<E>'s native StdError vtable for
-            // the right original type E.
-            (vtable(outer.inner.ptr).object_boxed)(outer.inner)
-        }
+        error.into_boxed_dyn_error()
     }
 }
 
 impl From<Error> for Box<dyn StdError + Send + 'static> {
+    #[cold]
     fn from(error: Error) -> Self {
-        Box::<dyn StdError + Send + Sync>::from(error)
+        error.into_boxed_dyn_error()
     }
 }
 
 impl From<Error> for Box<dyn StdError + 'static> {
+    #[cold]
     fn from(error: Error) -> Self {
-        Box::<dyn StdError + Send + Sync>::from(error)
+        error.into_boxed_dyn_error()
     }
 }