Proof of concept of dyn dispatch based report handler

Cargo.toml

@@ -20,6 +20,9 @@ rustversion = "1.0"
 thiserror = "1.0"
 trybuild = { version = "1.0.19", features = ["diff"] }
 
+[dependencies]
+once_cell = "1.4.0"
+
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
 rustdoc-args = ["--cfg", "doc_cfg"]

src/error.rs

@@ -190,9 +190,13 @@ impl Error {
     where
         E: StdError + Send + Sync + 'static,
     {
+        let handler =
+            crate::HOOK.get_or_init(|| Box::new(|_| Box::new(crate::DefaultHandler)))(&error);
+
         let inner = Box::new(ErrorImpl {
             vtable,
             backtrace,
+            handler,
             _object: error,
         });
         // Erase the concrete type of E from the compile-time type system. This
@@ -310,6 +314,14 @@ impl Error {
         self.inner.backtrace()
     }
 
+    pub fn handler(&self) -> &dyn crate::ReportHandler {
+        self.inner.handler()
+    }
+
+    pub fn handler_mut(&mut self) -> &mut dyn crate::ReportHandler {
+        self.inner.handler_mut()
+    }
+
     /// An iterator of the chain of source errors contained by this Error.
     ///
     /// This iterator will visit every error in the cause chain of this error
@@ -681,6 +693,7 @@ where
 pub(crate) struct ErrorImpl<E> {
     vtable: &'static ErrorVTable,
     backtrace: Option<Backtrace>,
+    handler: Box<dyn crate::ReportHandler + Send + Sync + 'static>,
     // NOTE: Don't use directly. Use only through vtable. Erased type may have
     // different alignment.
     _object: E,
@@ -728,6 +741,14 @@ impl ErrorImpl<()> {
             .expect("backtrace capture failed")
     }
 
+    pub(crate) fn handler(&self) -> &dyn crate::ReportHandler {
+        self.handler.as_ref()
+    }
+
+    pub(crate) fn handler_mut(&mut self) -> &mut dyn crate::ReportHandler {
+        self.handler.as_mut()
+    }
+
     pub(crate) fn chain(&self) -> Chain {
         Chain::new(self.error())
     }

src/fmt.rs

@@ -1,6 +1,6 @@
 use crate::chain::Chain;
 use crate::error::ErrorImpl;
-use core::fmt::{self, Debug, Write};
+use core::fmt::{self, Write};
 
 impl ErrorImpl<()> {
     pub(crate) fn display(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -17,9 +17,20 @@ impl ErrorImpl<()> {
 
     pub(crate) fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let error = self.error();
+        let handler = self.handler();
 
+        handler.report(error, f)
+    }
+}
+
+impl crate::ReportHandler for crate::DefaultHandler {
+    fn report(
+        &self,
+        error: &(dyn crate::StdError + 'static),
+        f: &mut core::fmt::Formatter<'_>,
+    ) -> core::fmt::Result {
         if f.alternate() {
-            return Debug::fmt(error, f);
+            return core::fmt::Debug::fmt(error, f);
         }
 
         write!(f, "{}", error)?;

src/lib.rs

@@ -247,6 +247,7 @@ trait StdError: Debug + Display {
 }
 
 pub use anyhow as format_err;
+use once_cell::sync::OnceCell;
 
 /// The `Error` type, a wrapper around a dynamic error type.
 ///
@@ -584,6 +585,59 @@ pub trait Context<T, E>: context::private::Sealed {
         F: FnOnce() -> C;
 }
 
+static HOOK: OnceCell<ErrorHook> = OnceCell::new();
+
+pub trait ReportHandler: core::any::Any {
+    fn report(
+        &self,
+        error: &(dyn StdError + 'static),
+        f: &mut core::fmt::Formatter<'_>,
+    ) -> core::fmt::Result;
+}
+
+type ErrorHook = Box<
+    dyn Fn(&(dyn StdError + 'static)) -> Box<dyn ReportHandler + Send + Sync + 'static>
+        + Sync
+        + Send
+        + 'static,
+>;
+
+pub fn set_hook(hook: ErrorHook) -> Result<(), Box<dyn StdError + Send + Sync + 'static>> {
+    HOOK.set(hook)
+        .map_err(|_| "unable to set global hook".into())
+}
+
+impl dyn ReportHandler {
+    pub fn is<T: ReportHandler>(&self) -> bool {
+        // Get `TypeId` of the type this function is instantiated with.
+        let t = core::any::TypeId::of::<T>();
+
+        // Get `TypeId` of the type in the trait object (`self`).
+        let concrete = self.type_id();
+
+        // Compare both `TypeId`s on equality.
+        t == concrete
+    }
+
+    pub fn downcast_ref<T: ReportHandler>(&self) -> Option<&T> {
+        if self.is::<T>() {
+            unsafe { Some(&*(self as *const dyn ReportHandler as *const T)) }
+        } else {
+            None
+        }
+    }
+
+    pub fn downcast_mut<T: ReportHandler>(&mut self) -> Option<&mut T> {
+        if self.is::<T>() {
+            unsafe { Some(&mut *(self as *mut dyn ReportHandler as *mut T)) }
+        } else {
+            None
+        }
+    }
+}
+
+struct DefaultHandler;
+
 // Not public API. Referenced by macro-generated code.
 #[doc(hidden)]
 pub mod private {

tests/test_handler.rs

@@ -0,0 +1,50 @@
+struct CustomHandler {
+    msg: &'static str,
+}
+
+impl anyhow::ReportHandler for CustomHandler {
+    fn report(
+        &self,
+        _error: &(dyn std::error::Error + 'static),
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::fmt::Result {
+        write!(f, "{}", self.msg)
+    }
+}
+
+static EXPECTED: &str = "hook is set!";
+
+#[test]
+fn test_custom_hook() {
+    // discard the result because the tests in the same file race against
+    // eachother to set the global hook and one will panic
+    let _ = anyhow::set_hook(Box::new(move |_error| {
+        Box::new(CustomHandler { msg: EXPECTED })
+    }));
+
+    let report = anyhow::anyhow!("heres the message!");
+    let actual = format!("{:?}", report);
+
+    assert_eq!(EXPECTED, actual);
+}
+
+#[test]
+fn test_mutable_hook() {
+    let real_expected = "the context was modified!";
+
+    // discard the result because the tests in the same file race against
+    // eachother to set the global hook and one will panic
+    let _ = anyhow::set_hook(Box::new(move |_error| {
+        Box::new(CustomHandler { msg: EXPECTED })
+    }));
+
+    let mut report = anyhow::anyhow!("heres the message!");
+    report
+        .handler_mut()
+        .downcast_mut::<CustomHandler>()
+        .unwrap()
+        .msg = real_expected;
+    let actual = format!("{:?}", report);
+
+    assert_eq!(real_expected, actual);
+}

tests/test_macros.rs

@@ -11,6 +11,7 @@ fn test_messages() {
 }
 
 #[test]
+#[allow(clippy::eq_op)]
 fn test_ensure() {
     let f = || {
         ensure!(1 + 1 == 2, "This is correct");