feat: probe for windows nightly

Author: demosdemon

.github/workflows/ci.yml

@@ -51,18 +51,6 @@ jobs:
           - stable
           - beta
           - nightly
-        exclude:
-          # Windows builds depend on an unstable feature: windows_process_exit_code_from
-          # TODO: find a better way to handle this for windows without nightly
-          - os: windows-latest
-            rust:
-              - '1.86'
-              - '1.87'
-              - '1.88'
-              - '1.89'
-              - '1.90'
-              - stable
-              - beta
     runs-on: ${{ matrix.os }}
     env:
       RUSTFLAGS: "-D warnings"

crates/git-remote-codecommit/build.rs

@@ -23,54 +23,75 @@ macro_rules! die {
 fn main() {
     println!("cargo:rustc-check-cfg=cfg(build_feature_probe)");
     println!("cargo:rustc-check-cfg=cfg(bool_to_result)");
-    println!("cargo:rerun-if-changed=src/nightly.rs");
-
-    let bool_to_result;
-    let consider_rustc_bootstrap;
-    if compile_probe(false) {
-        // This is a nightly or dev compiler, so it supports unstable
-        // features regardless of RUSTC_BOOTSTRAP. No need to rerun build
-        // script if RUSTC_BOOTSTRAP is changed.
-        bool_to_result = true;
-        consider_rustc_bootstrap = false;
-    } else if let Some(rustc_bootstrap) = std::env::var_os("RUSTC_BOOTSTRAP") {
-        if compile_probe(true) {
-            // This is a stable or beta compiler for which the user has set
-            // RUSTC_BOOTSTRAP to turn on unstable features. Rerun build
-            // script if they change it.
-            bool_to_result = true;
-            consider_rustc_bootstrap = true;
-        } else if rustc_bootstrap == "1" {
-            // This compiler does not support the generic member access API
-            // in the form that anyhow expects. No need to pay attention to
-            // RUSTC_BOOTSTRAP.
-            bool_to_result = false;
-            consider_rustc_bootstrap = false;
-        } else {
-            // This is a stable or beta compiler for which RUSTC_BOOTSTRAP
-            // is set to restrict the use of unstable features by this
-            // crate.
-            bool_to_result = false;
-            consider_rustc_bootstrap = true;
-        }
-    } else {
-        // Without RUSTC_BOOTSTRAP, this compiler does not support the
-        // unstable features this crate uses, but try again if the user turns on
-        // unstable features.
-        bool_to_result = false;
-        consider_rustc_bootstrap = true;
-    }
+    println!("cargo:rustc-check-cfg=cfg(windows_process_exit_code_from)");
+    println!("cargo:rerun-if-changed=src/nightly/mod.rs");
+    println!("cargo:rerun-if-changed=src/nightly/bool_or.rs");
+    println!("cargo:rerun-if-changed=src/nightly/windows_process_exit_code.rs");
+
+    let CompilerProbeResult {
+        supported: bool_to_result,
+        consider_rustc_bootstrap,
+    } = compiler_probe("bool_or.rs");
 
     if bool_to_result {
         println!("cargo:rustc-cfg=bool_to_result");
     }
 
+    #[cfg(windows)]
+    let consider_rustc_bootstrap = {
+        let CompilerProbeResult {
+            supported,
+            consider_rustc_bootstrap: consider_rustc_bootstrap_windows,
+        } = compiler_probe("windows_process_exit_code.rs");
+        if supported {
+            println!("cargo:rustc-cfg=windows_process_exit_code_from");
+        }
+
+        consider_rustc_bootstrap || consider_rustc_bootstrap_windows
+    };
+
     if consider_rustc_bootstrap {
         println!("cargo:rerun-if-env-changed=RUSTC_BOOTSTRAP");
     }
 }
 
-fn compile_probe(rustc_bootstrap: bool) -> bool {
+struct CompilerProbeResult {
+    supported: bool,
+    consider_rustc_bootstrap: bool,
+}
+
+fn compiler_probe(filename: impl AsRef<Path>) -> CompilerProbeResult {
+    if compile_probe(&filename, false) {
+        CompilerProbeResult {
+            supported: true,
+            consider_rustc_bootstrap: false,
+        }
+    } else if let Some(rustc_bootstrap) = std::env::var_os("RUSTC_BOOTSTRAP") {
+        if compile_probe("bool_or.rs", true) {
+            CompilerProbeResult {
+                supported: true,
+                consider_rustc_bootstrap: true,
+            }
+        } else if rustc_bootstrap == "1" {
+            CompilerProbeResult {
+                supported: false,
+                consider_rustc_bootstrap: false,
+            }
+        } else {
+            CompilerProbeResult {
+                supported: false,
+                consider_rustc_bootstrap: true,
+            }
+        }
+    } else {
+        CompilerProbeResult {
+            supported: false,
+            consider_rustc_bootstrap: true,
+        }
+    }
+}
+
+fn compile_probe(filename: impl AsRef<Path>, rustc_bootstrap: bool) -> bool {
     if std::env::var_os("RUSTC_STAGE").is_some() {
         println!("cargo:rerun-if-env-changed=RUSTC_STAGE");
         // We are running inside rustc bootstrap. This is a highly non-standard
@@ -89,7 +110,7 @@ fn compile_probe(rustc_bootstrap: bool) -> bool {
     let out_subdir = Path::new(&out_dir).join(probe_dir);
     mkdir(&out_subdir);
 
-    let probefile = Path::new("src").join("nightly.rs");
+    let probefile = Path::new("src").join("nightly").join(filename);
 
     let mut cmd = rustc_command();
 

crates/git-remote-codecommit/src/main.rs

@@ -1,4 +1,7 @@
-#![cfg_attr(windows, feature(windows_process_exit_code_from))]
+#![cfg_attr(
+    windows_process_exit_code_from,
+    feature(windows_process_exit_code_from)
+)]
 #![cfg_attr(bool_to_result, feature(bool_to_result))]
 
 mod canonical_request;
@@ -144,13 +147,13 @@ fn exec_replace(mut cmd: std::process::Command) -> anyhow::Result<ExitCode> {
 fn exec_replace(mut cmd: std::process::Command) -> anyhow::Result<ExitCode> {
     #![expect(unsafe_code)]
 
-    use std::os::windows::process::ExitCodeExt;
-
     use windows_sys::Win32::Foundation::FALSE;
     use windows_sys::Win32::Foundation::TRUE;
     use windows_sys::Win32::System::Console::SetConsoleCtrlHandler;
     use windows_sys::core::BOOL;
 
+    use crate::nightly::ExitCodeExt;
+
     unsafe extern "system" fn ctrlc_handler(_: u32) -> BOOL {
         // Do nothing; let the child process handle it.
         TRUE

crates/git-remote-codecommit/src/nightly.rs renamed to crates/git-remote-codecommit/src/nightly/bool_or.rs

@@ -0,0 +1,13 @@
+#[cfg(not(build_feature_probe))]
+mod bool_or;
+
+#[cfg(all(windows, not(build_feature_probe)))]
+mod windows_process_exit_code;
+
+#[cfg(all(windows, windows_process_exit_code_from))]
+pub(crate) use std::os::windows::process::ExitCodeExt;
+
+#[cfg(not(bool_to_result))]
+pub(crate) use self::bool_or::BoolExt;
+#[cfg(all(windows, not(windows_process_exit_code_from)))]
+pub(crate) use self::windows_process_exit_code::ExitCodeExt;

crates/git-remote-codecommit/src/nightly/mod.rs

@@ -0,0 +1,29 @@
+#![cfg_attr(build_feature_probe, feature(windows_process_exit_code_from))]
+
+#[cfg(build_feature_probe)]
+const _: () = {
+    use std::process::ExitCode;
+
+    fn _probe() -> std::process::ExitCode {
+        std::os::windows::process::ExitCodeExt::from_raw(0_u32)
+    }
+};
+
+#[cfg(build_feature_probe)]
+const _: Option<&str> = option_env!("RUSTC_BOOTSTRAP");
+
+#[cfg(not(windows_process_exit_code_from))]
+pub(crate) trait ExitCodeExt {
+    fn from_raw(code: u32) -> Self;
+}
+
+#[cfg(not(windows_process_exit_code_from))]
+impl ExitCodeExt for std::process::ExitCode {
+    fn from_raw(code: u32) -> Self {
+        if (code & 0xff) == code {
+            std::process::ExitCode::from((code & 0xff) as u8)
+        } else {
+            std::process::ExitCode::FAILURE
+        }
+    }
+}