Preparing to move config & metadata modules into cargo-gpu-build

Author: tuguzT

Cargo.lock

@@ -12,12 +12,14 @@ rustc_codegen_spirv-cache = { path = "../rustc_codegen_spirv-cache" }
 dunce.workspace = true
 thiserror.workspace = true
 log.workspace = true
+serde.workspace = true
+clap = { workspace = true, optional = true }
 
 [features]
 # Rebuilds target shader crate upon changes
 watch = ["rustc_codegen_spirv-cache/watch"]
 # Enables `clap` support for public structs
-clap = ["rustc_codegen_spirv-cache/clap"]
+clap = ["dep:clap", "rustc_codegen_spirv-cache/clap"]
 
 [lints]
 workspace = true

crates/cargo-gpu-build/Cargo.toml

@@ -23,14 +23,33 @@ use crate::{
 #[cfg(feature = "watch")]
 use crate::spirv_builder::SpirvWatcher;
 
-/// Parameters for [`CargoGpuBuilder::new()`].
-#[derive(Debug, Clone)]
+/// Metadata specific to the build process.
+#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
+#[cfg_attr(feature = "clap", derive(clap::Parser))]
 #[non_exhaustive]
-pub struct CargoGpuBuilderParams<W, T, C, O, E> {
-    /// Parameters of the shader crate build.
-    pub build: SpirvBuilder,
-    /// Parameters of the codegen backend installation for the shader crate.
-    pub install: SpirvCodegenBackendInstaller,
+pub struct CargoGpuBuildMetadata {
+    /// The flattened [`SpirvBuilder`].
+    #[cfg_attr(feature = "clap", clap(flatten))]
+    #[serde(flatten)]
+    pub spirv_builder: SpirvBuilder,
+}
+
+impl From<SpirvBuilder> for CargoGpuBuildMetadata {
+    #[inline]
+    fn from(spirv_builder: SpirvBuilder) -> Self {
+        Self { spirv_builder }
+    }
+}
+
+/// Metadata specific to the codegen backend installation process.
+#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
+#[cfg_attr(feature = "clap", derive(clap::Parser))]
+#[non_exhaustive]
+pub struct CargoGpuInstallMetadata {
+    /// The flattened [`SpirvCodegenBackendInstaller`].
+    #[cfg_attr(feature = "clap", clap(flatten))]
+    #[serde(flatten)]
+    pub spirv_installer: SpirvCodegenBackendInstaller,
     /// There is a tricky situation where a shader crate that depends on workspace config can have
     /// a different `Cargo.lock` lockfile version from the the workspace's `Cargo.lock`. This can
     /// prevent builds when an old Rust toolchain doesn't recognise the newer lockfile version.
@@ -52,7 +71,29 @@ pub struct CargoGpuBuilderParams<W, T, C, O, E> {
     /// way source URLs are encoded. See these PRs for more details:
     ///   * <https://github.com/rust-lang/cargo/pull/12280>
     ///   * <https://github.com/rust-lang/cargo/pull/14595>
+    #[cfg_attr(feature = "clap", clap(long, action, verbatim_doc_comment))]
     pub force_overwrite_lockfiles_v4_to_v3: bool,
+}
+
+/// Metadata for both shader crate build and codegen backend installation.
+#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
+#[cfg_attr(feature = "clap", derive(clap::Parser))]
+#[non_exhaustive]
+pub struct CargoGpuMetadata {
+    /// Parameters of the shader crate build.
+    #[cfg_attr(feature = "clap", clap(flatten))]
+    pub build: CargoGpuBuildMetadata,
+    /// Parameters of the codegen backend installation for the shader crate.
+    #[cfg_attr(feature = "clap", clap(flatten))]
+    pub install: CargoGpuInstallMetadata,
+}
+
+/// Parameters for [`CargoGpuBuilder::new()`].
+#[derive(Debug, Clone)]
+#[non_exhaustive]
+pub struct CargoGpuBuilderParams<W, T, C, O, E> {
+    /// Parameters of the shader crate build & codegen backend installation.
+    pub metadata: CargoGpuMetadata,
     /// Writer of user output.
     pub writer: W,
     /// Callbacks to halt toolchain installation.
@@ -62,41 +103,41 @@ pub struct CargoGpuBuilderParams<W, T, C, O, E> {
 }
 
 impl<W, T, C, O, E> CargoGpuBuilderParams<W, T, C, O, E> {
-    /// Replaces build parameters of the shader crate.
+    /// Replaces of the shader crate build & codegen backend installation.
     #[inline]
     #[must_use]
-    pub fn build(self, build: SpirvBuilder) -> Self {
-        Self { build, ..self }
+    pub fn metadata(self, metadata: CargoGpuMetadata) -> Self {
+        Self { metadata, ..self }
     }
 
-    /// Replaces codegen backend installation parameters of the shader crate.
+    /// Replaces build parameters of the shader crate.
     #[inline]
     #[must_use]
-    pub fn install(self, install: SpirvCodegenBackendInstaller) -> Self {
-        Self { install, ..self }
+    pub fn build(self, build: CargoGpuBuildMetadata) -> Self {
+        let metadata = CargoGpuMetadata {
+            build,
+            ..self.metadata
+        };
+        Self { metadata, ..self }
     }
 
-    /// Sets whether to force overwriting lockfiles from v4 to v3.
+    /// Replaces codegen backend installation parameters of the shader crate.
     #[inline]
     #[must_use]
-    pub fn force_overwrite_lockfiles_v4_to_v3(
-        self,
-        force_overwrite_lockfiles_v4_to_v3: bool,
-    ) -> Self {
-        Self {
-            force_overwrite_lockfiles_v4_to_v3,
-            ..self
-        }
+    pub fn install(self, install: CargoGpuInstallMetadata) -> Self {
+        let metadata = CargoGpuMetadata {
+            install,
+            ..self.metadata
+        };
+        Self { metadata, ..self }
     }
 
     /// Replaces the writer of user output.
     #[inline]
     #[must_use]
     pub fn writer<NW>(self, writer: NW) -> CargoGpuBuilderParams<NW, T, C, O, E> {
         CargoGpuBuilderParams {
-            build: self.build,
-            install: self.install,
-            force_overwrite_lockfiles_v4_to_v3: self.force_overwrite_lockfiles_v4_to_v3,
+            metadata: self.metadata,
             writer,
             halt: self.halt,
             stdio_cfg: self.stdio_cfg,
@@ -111,9 +152,7 @@ impl<W, T, C, O, E> CargoGpuBuilderParams<W, T, C, O, E> {
         halt: HaltToolchainInstallation<NT, NC>,
     ) -> CargoGpuBuilderParams<W, NT, NC, O, E> {
         CargoGpuBuilderParams {
-            build: self.build,
-            install: self.install,
-            force_overwrite_lockfiles_v4_to_v3: self.force_overwrite_lockfiles_v4_to_v3,
+            metadata: self.metadata,
             writer: self.writer,
             halt,
             stdio_cfg: self.stdio_cfg,
@@ -128,9 +167,7 @@ impl<W, T, C, O, E> CargoGpuBuilderParams<W, T, C, O, E> {
         stdio_cfg: StdioCfg<NO, NE>,
     ) -> CargoGpuBuilderParams<W, T, C, NO, NE> {
         CargoGpuBuilderParams {
-            build: self.build,
-            install: self.install,
-            force_overwrite_lockfiles_v4_to_v3: self.force_overwrite_lockfiles_v4_to_v3,
+            metadata: self.metadata,
             writer: self.writer,
             halt: self.halt,
             stdio_cfg,
@@ -147,11 +184,18 @@ pub type DefaultCargoGpuBuilderParams = CargoGpuBuilderParams<
     InheritStderr,
 >;
 
-impl From<SpirvBuilder> for DefaultCargoGpuBuilderParams {
+impl<T> From<T> for DefaultCargoGpuBuilderParams
+where
+    T: Into<CargoGpuBuildMetadata>,
+{
     #[inline]
-    fn from(build: SpirvBuilder) -> Self {
+    fn from(value: T) -> Self {
+        let metadata = CargoGpuMetadata {
+            build: value.into(),
+            install: CargoGpuInstallMetadata::default(),
+        };
         Self {
-            build,
+            metadata,
             ..Self::default()
         }
     }
@@ -161,9 +205,7 @@ impl Default for DefaultCargoGpuBuilderParams {
     #[inline]
     fn default() -> Self {
         Self {
-            build: SpirvBuilder::default(),
-            install: SpirvCodegenBackendInstaller::default(),
-            force_overwrite_lockfiles_v4_to_v3: false,
+            metadata: CargoGpuMetadata::default(),
             writer: io::stdout(),
             halt: HaltToolchainInstallation::noop(),
             stdio_cfg: StdioCfg::inherit(),
@@ -212,23 +254,29 @@ where
         E: FnMut() -> Stdio,
     {
         let CargoGpuBuilderParams {
-            mut build,
-            install,
-            force_overwrite_lockfiles_v4_to_v3,
+            metadata,
             mut writer,
             halt,
             mut stdio_cfg,
         } = params.into();
+        let CargoGpuMetadata { build, install } = metadata;
+        let CargoGpuBuildMetadata {
+            spirv_builder: mut builder,
+        } = build;
+        let CargoGpuInstallMetadata {
+            spirv_installer: installer,
+            force_overwrite_lockfiles_v4_to_v3,
+        } = install;
 
-        if build.target.is_none() {
+        if builder.target.is_none() {
             return Err(NewCargoGpuBuilderError::MissingTarget);
         }
-        let path_to_crate = build
+        let path_to_crate = builder
             .path_to_crate
             .as_ref()
             .ok_or(NewCargoGpuBuilderError::MissingCratePath)?;
         let shader_crate = dunce::canonicalize(path_to_crate)?;
-        build.path_to_crate = Some(shader_crate.clone());
+        builder.path_to_crate = Some(shader_crate.clone());
 
         let backend_install_params = SpirvCodegenBackendInstallParams::from(&shader_crate)
             .writer(&mut writer)
@@ -240,7 +288,7 @@ where
                 stdout: || (stdio_cfg.stdout)(),
                 stderr: || (stdio_cfg.stderr)(),
             });
-        let codegen_backend = install.install(backend_install_params)?;
+        let codegen_backend = installer.install(backend_install_params)?;
 
         let lockfile_mismatch_handler = LockfileMismatchHandler::new(
             &shader_crate,
@@ -250,12 +298,12 @@ where
 
         #[expect(clippy::unreachable, reason = "target was set")]
         codegen_backend
-            .configure_spirv_builder(&mut build)
+            .configure_spirv_builder(&mut builder)
             .unwrap_or_else(|_| unreachable!("target was set before calling this function"));
 
         Ok(Self {
-            builder: build,
-            installer: install,
+            builder,
+            installer,
             codegen_backend,
             lockfile_mismatch_handler,
             writer,

crates/cargo-gpu-build/src/build.rs

@@ -68,7 +68,7 @@ impl LockfileMismatchHandler {
         })
     }
 
-    /// See docs for [`force_overwrite_lockfiles_v4_to_v3`](field@crate::build::CargoGpuBuilderParams::force_overwrite_lockfiles_v4_to_v3)
+    /// See docs for [`force_overwrite_lockfiles_v4_to_v3`](field@crate::build::CargoGpuInstallMetadata::force_overwrite_lockfiles_v4_to_v3)
     /// flag for why we do this.
     fn ensure_workspace_rust_version_does_not_conflict_with_shader(
         shader_crate_path: &Path,
@@ -96,7 +96,7 @@ impl LockfileMismatchHandler {
         }
     }
 
-    /// See docs for [`force_overwrite_lockfiles_v4_to_v3`](field@crate::build::CargoGpuBuilderParams::force_overwrite_lockfiles_v4_to_v3)
+    /// See docs for [`force_overwrite_lockfiles_v4_to_v3`](field@crate::build::CargoGpuInstallMetadata::force_overwrite_lockfiles_v4_to_v3)
     /// flag for why we do this.
     fn ensure_shader_rust_version_does_not_conflict_with_any_cargo_locks(
         shader_crate_path: &Path,
@@ -334,7 +334,7 @@ pub enum LockfileMismatchError {
     /// Conflicting lockfile manifest versions detected, with advice on how to resolve them
     /// by setting the [`force_overwrite_lockfiles_v4_to_v3`] flag.
     ///
-    /// [`force_overwrite_lockfiles_v4_to_v3`]: field@crate::build::CargoGpuBuilderParams::force_overwrite_lockfiles_v4_to_v3
+    /// [`force_overwrite_lockfiles_v4_to_v3`]: field@crate::build::CargoGpuInstallMetadata::force_overwrite_lockfiles_v4_to_v3
     #[error(
         r#"conflicting `Cargo.lock` versions detected ⚠️
 

crates/cargo-gpu-build/src/lockfile.rs

@@ -10,8 +10,8 @@ use std::{
 
 use anyhow::Context as _;
 use cargo_gpu_build::{
-    build::{CargoGpuBuilder, CargoGpuBuilderParams},
-    spirv_builder::{CompileResult, ModuleResult, SpirvBuilder},
+    build::{CargoGpuBuildMetadata, CargoGpuBuilder, CargoGpuBuilderParams},
+    spirv_builder::{CompileResult, ModuleResult},
 };
 
 use crate::{
@@ -34,10 +34,10 @@ pub struct BuildArgs {
     #[clap(long, short, action)]
     pub watch: bool,
 
-    /// The flattened [`SpirvBuilder`].
+    /// The flattened [`CargoGpuBuildMetadata`].
     #[clap(flatten)]
     #[serde(flatten)]
-    pub spirv_builder: SpirvBuilder,
+    pub build_meta: CargoGpuBuildMetadata,
 
     /// Renames the manifest.json file to the given name.
     #[clap(long, short, default_value = "manifest.json")]
@@ -50,7 +50,7 @@ impl Default for BuildArgs {
         Self {
             output_dir: PathBuf::from("./"),
             watch: false,
-            spirv_builder: SpirvBuilder::default(),
+            build_meta: CargoGpuBuildMetadata::default(),
             manifest_file: String::from("manifest.json"),
         }
     }
@@ -77,29 +77,33 @@ impl Build {
     /// Returns an error if the build process fails somehow.
     #[inline]
     pub fn run(&mut self) -> anyhow::Result<()> {
-        self.build.spirv_builder.path_to_crate = Some(self.install.shader_crate.clone());
+        let Self { install, build } = self;
+        let InstallArgs { install_meta, .. } = install;
+        let BuildArgs { build_meta, .. } = build;
 
-        let halt = ask_for_user_consent(self.install.auto_install_rust_toolchain);
-        let crate_builder_params = CargoGpuBuilderParams::from(self.build.spirv_builder.clone())
-            .install(self.install.spirv_installer.clone())
-            .force_overwrite_lockfiles_v4_to_v3(self.install.force_overwrite_lockfiles_v4_to_v3)
+        build_meta.spirv_builder.path_to_crate = Some(install.shader_crate.clone());
+
+        let skip_consent = install.auto_install_rust_toolchain;
+        let halt = ask_for_user_consent(skip_consent);
+        let crate_builder_params = CargoGpuBuilderParams::from(build_meta.clone())
+            .install(install_meta.clone())
             .halt(halt);
         let crate_builder = CargoGpuBuilder::new(crate_builder_params)?;
 
-        self.install.spirv_installer = crate_builder.installer.clone();
-        self.build.spirv_builder = crate_builder.builder.clone();
+        install_meta.spirv_installer = crate_builder.installer.clone();
+        build_meta.spirv_builder = crate_builder.builder.clone();
 
         // Ensure the shader output dir exists
         log::debug!(
             "ensuring output-dir '{}' exists",
-            self.build.output_dir.display()
+            build.output_dir.display()
         );
-        std::fs::create_dir_all(&self.build.output_dir)?;
-        let canonicalized = dunce::canonicalize(&self.build.output_dir)?;
+        std::fs::create_dir_all(&build.output_dir)?;
+        let canonicalized = dunce::canonicalize(&build.output_dir)?;
         log::debug!("canonicalized output dir: {}", canonicalized.display());
-        self.build.output_dir = canonicalized;
+        build.output_dir = canonicalized;
 
-        if self.build.watch {
+        if build.watch {
             let never = self.watch(crate_builder)?;
             match never {}
         }