spirv-builder: make required extra arg -Zjson-target-spec backwards compatible

Author: Firestar99

crates/rustc_codegen_spirv-types/src/target_spec.rs

@@ -7,8 +7,9 @@ use std::path::Path;
 /// The version listed in the enum is always the minimum version to require said target spec, with the newest version
 /// always at the top.
 #[allow(non_camel_case_types)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub enum TargetSpecVersion {
+    Older,
     /// Introduced in `489c3ee6fd63da3ca7cf2b15e1ee709d8e078aab` in the old v2 target spec way, later ported to here.
     /// remove `os: unknown`, add `crt-static-respected: true`
     Rustc_1_85_0,
@@ -18,6 +19,24 @@ pub enum TargetSpecVersion {
     Rustc_1_76_0,
     /// rustc 1.93 requires that the value of "target-pointer-width" is no longer a string but u16
     Rustc_1_93_0,
+    /// rustc 1.94.0 destabilised json target specs, requiring `-Ztarget-spec-json`
+    /// see <https://github.com/Rust-GPU/rust-gpu/pull/545>
+    /// see <https://github.com/rust-lang/rust/pull/150151>
+    Rustc_1_94_0,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct TargetSpec {
+    pub target: OsString,
+    pub extra_options: Vec<OsString>,
+}
+
+impl TargetSpec {
+    pub fn append_to_cmd(&self, cmd: &mut std::process::Command) {
+        cmd.args(self.extra_options.iter());
+        cmd.arg("--target");
+        cmd.arg(&self.target);
+    }
 }
 
 impl TargetSpecVersion {
@@ -27,38 +46,50 @@ impl TargetSpecVersion {
         rustc_version: Version,
         target: &SpirvTarget,
         target_spec_folder: &Path,
-    ) -> std::io::Result<OsString> {
-        if let Some(target_spec) = Self::from_rustc_version(rustc_version) {
+    ) -> std::io::Result<TargetSpec> {
+        let mut ret = TargetSpec::default();
+        let target_spec = Self::from_rustc_version(rustc_version);
+        if target_spec >= Self::Rustc_1_94_0 {
+            ret.extra_options.push("-Zjson-target-spec".into());
+        }
+
+        ret.target = if target_spec == Self::Older {
+            target.target().into()
+        } else {
             std::fs::create_dir_all(target_spec_folder)?;
             let spec_file = target_spec_folder.join(format!("{}.json", target.target()));
             std::fs::write(&spec_file, target_spec.format_spec(target))?;
-            Ok(std::fs::canonicalize(spec_file)?.into_os_string())
-        } else {
-            Ok(OsString::from(target.target()))
-        }
+            std::fs::canonicalize(spec_file)?.into_os_string()
+        };
+        Ok(ret)
     }
 
     /// Returns the version of the target spec required for a certain rustc version. May return `None` if the version
     /// is old enough to not need target specs.
-    pub fn from_rustc_version(rustc_version: Version) -> Option<Self> {
-        if rustc_version >= Version::new(1, 93, 0) {
-            Some(Self::Rustc_1_93_0)
+    pub fn from_rustc_version(rustc_version: Version) -> Self {
+        if rustc_version >= Version::new(1, 94, 0) {
+            Self::Rustc_1_94_0
+        } else if rustc_version >= Version::new(1, 93, 0) {
+            Self::Rustc_1_93_0
         } else if rustc_version >= Version::new(1, 85, 0) {
-            Some(Self::Rustc_1_85_0)
+            Self::Rustc_1_85_0
         } else if rustc_version >= Version::new(1, 76, 0) {
-            Some(Self::Rustc_1_76_0)
+            Self::Rustc_1_76_0
         } else {
-            None
+            Self::Older
         }
     }
 
     /// format the target spec json
     pub fn format_spec(&self, target: &SpirvTarget) -> String {
         let target_env = target.env();
         let (extra, target_pointer_width) = match self {
+            TargetSpecVersion::Older => panic!("no target specs for older rustc versions"),
             TargetSpecVersion::Rustc_1_76_0 => (r#""os": "unknown","#, "\"32\""),
             TargetSpecVersion::Rustc_1_85_0 => (r#""crt-static-respected": true,"#, "\"32\""),
-            TargetSpecVersion::Rustc_1_93_0 => (r#""crt-static-respected": true,"#, "32"),
+            TargetSpecVersion::Rustc_1_93_0 | TargetSpecVersion::Rustc_1_94_0 => {
+                (r#""crt-static-respected": true,"#, "32")
+            }
         };
         format!(
             r#"{{

crates/spirv-builder/src/lib.rs

@@ -1046,14 +1046,8 @@ fn invoke_rustc(builder: &SpirvBuilder) -> Result<PathBuf, SpirvBuilderError> {
     }
 
     let target_spec_dir = target_dir.join("target-specs");
-    let target = TargetSpecVersion::target_arg(toolchain_rustc_version, &target, &target_spec_dir)?;
-    if Path::new(&target)
-        .extension()
-        .is_some_and(|ext| ext == "json")
-    {
-        cargo.arg("-Zjson-target-spec");
-    }
-    cargo.arg("--target").arg(target);
+    let target_spec = TargetSpecVersion::target_arg(toolchain_rustc_version, &target, &target_spec_dir)?;
+    target_spec.append_to_cmd(&mut cargo);
 
     if !builder.shader_crate_features.default_features {
         cargo.arg("--no-default-features");

tests/compiletests/src/main.rs

@@ -1,7 +1,7 @@
 use clap::Parser;
+use compiletest::common::Mode;
 use itertools::Itertools as _;
-use rustc_codegen_spirv_types::{SpirvTarget, TargetSpecVersion, query_rustc_version};
-use std::ffi::OsString;
+use rustc_codegen_spirv_types::{SpirvTarget, TargetSpec, TargetSpecVersion, query_rustc_version};
 use std::{
     env, io,
     path::{Path, PathBuf},
@@ -79,7 +79,7 @@ fn main() {
         codegen_backend_path,
     };
 
-    runner.run_mode("ui");
+    runner.run_mode(Mode::Ui);
 }
 
 struct Runner {
@@ -94,7 +94,7 @@ impl Runner {
     /// Runs the given `mode` on the directory that matches that name, using the
     /// backend provided by `codegen_backend_path`.
     #[allow(clippy::string_add)]
-    fn run_mode(&self, mode: &'static str) {
+    fn run_mode(&self, mode: Mode) {
         /// RUSTFLAGS passed to all test files.
         fn test_rustc_flags(
             codegen_backend_path: &Path,
@@ -157,7 +157,12 @@ impl Runner {
             println!("Testing env: {stage_id}\n");
 
             let target = SpirvTarget::parse(env).unwrap();
-            let libs = self.build_deps(&target);
+            let rustc_version = query_rustc_version(None).unwrap();
+            let target_spec =
+                TargetSpecVersion::target_arg(rustc_version, &target, &self.deps_target_dir)
+                    .unwrap();
+
+            let libs = self.build_deps(&target, &target_spec);
             let mut flags = test_rustc_flags(
                 &self.codegen_backend_path,
                 &libs,
@@ -175,9 +180,9 @@ impl Runner {
             let config = compiletest::Config {
                 stage_id,
                 target_rustcflags: Some(flags),
-                mode: mode.parse().expect("Invalid mode"),
-                target: self.target_spec_json(&target).into_string().unwrap(),
-                src_base: self.tests_dir.join(mode),
+                mode,
+                target: target_spec.target.into_string().unwrap(),
+                src_base: self.tests_dir.join(mode.to_string()),
                 build_base: self.compiletest_build_dir.clone(),
                 bless: self.opt.bless,
                 filters: self.opt.filters.clone(),
@@ -191,20 +196,18 @@ impl Runner {
     }
 
     /// Runs the processes needed to build `spirv-std` & other deps.
-    fn build_deps(&self, target: &SpirvTarget) -> TestDeps {
+    fn build_deps(&self, target: &SpirvTarget, target_spec: &TargetSpec) -> TestDeps {
         // Build compiletests-deps-helper
-        std::process::Command::new("cargo")
-            .args([
-                "build",
-                "-p",
-                "compiletests-deps-helper",
-                "-Zjson-target-spec",
-                "-Zbuild-std=core",
-                "-Zbuild-std-features=compiler-builtins-mem",
-                "--target",
-            ])
-            .arg(self.target_spec_json(target))
-            .arg("--target-dir")
+        let mut cmd = std::process::Command::new("cargo");
+        cmd.args([
+            "build",
+            "-p",
+            "compiletests-deps-helper",
+            "-Zbuild-std=core",
+            "-Zbuild-std-features=compiler-builtins-mem",
+        ]);
+        target_spec.append_to_cmd(&mut cmd);
+        cmd.arg("--target-dir")
             .arg(&self.deps_target_dir)
             .env("RUSTFLAGS", rust_flags(&self.codegen_backend_path))
             .stderr(std::process::Stdio::inherit())
@@ -242,7 +245,7 @@ impl Runner {
                 "warning: cleaning deps ({missing_count} missing libs, {duplicate_count} duplicated libs)"
             );
             self.clean_deps();
-            self.build_deps(target)
+            self.build_deps(target, target_spec)
         } else {
             TestDeps {
                 core: core.ok().unwrap(),
@@ -259,17 +262,10 @@ impl Runner {
             .arg("clean")
             .arg("--target-dir")
             .arg(&self.deps_target_dir)
-            .stderr(std::process::Stdio::inherit())
-            .stdout(std::process::Stdio::inherit())
             .status()
             .and_then(map_status_to_result)
             .unwrap();
     }
-
-    fn target_spec_json(&self, target: &SpirvTarget) -> OsString {
-        let rustc_version = query_rustc_version(None).unwrap();
-        TargetSpecVersion::target_arg(rustc_version, target, &self.deps_target_dir).unwrap()
-    }
 }
 
 enum FindLibError {