Avoid probing for std in build.rs to support -Z build-std

Author: purplesyringa

Cargo.toml

@@ -33,8 +33,8 @@ harness = false
 level = "warn"
 check-cfg = [
 	"cfg(abort, values(\"std\", \"core\"))",
-	"cfg(backend, values(\"itanium\", \"seh\", \"emscripten\", \"wasm\", \"panic\", \"unimplemented\"))",
-	"cfg(thread_local, values(\"std\", \"attribute\", \"unimplemented\"))",
+	"cfg(backend, values(\"itanium\", \"seh\", \"emscripten\", \"wasm\", \"panic\"))",
+	"cfg(thread_local, values(\"std\", \"attribute\"))",
 ]
 
 [profile.dev]

build.rs

@@ -8,6 +8,14 @@ fn cfg(name: &str) -> String {
     std::env::var(format!("CARGO_CFG_{}", name.to_uppercase())).unwrap_or_default()
 }
 
+fn make_overridable_cfg(name: &str, logic: impl FnOnce() -> &'static str) -> String {
+    let env_name = format!("LITHIUM_{}", name.to_uppercase());
+    println!("cargo::rerun-if-env-changed={env_name}");
+    let value = std::env::var(env_name).unwrap_or_else(|_| logic().to_string());
+    println!("cargo::rustc-cfg={name}=\"{value}\"");
+    value
+}
+
 fn main() {
     println!("cargo::rerun-if-env-changed=MIRIFLAGS");
     let is_miri = has_cfg("miri");
@@ -17,66 +25,49 @@ fn main() {
         println!("cargo::rustc-cfg=feature=\"sound-under-stacked-borrows\"");
     }
 
-    let ac = autocfg::new();
     let is_nightly = version_meta().unwrap().channel == Channel::Nightly;
 
-    // `ac.probe_raw` calls need to be very careful here: under certain configurations, like
-    // `cargo clippy -- -D warnings`, warnigns in the tested snippets can cause probing to give
-    // false negatives. It's important to make sure that, for example, there's no unused items or
-    // variables. See https://github.com/cuviper/autocfg/issues/41.
+    // We've previously used `autocfg` to check if `std` is available, and emitted errors when
+    // compiling without `std` on stable. But that didn't work well: when std is available due to
+    // `-Z build-std`, autocfg doesn't notice it [1], so the tests within this build script would
+    // fail even though using `std` from within the crate would work. So instead, we just assume
+    // that `std` is present if nothing else works -- that leads to worse diagnostics in the failure
+    // case, but makes the common one actually work.
+    //
+    // [1]: https://github.com/cuviper/autocfg/issues/34
 
-    println!("cargo::rerun-if-env-changed=LITHIUM_THREAD_LOCAL");
-    if let Ok(thread_local) = std::env::var("LITHIUM_THREAD_LOCAL") {
-        println!("cargo::rustc-cfg=thread_local=\"{thread_local}\"");
-    } else if is_nightly && has_cfg("target_thread_local") {
-        println!("cargo::rustc-cfg=thread_local=\"attribute\"");
-    } else if ac
-        .probe_raw(
-            r"
-        #![no_std]
-        extern crate std;
-        std::thread_local! {
-            static FOO: () = const {};
+    make_overridable_cfg("thread_local", || {
+        if is_nightly && has_cfg("target_thread_local") {
+            "attribute"
+        } else {
+            "std"
         }
-    ",
-        )
-        .is_ok()
-    {
-        println!("cargo::rustc-cfg=thread_local=\"std\"");
-    } else {
-        println!("cargo::rustc-cfg=thread_local=\"unimplemented\"");
-    }
+    });
 
-    println!("cargo::rerun-if-env-changed=LITHIUM_BACKEND");
-    if let Ok(backend) = std::env::var("LITHIUM_BACKEND") {
-        println!("cargo::rustc-cfg=backend=\"{backend}\"");
-    } else if is_nightly && cfg("target_os") == "emscripten" && !has_cfg("emscripten_wasm_eh") {
-        println!("cargo::rustc-cfg=backend=\"emscripten\"");
-    } else if is_nightly && cfg("target_arch") == "wasm32" {
-        println!("cargo::rustc-cfg=backend=\"wasm\"");
-    } else if is_nightly && (has_cfg("unix") || (has_cfg("windows") && cfg("target_env") == "gnu"))
-    {
-        println!("cargo::rustc-cfg=backend=\"itanium\"");
-    } else if is_nightly && (has_cfg("windows") && cfg("target_env") == "msvc") && !is_miri {
-        println!("cargo::rustc-cfg=backend=\"seh\"");
-    } else if ac
-        .probe_raw(
-            r"
-        #![no_std]
-        extern crate std;
-        pub use std::panic::{catch_unwind, resume_unwind};
-        ",
-        )
-        .is_ok()
-    {
-        println!("cargo::rustc-cfg=backend=\"panic\"");
-    } else {
-        println!("cargo::rustc-cfg=backend=\"unimplemented\"");
-    }
+    let backend = make_overridable_cfg("backend", || {
+        if is_nightly && cfg("target_os") == "emscripten" && !has_cfg("emscripten_wasm_eh") {
+            "emscripten"
+        } else if is_nightly && cfg("target_arch") == "wasm32" {
+            "wasm"
+        } else if is_nightly
+            && (has_cfg("unix") || (has_cfg("windows") && cfg("target_env") == "gnu"))
+        {
+            "itanium"
+        } else if is_nightly && has_cfg("windows") && cfg("target_env") == "msvc" && !is_miri {
+            "seh"
+        } else {
+            "panic"
+        }
+    });
 
-    if ac
-        .probe_raw(
-            r#"
+    // Since the panic backend can use `abort` and is available on stable, we need to set
+    // `abort = "std"` whenever the panic backend is used, even if we don't readily know if `std` is
+    // available. But that's fine, since the panic backend requires `std` anyway.
+    let ac = autocfg::new();
+    if backend == "panic"
+        || ac
+            .probe_raw(
+                r#"
         #![no_std]
         extern crate std;
         use std::io::Write;
@@ -85,8 +76,8 @@ fn main() {
             std::process::abort();
         }
     "#,
-        )
-        .is_ok()
+            )
+            .is_ok()
     {
         println!("cargo::rustc-cfg=abort=\"std\"");
     } else {

src/backend/mod.rs

@@ -177,10 +177,6 @@ mod imp;
 #[path = "wasm.rs"]
 mod imp;
 
-#[cfg(backend = "unimplemented")]
-#[path = "unimplemented.rs"]
-mod imp;
-
 pub(crate) use imp::ActiveBackend;
 
 #[cfg(test)]

src/backend/unimplemented.rs

@@ -57,10 +57,11 @@
 //! Lithium strives to support all targets that Rust panics support. If Lithium does not work
 //! correctly on such a target, please [open an issue](https://github.com/iex-rs/lithium/issues/).
 //!
-//! On nightly, Lithium can work without `std` on certain platforms that expose native thread
-//! locals and link in an Itanium-style unwinder. Such situations are best handled on a case-by-case
-//! basis: [open an issue](https://github.com/iex-rs/lithium/issues/) if you would like to see
-//! support for a certain `std`-less target.
+//! On nightly exclusively, Lithium can work without `std` on certain platforms that expose native
+//! thread locals and link in an Itanium-style unwinder, such as `x86_64-unknown-linux-gnu`. Such
+//! situations are best handled on a case-by-case basis:
+//! [open an issue](https://github.com/iex-rs/lithium/issues/) if you would like to see support for
+//! a certain `std`-less target.
 //!
 //!
 //! # Safety
@@ -288,12 +289,7 @@ pub use api::{InFlightException, catch, intercept, throw};
 /// Abort the process with a message.
 ///
 /// If `std` is available, this also outputs a message to stderr before aborting.
-#[cfg(any(
-    backend = "itanium",
-    backend = "seh",
-    backend = "emscripten",
-    backend = "wasm"
-))]
+#[allow(dead_code, reason = "not used by all backends")]
 #[cold]
 #[inline(never)]
 fn abort(message: &str) -> ! {
@@ -304,9 +300,8 @@ fn abort(message: &str) -> ! {
         std::process::abort();
     }
 
-    // This is a nightly-only method, but all three backends this is enabled under require nightly
-    // anyway, so this is no big deal.
-    #[cfg(not(abort = "std"))]
+    // This is a nightly-only method, but build.rs sets `abort = "std"` for stable backends.
+    #[cfg(abort = "core")]
     {
         let _ = message;
         core::intrinsics::abort();

src/lib.rs

@@ -165,9 +165,6 @@ unsafe fn get_stack() -> &'static Stack<Header> {
     // SAFETY: We require the caller to not use the reference anywhere near the end of the thread,
     // so if `&STACK` is sound in the first place, there is no problem.
     return unsafe { core::mem::transmute::<&Stack<Header>, &'static Stack<Header>>(&STACK) };
-
-    #[cfg(thread_local = "unimplemented")]
-    compile_error!("Unable to compile Lithium on a platform does not support thread locals")
 }
 
 const fn get_alloc_size<E>() -> usize {