Make all nightly go through the module that was probed

Author: dtolnay

build.rs

@@ -15,7 +15,7 @@ compile_error! {
 fn main() {
     let mut error_generic_member_access = false;
     if cfg!(feature = "std") {
-        println!("cargo:rerun-if-changed=build/probe.rs");
+        println!("cargo:rerun-if-changed=src/nightly.rs");
 
         let consider_rustc_bootstrap;
         if compile_probe(false) {
@@ -68,6 +68,7 @@ fn main() {
     };
 
     if rustc >= 80 {
+        println!("cargo:rustc-check-cfg=cfg(anyhow_build_probe)");
         println!("cargo:rustc-check-cfg=cfg(anyhow_nightly_testing)");
         println!("cargo:rustc-check-cfg=cfg(anyhow_no_core_error)");
         println!("cargo:rustc-check-cfg=cfg(anyhow_no_core_unwind_safe)");
@@ -128,7 +129,7 @@ fn compile_probe(rustc_bootstrap: bool) -> bool {
     let rustc = cargo_env_var("RUSTC");
     let out_dir = cargo_env_var("OUT_DIR");
     let out_subdir = Path::new(&out_dir).join("probe");
-    let probefile = Path::new("build").join("probe.rs");
+    let probefile = Path::new("src").join("nightly.rs");
 
     if let Err(err) = fs::create_dir(&out_subdir) {
         if err.kind() != ErrorKind::AlreadyExists {
@@ -152,6 +153,7 @@ fn compile_probe(rustc_bootstrap: bool) -> bool {
     }
 
     cmd.stderr(Stdio::null())
+        .arg("--cfg=anyhow_build_probe")
         .arg("--edition=2018")
         .arg("--crate-name=anyhow")
         .arg("--crate-type=lib")

build/probe.rs

@@ -38,8 +38,7 @@ macro_rules! backtrace {
 #[cfg(error_generic_member_access)]
 macro_rules! backtrace_if_absent {
     ($err:expr) => {
-        match core::error::request_ref::<std::backtrace::Backtrace>($err as &dyn core::error::Error)
-        {
+        match $crate::nightly::request_ref_backtrace($err as &dyn core::error::Error) {
             Some(_) => None,
             None => backtrace!(),
         }

src/backtrace.rs

@@ -4,7 +4,7 @@ use core::convert::Infallible;
 use core::fmt::{self, Debug, Display, Write};
 
 #[cfg(error_generic_member_access)]
-use core::error::Request;
+use crate::nightly::{self, Request};
 
 mod ext {
     use super::*;
@@ -145,7 +145,7 @@ where
 
     #[cfg(error_generic_member_access)]
     fn provide<'a>(&'a self, request: &mut Request<'a>) {
-        StdError::provide(&self.error, request);
+        nightly::provide(&self.error, request);
     }
 }
 

src/context.rs

@@ -1,13 +1,13 @@
 use crate::backtrace::Backtrace;
 use crate::chain::Chain;
+#[cfg(error_generic_member_access)]
+use crate::nightly::{self, Request};
 #[cfg(any(feature = "std", not(anyhow_no_core_error), anyhow_no_ptr_addr_of))]
 use crate::ptr::Mut;
 use crate::ptr::{Own, Ref};
 use crate::{Error, StdError};
 use alloc::boxed::Box;
 use core::any::TypeId;
-#[cfg(error_generic_member_access)]
-use core::error::{self, Request};
 use core::fmt::{self, Debug, Display};
 use core::mem::ManuallyDrop;
 #[cfg(any(feature = "std", not(anyhow_no_core_error)))]
@@ -995,7 +995,7 @@ impl ErrorImpl {
             .as_ref()
             .or_else(|| {
                 #[cfg(error_generic_member_access)]
-                return error::request_ref::<Backtrace>(unsafe { Self::error(this) });
+                return nightly::request_ref_backtrace(unsafe { Self::error(this) });
                 #[cfg(not(error_generic_member_access))]
                 return unsafe { (vtable(this.ptr).object_backtrace)(this) };
             })
@@ -1005,9 +1005,9 @@ impl ErrorImpl {
     #[cfg(error_generic_member_access)]
     unsafe fn provide<'a>(this: Ref<'a, Self>, request: &mut Request<'a>) {
         if let Some(backtrace) = unsafe { &this.deref().backtrace } {
-            request.provide_ref(backtrace);
+            nightly::provide_ref_backtrace(request, backtrace);
         }
-        unsafe { Self::error(this) }.provide(request);
+        nightly::provide(unsafe { Self::error(this) }, request);
     }
 
     #[cold]

src/error.rs

@@ -260,6 +260,8 @@ mod error;
 mod fmt;
 mod kind;
 mod macros;
+#[cfg(error_generic_member_access)]
+mod nightly;
 mod ptr;
 mod wrapper;
 

src/lib.rs

@@ -0,0 +1,58 @@
+// This code exercises the surface area that we expect of the Error generic
+// member access API. If the current toolchain is able to compile it, then
+// anyhow is able to provide backtrace support.
+
+#![cfg_attr(anyhow_build_probe, feature(error_generic_member_access))]
+
+use core::error::{self, Error};
+use std::backtrace::Backtrace;
+
+pub use core::error::Request;
+
+#[cfg(anyhow_build_probe)]
+const _: () = {
+    use core::fmt::{self, Debug, Display};
+
+    struct MyError(Backtrace);
+
+    impl Debug for MyError {
+        fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
+            unimplemented!()
+        }
+    }
+
+    impl Display for MyError {
+        fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
+            unimplemented!()
+        }
+    }
+
+    impl Error for MyError {
+        fn provide<'a>(&'a self, request: &mut Request<'a>) {
+            provide_ref_backtrace(request, &self.0);
+        }
+    }
+};
+
+// Include in sccache cache key.
+#[cfg(anyhow_build_probe)]
+const _: Option<&str> = option_env!("RUSTC_BOOTSTRAP");
+
+pub fn request_ref_backtrace(err: &dyn Error) -> Option<&Backtrace> {
+    request_ref::<Backtrace>(err)
+}
+
+fn request_ref<'a, T>(err: &'a (impl Error + ?Sized)) -> Option<&'a T>
+where
+    T: 'static + ?Sized,
+{
+    error::request_ref::<T>(err)
+}
+
+pub fn provide_ref_backtrace<'a>(request: &mut Request<'a>, backtrace: &'a Backtrace) {
+    Request::provide_ref(request, backtrace);
+}
+
+pub fn provide<'a>(err: &'a (impl Error + ?Sized), request: &mut Request<'a>) {
+    Error::provide(err, request);
+}

src/nightly.rs

@@ -5,7 +5,7 @@ use core::fmt::{self, Debug, Display};
 use alloc::boxed::Box;
 
 #[cfg(error_generic_member_access)]
-use core::error::Request;
+use crate::nightly::{self, Request};
 
 #[repr(transparent)]
 pub struct MessageError<M>(pub M);
@@ -79,6 +79,6 @@ impl StdError for BoxedError {
 
     #[cfg(error_generic_member_access)]
     fn provide<'a>(&'a self, request: &mut Request<'a>) {
-        self.0.provide(request);
+        nightly::provide(&*self.0, request);
     }
 }