Rename some structs

Author: tuguzT

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

@@ -7,7 +7,10 @@ use crate::{
     lockfile::{LockfileMismatchError, LockfileMismatchHandler},
     spirv_builder::{CompileResult, SpirvBuilder, SpirvBuilderError},
     spirv_cache::{
-        backend::{Install, InstallError, InstallParams, InstallRunParams, InstalledBackend},
+        backend::{
+            SpirvCodegenBackend, SpirvCodegenBackendInstallError, SpirvCodegenBackendInstaller,
+            SpirvCodegenBackendInstallerParams, SpirvCodegenBackendInstallerRunParams,
+        },
         command::CommandExecError,
         toolchain::{
             HaltToolchainInstallation, InheritStderr, InheritStdout, NoopOnComponentsInstall,
@@ -20,14 +23,14 @@ use crate::{
 #[cfg(feature = "watch")]
 use crate::spirv_builder::SpirvWatcher;
 
-/// Parameters for [`ShaderCrateBuilder::new()`].
+/// Parameters for [`CargoGpuBuilder::new()`].
 #[derive(Debug, Clone)]
 #[non_exhaustive]
-pub struct ShaderCrateBuilderParams<W, T, C, O, E> {
+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: InstallParams,
+    pub install: SpirvCodegenBackendInstallerParams,
     /// 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.
@@ -58,7 +61,7 @@ pub struct ShaderCrateBuilderParams<W, T, C, O, E> {
     pub stdio_cfg: StdioCfg<O, E>,
 }
 
-impl<W, T, C, O, E> ShaderCrateBuilderParams<W, T, C, O, E> {
+impl<W, T, C, O, E> CargoGpuBuilderParams<W, T, C, O, E> {
     /// Replaces build parameters of the shader crate.
     #[inline]
     #[must_use]
@@ -69,7 +72,7 @@ impl<W, T, C, O, E> ShaderCrateBuilderParams<W, T, C, O, E> {
     /// Replaces codegen backend installation parameters of the shader crate.
     #[inline]
     #[must_use]
-    pub fn install(self, install: InstallParams) -> Self {
+    pub fn install(self, install: SpirvCodegenBackendInstallerParams) -> Self {
         Self { install, ..self }
     }
 
@@ -89,8 +92,8 @@ impl<W, T, C, O, E> ShaderCrateBuilderParams<W, T, C, O, E> {
     /// Replaces the writer of user output.
     #[inline]
     #[must_use]
-    pub fn writer<NW>(self, writer: NW) -> ShaderCrateBuilderParams<NW, T, C, O, E> {
-        ShaderCrateBuilderParams {
+    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,
@@ -106,8 +109,8 @@ impl<W, T, C, O, E> ShaderCrateBuilderParams<W, T, C, O, E> {
     pub fn halt<NT, NC>(
         self,
         halt: HaltToolchainInstallation<NT, NC>,
-    ) -> ShaderCrateBuilderParams<W, NT, NC, O, E> {
-        ShaderCrateBuilderParams {
+    ) -> 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,
@@ -123,8 +126,8 @@ impl<W, T, C, O, E> ShaderCrateBuilderParams<W, T, C, O, E> {
     pub fn stdio_cfg<NO, NE>(
         self,
         stdio_cfg: StdioCfg<NO, NE>,
-    ) -> ShaderCrateBuilderParams<W, T, C, NO, NE> {
-        ShaderCrateBuilderParams {
+    ) -> 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,
@@ -135,16 +138,16 @@ impl<W, T, C, O, E> ShaderCrateBuilderParams<W, T, C, O, E> {
     }
 }
 
-/// [`Default`] parameters for [`ShaderCrateBuilder::new()`].
-pub type DefaultShaderCrateBuilderParams = ShaderCrateBuilderParams<
+/// [`Default`] parameters for [`CargoGpuBuilder::new()`].
+pub type DefaultCargoGpuBuilderParams = CargoGpuBuilderParams<
     io::Stdout,
     NoopOnToolchainInstall,
     NoopOnComponentsInstall,
     InheritStdout,
     InheritStderr,
 >;
 
-impl From<SpirvBuilder> for DefaultShaderCrateBuilderParams {
+impl From<SpirvBuilder> for DefaultCargoGpuBuilderParams {
     #[inline]
     fn from(build: SpirvBuilder) -> Self {
         Self {
@@ -154,12 +157,12 @@ impl From<SpirvBuilder> for DefaultShaderCrateBuilderParams {
     }
 }
 
-impl Default for DefaultShaderCrateBuilderParams {
+impl Default for DefaultCargoGpuBuilderParams {
     #[inline]
     fn default() -> Self {
         Self {
             build: SpirvBuilder::default(),
-            install: InstallParams::default(),
+            install: SpirvCodegenBackendInstallerParams::default(),
             force_overwrite_lockfiles_v4_to_v3: false,
             writer: io::stdout(),
             halt: HaltToolchainInstallation::noop(),
@@ -171,20 +174,20 @@ impl Default for DefaultShaderCrateBuilderParams {
 /// A builder for compiling a `rust-gpu` shader crate.
 #[derive(Debug, Clone)]
 #[non_exhaustive]
-pub struct ShaderCrateBuilder<W = io::Stdout> {
+pub struct CargoGpuBuilder<W = io::Stdout> {
     /// The underlying builder for compiling the shader crate.
     pub builder: SpirvBuilder,
     /// The arguments used to install the backend.
-    pub installed_backend_args: Install,
+    pub installed_backend_args: SpirvCodegenBackendInstaller,
     /// The installed backend.
-    pub installed_backend: InstalledBackend,
+    pub installed_backend: SpirvCodegenBackend,
     /// The lockfile mismatch handler.
     pub lockfile_mismatch_handler: LockfileMismatchHandler,
     /// Writer of user output.
     pub writer: W,
 }
 
-impl<W> ShaderCrateBuilder<W>
+impl<W> CargoGpuBuilder<W>
 where
     W: io::Write,
 {
@@ -199,16 +202,16 @@ where
     /// * the backend installation fails,
     /// * there is a lockfile version mismatch that cannot be resolved automatically.
     #[inline]
-    pub fn new<I, R, T, C, O, E>(params: I) -> Result<Self, NewShaderCrateBuilderError<R>>
+    pub fn new<I, R, T, C, O, E>(params: I) -> Result<Self, NewCargoGpuBuilderError<R>>
     where
-        I: Into<ShaderCrateBuilderParams<W, T, C, O, E>>,
+        I: Into<CargoGpuBuilderParams<W, T, C, O, E>>,
         R: From<CommandExecError>,
         T: FnOnce(&str) -> Result<(), R>,
         C: FnOnce(&str) -> Result<(), R>,
         O: FnMut() -> Stdio,
         E: FnMut() -> Stdio,
     {
-        let ShaderCrateBuilderParams {
+        let CargoGpuBuilderParams {
             mut build,
             install,
             force_overwrite_lockfiles_v4_to_v3,
@@ -218,16 +221,16 @@ where
         } = params.into();
 
         if build.target.is_none() {
-            return Err(NewShaderCrateBuilderError::MissingTarget);
+            return Err(NewCargoGpuBuilderError::MissingTarget);
         }
         let path_to_crate = build
             .path_to_crate
             .as_ref()
-            .ok_or(NewShaderCrateBuilderError::MissingCratePath)?;
+            .ok_or(NewCargoGpuBuilderError::MissingCratePath)?;
         let shader_crate = dunce::canonicalize(path_to_crate)?;
 
-        let backend_to_install = Install::new(shader_crate, install);
-        let backend_install_params = InstallRunParams::default()
+        let backend_to_install = SpirvCodegenBackendInstaller::new(shader_crate, install);
+        let backend_install_params = SpirvCodegenBackendInstallerRunParams::default()
             .writer(&mut writer)
             .halt(HaltToolchainInstallation {
                 on_toolchain_install: |channel: &str| (halt.on_toolchain_install)(channel),
@@ -237,7 +240,7 @@ where
                 stdout: || (stdio_cfg.stdout)(),
                 stderr: || (stdio_cfg.stderr)(),
             });
-        let backend = backend_to_install.run(backend_install_params)?;
+        let backend = backend_to_install.install(backend_install_params)?;
 
         let lockfile_mismatch_handler = LockfileMismatchHandler::new(
             &backend_to_install.shader_crate,
@@ -265,7 +268,7 @@ where
     ///
     /// Returns an error if building the shader crate failed.
     #[inline]
-    pub fn build(&mut self) -> Result<CompileResult, ShaderCrateBuildError> {
+    pub fn build(&mut self) -> Result<CompileResult, CargoGpuBuildError> {
         let shader_crate = self.installed_backend_args.shader_crate.display();
         user_output!(&mut self.writer, "Compiling shaders at {shader_crate}...\n")?;
 
@@ -280,7 +283,7 @@ where
     /// Returns an error if watching shader crate for changes failed.
     #[cfg(feature = "watch")]
     #[inline]
-    pub fn watch(&mut self) -> Result<SpirvWatcher, ShaderCrateBuildError> {
+    pub fn watch(&mut self) -> Result<SpirvWatcher, CargoGpuBuildError> {
         let shader_crate = self.installed_backend_args.shader_crate.display();
         user_output!(
             &mut self.writer,
@@ -292,10 +295,10 @@ where
     }
 }
 
-/// An error indicating what went wrong when creating a [`ShaderCrateBuilder`].
+/// An error indicating what went wrong when creating a [`CargoGpuBuilder`].
 #[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
-pub enum NewShaderCrateBuilderError<E = CommandExecError> {
+pub enum NewCargoGpuBuilderError<E = CommandExecError> {
     /// Shader crate target is missing from parameters of the build.
     #[error("shader crate target must be set, for example `spirv-unknown-vulkan1.2`")]
     MissingTarget,
@@ -307,7 +310,7 @@ pub enum NewShaderCrateBuilderError<E = CommandExecError> {
     InvalidCratePath(#[from] io::Error),
     /// The backend installation failed.
     #[error("could not install backend: {0}")]
-    Install(#[from] InstallError<E>),
+    Install(#[from] SpirvCodegenBackendInstallError<E>),
     /// There is a lockfile version mismatch that cannot be resolved automatically.
     #[error(transparent)]
     LockfileMismatch(#[from] LockfileMismatchError),
@@ -316,7 +319,7 @@ pub enum NewShaderCrateBuilderError<E = CommandExecError> {
 /// An error indicating what went wrong when building the shader crate.
 #[derive(Debug, thiserror::Error)]
 #[non_exhaustive]
-pub enum ShaderCrateBuildError {
+pub enum CargoGpuBuildError {
     /// Failed to write user output.
     #[error("failed to write user output: {0}")]
     IoWrite(#[from] io::Error),

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

@@ -68,7 +68,7 @@ impl LockfileMismatchHandler {
         })
     }
 
-    /// See docs for [`force_overwrite_lockfiles_v4_to_v3`](field@crate::build::ShaderCrateBuilderParams::force_overwrite_lockfiles_v4_to_v3)
+    /// See docs for [`force_overwrite_lockfiles_v4_to_v3`](field@crate::build::CargoGpuBuilderParams::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::ShaderCrateBuilderParams::force_overwrite_lockfiles_v4_to_v3)
+    /// See docs for [`force_overwrite_lockfiles_v4_to_v3`](field@crate::build::CargoGpuBuilderParams::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::ShaderCrateBuilderParams::force_overwrite_lockfiles_v4_to_v3
+    /// [`force_overwrite_lockfiles_v4_to_v3`]: field@crate::build::CargoGpuBuilderParams::force_overwrite_lockfiles_v4_to_v3
     #[error(
         r#"conflicting `Cargo.lock` versions detected ⚠️
 

crates/cargo-gpu/src/build.rs

@@ -5,12 +5,11 @@ use std::{io::Write as _, panic, path::PathBuf};
 
 use anyhow::Context as _;
 use cargo_gpu_build::{
-    build::{ShaderCrateBuilder, ShaderCrateBuilderParams},
+    build::{CargoGpuBuilder, CargoGpuBuilderParams},
     spirv_builder::{CompileResult, ModuleResult, SpirvBuilder},
-    spirv_cache::backend::Install,
 };
 
-use crate::{linkage::Linkage, user_consent::ask_for_user_consent};
+use crate::{install::Install, linkage::Linkage, user_consent::ask_for_user_consent};
 
 /// Args for just a build.
 #[derive(Debug, Clone, clap::Parser, serde::Deserialize, serde::Serialize)]
@@ -54,7 +53,7 @@ pub struct InstallArgs {
     /// The flattened [`Install`].
     #[clap(flatten)]
     #[serde(flatten)]
-    pub backend: Install,
+    pub install: Install,
 
     /// 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
@@ -85,7 +84,7 @@ pub struct InstallArgs {
     pub auto_install_rust_toolchain: bool,
 }
 
-/// `cargo build` subcommands
+/// `cargo build` subcommands.
 #[derive(Clone, Debug, clap::Parser, serde::Deserialize, serde::Serialize)]
 #[non_exhaustive]
 pub struct Build {
@@ -106,16 +105,17 @@ 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.backend.shader_crate.clone());
+        self.build.spirv_builder.path_to_crate =
+            Some(self.install.install.spirv_installer.shader_crate.clone());
 
         let halt = ask_for_user_consent(self.install.auto_install_rust_toolchain);
-        let crate_builder_params = ShaderCrateBuilderParams::from(self.build.spirv_builder.clone())
-            .install(self.install.backend.params.clone())
+        let crate_builder_params = CargoGpuBuilderParams::from(self.build.spirv_builder.clone())
+            .install(self.install.install.spirv_installer.params.clone())
             .force_overwrite_lockfiles_v4_to_v3(self.install.force_overwrite_lockfiles_v4_to_v3)
             .halt(halt);
-        let crate_builder = ShaderCrateBuilder::new(crate_builder_params)?;
+        let crate_builder = CargoGpuBuilder::new(crate_builder_params)?;
 
-        self.install.backend = crate_builder.installed_backend_args.clone();
+        self.install.install.spirv_installer = crate_builder.installed_backend_args.clone();
         self.build.spirv_builder = crate_builder.builder.clone();
 
         // Ensure the shader output dir exists
@@ -135,15 +135,15 @@ impl Build {
         self.build(crate_builder)
     }
 
-    /// Builds shader crate using [`ShaderCrateBuilder`].
-    fn build(&self, mut crate_builder: ShaderCrateBuilder) -> anyhow::Result<()> {
+    /// Builds shader crate using [`CargoGpuBuilder`].
+    fn build(&self, mut crate_builder: CargoGpuBuilder) -> anyhow::Result<()> {
         let result = crate_builder.build()?;
         self.parse_compilation_result(&result)?;
         Ok(())
     }
 
-    /// Watches shader crate for changes using [`ShaderCrateBuilder`].
-    fn watch(&self, mut crate_builder: ShaderCrateBuilder) -> anyhow::Result<Infallible> {
+    /// Watches shader crate for changes using [`CargoGpuBuilder`].
+    fn watch(&self, mut crate_builder: CargoGpuBuilder) -> anyhow::Result<Infallible> {
         let this = self.clone();
         let mut watcher = crate_builder.watch()?;
         let watch_thread = std::thread::spawn(move || -> ! {
@@ -196,10 +196,10 @@ impl Build {
                 log::debug!(
                     "linkage of {} relative to {}",
                     path.display(),
-                    self.install.backend.shader_crate.display()
+                    self.install.install.spirv_installer.shader_crate.display()
                 );
                 let spv_path = path
-                    .relative_to(&self.install.backend.shader_crate)
+                    .relative_to(&self.install.install.spirv_installer.shader_crate)
                     .map_or(path, |path_relative_to_shader_crate| {
                         path_relative_to_shader_crate.to_path("")
                     });
@@ -255,7 +255,10 @@ mod test {
             command: Command::Build(build),
         } = Cli::parse_from(args)
         {
-            assert_eq!(shader_crate_path, build.install.backend.shader_crate);
+            assert_eq!(
+                shader_crate_path,
+                build.install.install.spirv_installer.shader_crate
+            );
             assert_eq!(output_dir, build.build.output_dir);
 
             // TODO:

crates/cargo-gpu/src/install.rs

@@ -0,0 +1,13 @@
+//! `cargo gpu install`
+
+use cargo_gpu_build::spirv_cache::backend::SpirvCodegenBackendInstaller;
+
+/// `cargo gpu install` subcommands.
+#[derive(Clone, Debug, clap::Parser, serde::Deserialize, serde::Serialize)]
+#[non_exhaustive]
+pub struct Install {
+    /// The flattened [`SpirvCodegenBackendInstaller`].
+    #[clap(flatten)]
+    #[serde(flatten)]
+    pub spirv_installer: SpirvCodegenBackendInstaller,
+}