Fix compile probe and nightly backtraces

Cargo.toml

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

README.md

@@ -122,9 +122,12 @@ avoid using `eyre::Report` as your public error type.
   }
   ```
 
-- If using the nightly channel, a backtrace is captured and printed with the
-  error if the underlying error type does not already provide its own. In order
-  to see backtraces, they must be enabled through the environment variables
+- If using rust >1.65, a backtrace is captured and printed with the
+  error.
+
+  On nightly eyre will use the underlying error's backtrace if it has one.
+
+  In order to see backtraces, they must be enabled through the environment variables
   described in [`std::backtrace`]:
 
   - If you want panics and errors to both have backtraces, set
@@ -141,7 +144,7 @@ avoid using `eyre::Report` as your public error type.
 - Eyre works with any error type that has an impl of `std::error::Error`,
   including ones defined in your crate. We do not bundle a `derive(Error)` macro
   but you can write the impls yourself or use a standalone macro like
-  [thiserror].
+  [thiserror](https://github.com/dtolnay/thiserror).
 
   ```rust
   use thiserror::Error;
@@ -178,6 +181,15 @@ No-std support was removed in 2020 in [commit 608a16a] due to unaddressed upstre
 [commit 608a16a]:
 https://github.com/eyre-rs/eyre/pull/29/commits/608a16aa2c2c27eca6c88001cc94c6973c18f1d5
 
+
+## Backtrace support
+
+The built in default handler has support for capturing backtrace using `rustc-1.65` or later.
+
+Backtraces are captured when an error is converted to an `eyre::Report` (such as using `?` or `eyre!`).
+
+If using the nightly toolchain, backtraces will also be captured and accessed from other errors using [error_generic_member_access](https://github.com/rust-lang/rfcs/pull/2895) if available.
+
 ## Comparison to failure
 
 The `eyre::Report` type works something like `failure::Error`, but unlike
@@ -195,8 +207,6 @@ you need an error type that can be handled via match or reported. This is
 common in library crates where you don't know how your users will handle
 your errors.
 
-[thiserror]: https://github.com/dtolnay/thiserror
-
 ## Compatibility with `anyhow`
 
 This crate does its best to be usable as a drop in replacement of `anyhow` and

eyre/Cargo.toml

@@ -23,6 +23,9 @@ indenter = { workspace = true }
 once_cell = { workspace = true }
 pyo3 = { version = "0.20", optional = true, default-features = false }
 
+[build-dependencies]
+autocfg = { workspace = true }
+
 [dev-dependencies]
 futures = { version = "0.3", default-features = false }
 rustversion = "1.0"

eyre/build.rs

@@ -1,23 +1,53 @@
-use std::env;
-use std::ffi::OsString;
-use std::fs;
-use std::path::Path;
-use std::process::{Command, ExitStatus};
-use std::str;
-
-// This code exercises the surface area that we expect of the std Backtrace
-// type. If the current toolchain is able to compile it, we go ahead and use
-// backtrace in eyre.
-const BACKTRACE_PROBE: &str = r#"
-    #![feature(backtrace)]
+use std::{
+    env, fs,
+    path::Path,
+    process::{Command, ExitStatus},
+};
+
+fn main() {
+    let ac = autocfg::new();
+
+    // https://github.com/rust-lang/rust/issues/99301 [nightly]
+    //
+    // Autocfg does currently not support custom probes, or `nightly` only features
+    match compile_probe(GENERIC_MEMBER_ACCESS_PROBE) {
+        Some(status) if status.success() => autocfg::emit("generic_member_access"),
+        _ => {}
+    }
+
+    // https://github.com/rust-lang/rust/issues/47809 [rustc-1.46]
+    ac.emit_expression_cfg("std::panic::Location::caller", "track_caller");
+
+    if ac.probe_rustc_version(1, 52) {
+        autocfg::emit("eyre_no_fmt_arguments_as_str");
+    }
+
+    if ac.probe_rustc_version(1, 58) {
+        autocfg::emit("eyre_no_fmt_args_capture");
+    }
+
+    if ac.probe_rustc_version(1, 65) {
+        autocfg::emit("backtrace")
+    }
+}
+
+// This code exercises the surface area or the generic member access feature for the `std::error::Error` trait.
+//
+// This is use to detect and supply backtrace information through different errors types.
+const GENERIC_MEMBER_ACCESS_PROBE: &str = r#"
+    #![feature(error_generic_member_access)]
     #![allow(dead_code)]
 
-    use std::backtrace::{Backtrace, BacktraceStatus};
-    use std::error::Error;
+    use std::error::{Error, Request};
     use std::fmt::{self, Display};
 
     #[derive(Debug)]
-    struct E;
+    struct E { 
+        backtrace: MyBacktrace,
+    }
+
+    #[derive(Debug)]
+    struct MyBacktrace;
 
     impl Display for E {
         fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -26,59 +56,44 @@ const BACKTRACE_PROBE: &str = r#"
     }
 
     impl Error for E {
-        fn backtrace(&self) -> Option<&Backtrace> {
-            let backtrace = Backtrace::capture();
-            match backtrace.status() {
-                BacktraceStatus::Captured | BacktraceStatus::Disabled | _ => {}
-            }
-            unimplemented!()
+        fn provide<'a>(&'a self, request: &mut Request<'a>) {
+            request
+                .provide_ref::<MyBacktrace>(&self.backtrace);
         }
     }
 "#;
 
-const TRACK_CALLER_PROBE: &str = r#"
-    #![allow(dead_code)]
-
-    #[track_caller]
-    fn foo() {
-        let _location = std::panic::Location::caller();
-    }
-"#;
-
-fn main() {
-    match compile_probe(BACKTRACE_PROBE) {
-        Some(status) if status.success() => println!("cargo:rustc-cfg=backtrace"),
-        _ => {}
-    }
-
-    match compile_probe(TRACK_CALLER_PROBE) {
-        Some(status) if status.success() => println!("cargo:rustc-cfg=track_caller"),
-        _ => {}
-    }
+fn compile_probe(probe: &str) -> Option<ExitStatus> {
+    let rustc = env::var_os("RUSTC")?;
+    let out_dir = env::var_os("OUT_DIR")?;
+    let probefile = Path::new(&out_dir).join("probe.rs");
+    fs::write(&probefile, probe).ok()?;
 
-    let version = match rustc_version_info() {
-        Some(version) => version,
-        None => return,
-    };
+    let rustc_wrapper = env::var_os("RUSTC_WRAPPER").filter(|wrapper| !wrapper.is_empty());
+    let rustc_workspace_wrapper =
+        env::var_os("RUSTC_WORKSPACE_WRAPPER").filter(|wrapper| !wrapper.is_empty());
+    let mut rustc = rustc_wrapper
+        .into_iter()
+        .chain(rustc_workspace_wrapper)
+        .chain(std::iter::once(rustc));
 
-    version.toolchain.set_feature();
+    let mut cmd = Command::new(rustc.next().unwrap());
+    cmd.args(rustc);
 
-    if version.minor < 52 {
-        println!("cargo:rustc-cfg=eyre_no_fmt_arguments_as_str");
+    if let Some(target) = env::var_os("TARGET") {
+        cmd.arg("--target").arg(target);
     }
 
-    if version.minor < 58 {
-        println!("cargo:rustc-cfg=eyre_no_fmt_args_capture");
+    // If Cargo wants to set RUSTFLAGS, use that.
+    if let Ok(rustflags) = env::var("CARGO_ENCODED_RUSTFLAGS") {
+        if !rustflags.is_empty() {
+            for arg in rustflags.split('\x1f') {
+                cmd.arg(arg);
+            }
+        }
     }
-}
 
-fn compile_probe(probe: &str) -> Option<ExitStatus> {
-    let rustc = env::var_os("RUSTC")?;
-    let out_dir = env::var_os("OUT_DIR")?;
-    let probefile = Path::new(&out_dir).join("probe.rs");
-    fs::write(&probefile, probe).ok()?;
-    Command::new(rustc)
-        .arg("--edition=2018")
+    cmd.arg("--edition=2018")
         .arg("--crate-name=eyre_build")
         .arg("--crate-type=lib")
         .arg("--emit=metadata")
@@ -88,45 +103,3 @@ fn compile_probe(probe: &str) -> Option<ExitStatus> {
         .status()
         .ok()
 }
-
-// TODO factor this toolchain parsing and related tests into its own file
-#[derive(PartialEq)]
-enum Toolchain {
-    Stable,
-    Beta,
-    Nightly,
-}
-impl Toolchain {
-    fn set_feature(self) {
-        match self {
-            Toolchain::Nightly => println!("cargo:rustc-cfg=nightly"),
-            Toolchain::Beta => println!("cargo:rustc-cfg=beta"),
-            Toolchain::Stable => println!("cargo:rustc-cfg=stable"),
-        }
-    }
-}
-
-struct VersionInfo {
-    minor: u32,
-    toolchain: Toolchain,
-}
-
-fn rustc_version_info() -> Option<VersionInfo> {
-    let rustc = env::var_os("RUSTC").unwrap_or_else(|| OsString::from("rustc"));
-    let output = Command::new(rustc).arg("--version").output().ok()?;
-    let version = str::from_utf8(&output.stdout).ok()?;
-    let mut pieces = version.split(['.', ' ', '-']);
-    if pieces.next() != Some("rustc") {
-        return None;
-    }
-    let _major: u32 = pieces.next()?.parse().ok()?;
-    let minor = pieces.next()?.parse().ok()?;
-    let _patch: u32 = pieces.next()?.parse().ok()?;
-    let toolchain = match pieces.next() {
-        Some("beta") => Toolchain::Beta,
-        Some("nightly") => Toolchain::Nightly,
-        _ => Toolchain::Stable,
-    };
-    let version = VersionInfo { minor, toolchain };
-    Some(version)
-}

eyre/src/backtrace.rs

@@ -1,22 +1,36 @@
 #[cfg(backtrace)]
 pub(crate) use std::backtrace::Backtrace;
 
 #[cfg(not(backtrace))]
 pub(crate) enum Backtrace {}
 
 #[cfg(backtrace)]
+macro_rules! capture_backtrace {
+    () => {
+        Some(Backtrace::capture())
+    };
+}
+
+#[cfg(not(backtrace))]
+macro_rules! capture_backtrace {
+    () => {
+        None
+    };
+}
+/// Capture a backtrace iff there is not already a backtrace in the error chain
+#[cfg(generic_member_access)]
 macro_rules! backtrace_if_absent {
     ($err:expr) => {
-        match $err.backtrace() {
+        match std::error::request_ref::<std::backtrace::Backtrace>($err as &dyn std::error::Error) {
             Some(_) => None,
-            None => Some(Backtrace::capture()),
+            None => capture_backtrace!(),
         }
     };
 }
 
-#[cfg(not(backtrace))]
+#[cfg(not(generic_member_access))]
 macro_rules! backtrace_if_absent {
     ($err:expr) => {
-        None
+        capture_backtrace!()
     };
 }

eyre/src/context.rs

@@ -2,9 +2,6 @@ use crate::error::{ContextError, ErrorImpl};
 use crate::{Report, StdError, WrapErr};
 use core::fmt::{self, Debug, Display, Write};
 
-#[cfg(backtrace)]
-use std::backtrace::Backtrace;
-
 mod ext {
     use super::*;
 
@@ -139,9 +136,9 @@ where
     D: Display,
     E: StdError + 'static,
 {
-    #[cfg(backtrace)]
-    fn backtrace(&self) -> Option<&Backtrace> {
-        self.error.backtrace()
+    #[cfg(generic_member_access)]
+    fn provide<'a>(&'a self, request: &mut std::error::Request<'a>) {
+        self.error.provide(request);
     }
 
     fn source(&self) -> Option<&(dyn StdError + 'static)> {

eyre/src/error.rs

@@ -855,6 +855,11 @@ impl<E> StdError for ErrorImpl<E>
 where
     E: StdError,
 {
+    #[cfg(generic_member_access)]
+    fn provide<'a>(&'a self, request: &mut std::error::Request<'a>) {
+        self._object.provide(request)
+    }
+
     fn source(&self) -> Option<&(dyn StdError + 'static)> {
         ErrorImpl::<()>::error(self.erase()).source()
     }

eyre/src/lib.rs

@@ -330,7 +330,7 @@
 //! [`color-backtrace`]: https://github.com/athre0z/color-backtrace
 #![doc(html_root_url = "https://docs.rs/eyre/0.6.11")]
 #![cfg_attr(
     nightly,
     feature(rustdoc_missing_doc_code_examples),
     warn(rustdoc::missing_doc_code_examples)
 )]
@@ -355,8 +355,8 @@
     unused_parens,
     while_true
 )]
-#![cfg_attr(backtrace, feature(backtrace))]
+#![cfg_attr(generic_member_access, feature(error_generic_member_access))]
 #![cfg_attr(doc_cfg, feature(doc_cfg))]
 #![allow(
     clippy::needless_doctest_main,
     clippy::new_ret_no_self,
@@ -599,8 +599,8 @@
     HOOK.set(hook).map_err(|_| InstallError)
 }
 
 #[cfg_attr(track_caller, track_caller)]
 #[cfg_attr(not(track_caller), allow(unused_mut))]
 fn capture_handler(error: &(dyn StdError + 'static)) -> Box<dyn EyreHandler> {
     #[cfg(not(feature = "auto-install"))]
     let hook = HOOK
@@ -636,7 +636,7 @@
         t == concrete
     }
 
-    /// Downcast the handler to a concrete type `T`
+    /// Downcast the handler to a concrete type
     pub fn downcast_ref<T: EyreHandler>(&self) -> Option<&T> {
         if self.is::<T>() {
             unsafe { Some(&*(self as *const dyn EyreHandler as *const T)) }
@@ -645,7 +645,7 @@
         }
     }
 
-    /// Downcast the handler to a concrete type `T`
+    /// Downcast the handler to a concrete type
     pub fn downcast_mut<T: EyreHandler>(&mut self) -> Option<&mut T> {
         if self.is::<T>() {
             unsafe { Some(&mut *(self as *mut dyn EyreHandler as *mut T)) }
@@ -778,6 +778,7 @@
     #[allow(unused_variables)]
     #[cfg_attr(not(feature = "auto-install"), allow(dead_code))]
     pub fn default_with(error: &(dyn StdError + 'static)) -> Box<dyn EyreHandler> {
+        // Capture the backtrace if the source error did not already capture one
         let backtrace = backtrace_if_absent!(error);
 
         Box::new(Self {
@@ -837,15 +838,19 @@
             }
         }
 
-        #[cfg(backtrace)]
+        #[cfg(generic_member_access)]
         {
             use std::backtrace::BacktraceStatus;
 
+            // The backtrace can be stored either in the handler instance, or the error itself.
+            //
+            // If the source error has a backtrace, the handler should not capture one
             let backtrace = self
                 .backtrace
                 .as_ref()
-                .or_else(|| error.backtrace())
+                .or_else(|| std::error::request_ref::<Backtrace>(error))
                 .expect("backtrace capture failed");
+
             if let BacktraceStatus::Captured = backtrace.status() {
                 write!(f, "\n\nStack backtrace:\n{}", backtrace)?;
             }