feat: support converting between anyhow::Error and eyre::Result

Cargo.toml

@@ -17,6 +17,7 @@ rust-version = "1.65.0"
 indenter = "0.3.0"
 once_cell = "1.18.0"
 owo-colors = "4.0"
+anyhow = "1.0"
 
 [profile.dev.package.backtrace]
 opt-level = 3

eyre/Cargo.toml

@@ -13,23 +13,22 @@ readme = { workspace = true }
 rust-version = { workspace = true }
 
 [features]
-default = ["anyhow", "auto-install", "track-caller"]
-anyhow = []
+default = [ "auto-install", "track-caller"]
 auto-install = []
 track-caller = []
 
 [dependencies]
 indenter = { workspace = true }
 once_cell = { workspace = true }
 pyo3 = { version = "0.20", optional = true, default-features = false }
+anyhow = { workspace = true, optional = true, default-features = false }
 
 [dev-dependencies]
 futures = { version = "0.3", default-features = false }
 rustversion = "1.0"
 thiserror = "1.0"
 trybuild = { version = "=1.0.89", features = ["diff"] } # pinned due to MSRV
 backtrace = "0.3.46"
-anyhow = "1.0.28"
 syn = { version = "2.0", features = ["full"] }
 pyo3 = { version = "0.20", default-features = false, features = ["auto-initialize"] }
 

eyre/src/error.rs

@@ -8,6 +8,7 @@ use core::mem::{self, ManuallyDrop};
 use core::ptr::{self, NonNull};
 
 use core::ops::{Deref, DerefMut};
+use std::any::Any;
 
 impl Report {
     /// Create a new error object from any error type.
@@ -490,14 +491,33 @@ impl Report {
 
 impl<E> From<E> for Report
 where
-    E: StdError + Send + Sync + 'static,
+    E: 'static + Into<anyhow::Error>,
+    Result<(), E>: anyhow::Context<(), E>,
 {
-    #[cfg_attr(track_caller, track_caller)]
-    fn from(error: E) -> Self {
-        Report::from_std(error)
+    fn from(value: E) -> Self {
+        let mut value = Some(value);
+        let e = &mut value as &mut dyn Any;
+
+        if let Some(e) = e.downcast_mut::<Option<anyhow::Error>>() {
+            let e: Box<dyn StdError + Send + Sync> = e.take().unwrap().into();
+            Report::from_boxed(e)
+        } else {
+            let e: Box<dyn StdError + Send + Sync> = value.take().unwrap().into().into();
+            Report::from_boxed(e)
+        }
     }
 }
 
+// impl<E> From<E> for Report
+// where
+//     E: StdError + Send + Sync + 'static,
+// {
+//     #[cfg_attr(track_caller, track_caller)]
+//     fn from(error: E) -> Self {
+//         Report::from_std(error)
+//     }
+// }
+
 impl Deref for Report {
     type Target = dyn StdError + Send + Sync + 'static;
 

eyre/tests/test_anyhow.rs

@@ -0,0 +1,55 @@
+use eyre::Report;
+use std::fmt::Display;
+
+#[derive(Debug)]
+struct RootError;
+
+impl Display for RootError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "RootError")
+    }
+}
+
+impl std::error::Error for RootError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        None
+    }
+}
+
+fn this_function_fails() -> anyhow::Result<()> {
+    use anyhow::Context;
+
+    Err(RootError).context("Ouch!").context("Anyhow context A")
+}
+
+fn bubble() -> eyre::Result<()> {
+    use anyhow::Context;
+    this_function_fails().context("Anyhow context B")?;
+
+    Ok(())
+}
+
+#[test]
+fn anyhow_conversion() {
+    use eyre::WrapErr;
+    let error: Report = bubble().wrap_err("Eyre context").unwrap_err();
+
+    eprintln!("Error: {:?}", error);
+
+    let chain = error.chain().map(ToString::to_string).collect::<Vec<_>>();
+    assert_eq!(
+        chain,
+        [
+            "Eyre context",
+            // Anyhow context
+            "Anyhow context B",
+            "Anyhow context A",
+            // Anyhow error
+            "Ouch!",
+            // Original concrete error, shows up in chain too
+            "RootError"
+        ]
+    );
+
+    // let error = Report::msg("A").wrap_err("B").wrap_err("C");
+}