target-spec: add Target type

Author: Firestar99

Cargo.lock

@@ -13,3 +13,4 @@ rspirv = "0.12"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 semver = { version = "1.0.24", features = ["serde"] }
+thiserror = "2.0.12"

crates/rustc_codegen_spirv-types/Cargo.toml

@@ -4,9 +4,11 @@ pub use rspirv::spirv::Capability;
 
 mod compile_result;
 mod rustc_version;
+mod target;
 mod target_spec;
 pub use compile_result::*;
 pub use rustc_version::*;
+pub use target::*;
 pub use target_spec::*;
 
 // HACK(eddyb) allows downstream crates to access the correct version directly.

crates/rustc_codegen_spirv-types/src/lib.rs

@@ -0,0 +1,73 @@
+use std::fmt::{Debug, Formatter};
+use thiserror::Error;
+
+pub const SPIRV_TARGET_PREFIX: &str = "spirv-unknown-";
+
+/// A well-known rust-gpu target.
+///
+/// Even if [`Self::new`] accepted the target, it can still fail to compile if the specific rust-gpu compiler in use
+/// offers no support for it.
+///
+/// While the current implementation is just a validated string, that may change in the future.
+#[derive(Clone)]
+pub struct Target {
+    target: String,
+}
+
+impl Target {
+    pub fn from_target(target: &str) -> Result<Self, TargetError> {
+        let target_env = target.strip_prefix(SPIRV_TARGET_PREFIX).ok_or_else(|| {
+            TargetError::NonSpirvTarget {
+                target: target.to_string(),
+            }
+        })?;
+
+        // used only to split the full list into groups.
+        #[allow(clippy::match_same_arms)]
+        match target_env {
+            // HACK(firestar99) this hardcoded list should be replaced with patterns (eg. `vulkan{}.{}`),
+            // which would allow us to support new target versions without updating this list.
+            "spv1.0" | "spv1.1" | "spv1.2" | "spv1.3" | "spv1.4" | "spv1.5" | "spv1.6" => {}
+            "opengl4.0" | "opengl4.1" | "opengl4.2" | "opengl4.3" | "opengl4.5" => {}
+            "vulkan1.0" | "vulkan1.1" | "vulkan1.1spv1.4" | "vulkan1.2" | "vulkan1.3"
+            | "vulkan1.4" => {}
+
+            _ => {
+                return Err(TargetError::UnsupportedSpirvTargetEnv {
+                    target_env: target_env.into(),
+                });
+            }
+        }
+
+        Ok(Self {
+            target: target.to_string(),
+        })
+    }
+
+    pub fn from_env(target_env: &str) -> Result<Self, TargetError> {
+        Self::from_target(&format!("{SPIRV_TARGET_PREFIX}{target_env}"))
+    }
+
+    pub fn target(&self) -> &str {
+        &self.target
+    }
+
+    pub fn target_env(&self) -> &str {
+        &self.target[SPIRV_TARGET_PREFIX.len()..]
+    }
+}
+
+impl Debug for Target {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Target").field(&self.target).finish()
+    }
+}
+
+#[derive(Debug, Error)]
+#[non_exhaustive]
+pub enum TargetError {
+    #[error("SPIR-V target must start with `{SPIRV_TARGET_PREFIX}...`, was `{target}`")]
+    NonSpirvTarget { target: String },
+    #[error("SPIR-V target `{SPIRV_TARGET_PREFIX}-{target_env}` is not supported")]
+    UnsupportedSpirvTargetEnv { target_env: String },
+}

crates/rustc_codegen_spirv-types/src/target.rs

@@ -1,3 +1,4 @@
+use crate::Target;
 use semver::Version;
 use std::ffi::OsString;
 use std::path::Path;
@@ -19,16 +20,16 @@ impl TargetSpecVersion {
     /// the absolute path to it, on older rustc versions may return the target name.
     pub fn target_arg(
         rustc_version: Version,
-        target_env: &str,
+        target: &Target,
         target_spec_folder: &Path,
     ) -> std::io::Result<OsString> {
         if let Some(target_spec) = Self::from_rustc_version(rustc_version) {
             std::fs::create_dir_all(&target_spec_folder)?;
-            let spec_file = target_spec_folder.join(format!("spirv-unknown-{target_env}.json"));
-            std::fs::write(&spec_file, target_spec.format_spec(target_env))?;
+            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_env))
+            Ok(OsString::from(target.target()))
         }
     }
 
@@ -43,7 +44,8 @@ impl TargetSpecVersion {
     }
 
     /// format the target spec json
-    pub fn format_spec(&self, target_env: &str) -> String {
+    pub fn format_spec(&self, target: &Target) -> String {
+        let target_env = target.target_env();
         match self {
             TargetSpecVersion::Rustc_1_76_0 => {
                 format!(

crates/rustc_codegen_spirv-types/src/target_spec.rs

@@ -85,24 +85,20 @@ use std::env;
 use std::fs::File;
 use std::io::BufReader;
 use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
+use std::process::Stdio;
 use thiserror::Error;
 
 #[cfg(feature = "watch")]
 pub use self::watch::{SpirvWatcher, SpirvWatcherError};
-pub use rustc_codegen_spirv_types::Capability;
-use rustc_codegen_spirv_types::query_rustc_version;
-pub use rustc_codegen_spirv_types::{CompileResult, ModuleResult, TargetSpecVersion};
+pub use rustc_codegen_spirv_types::*;
 
 #[derive(Debug, Error)]
 #[non_exhaustive]
 pub enum SpirvBuilderError {
     #[error("`target` must be set, for example `spirv-unknown-vulkan1.2`")]
     MissingTarget,
-    #[error("expected `{SPIRV_TARGET_PREFIX}...` target, found `{target}`")]
-    NonSpirvTarget { target: String },
-    #[error("SPIR-V target `{SPIRV_TARGET_PREFIX}-{target_env}` is not supported")]
-    UnsupportedSpirvTargetEnv { target_env: String },
+    #[error("TargetError: {0}")]
+    TargetError(#[from] TargetError),
     #[error("`path_to_crate` must be set")]
     MissingCratePath,
     #[error("crate path '{0}' does not exist")]
@@ -128,8 +124,6 @@ pub enum SpirvBuilderError {
     WatchFailed(#[from] SpirvWatcherError),
 }
 
-const SPIRV_TARGET_PREFIX: &str = "spirv-unknown-";
-
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Default, serde::Deserialize, serde::Serialize)]
 #[cfg_attr(feature = "clap", derive(clap::ValueEnum))]
 #[non_exhaustive]
@@ -784,36 +778,13 @@ fn invoke_rustc(builder: &SpirvBuilder) -> Result<PathBuf, SpirvBuilderError> {
         .path_to_crate
         .as_ref()
         .ok_or(SpirvBuilderError::MissingCratePath)?;
-    let target_env;
+    let target;
     {
-        let target = builder
+        let target_str = builder
             .target
             .as_ref()
             .ok_or(SpirvBuilderError::MissingTarget)?;
-        target_env = target.strip_prefix(SPIRV_TARGET_PREFIX).ok_or_else(|| {
-            SpirvBuilderError::NonSpirvTarget {
-                target: target.clone(),
-            }
-        })?;
-        // HACK(eddyb) used only to split the full list into groups.
-        #[allow(clippy::match_same_arms)]
-        match target_env {
-            // HACK(eddyb) hardcoded list to avoid checking if the JSON file
-            // for a particular target exists (and sanitizing strings for paths).
-            //
-            // FIXME(eddyb) consider moving this list, or even `target-specs`,
-            // into `rustc_codegen_spirv_types`'s code/source.
-            "spv1.0" | "spv1.1" | "spv1.2" | "spv1.3" | "spv1.4" | "spv1.5" | "spv1.6" => {}
-            "opengl4.0" | "opengl4.1" | "opengl4.2" | "opengl4.3" | "opengl4.5" => {}
-            "vulkan1.0" | "vulkan1.1" | "vulkan1.1spv1.4" | "vulkan1.2" | "vulkan1.3"
-            | "vulkan1.4" => {}
-
-            _ => {
-                return Err(SpirvBuilderError::UnsupportedSpirvTargetEnv {
-                    target_env: target_env.into(),
-                });
-            }
-        }
+        target = Target::from_target(target_str)?;
 
         if (builder.print_metadata == MetadataPrintout::Full) && builder.multimodule {
             return Err(SpirvBuilderError::MultiModuleWithPrintMetadata);
@@ -1012,8 +983,7 @@ 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_env, &target_spec_dir)?;
+    let target = TargetSpecVersion::target_arg(toolchain_rustc_version, &target, &target_spec_dir)?;
     cargo.arg("--target").arg(target);
 
     if !builder.shader_crate_features.default_features {