some clippy fixes

Author: Firestar99

crates/cargo-gpu/src/args.rs

@@ -1,12 +1,20 @@
+//! Args for building and installing. Previously in `spirv-tools-cli` but got moved here.
+
+use spirv_builder::SpirvBuilder;
+
+/// All args for a build and install
 #[derive(clap::Parser, Debug, Clone, serde::Deserialize, serde::Serialize)]
 pub struct AllArgs {
+    /// build args
     #[clap(flatten)]
     pub build: BuildArgs,
 
+    /// install args
     #[clap(flatten)]
     pub install: InstallArgs,
 }
 
+/// Args for just a build
 #[derive(clap::Parser, Debug, Clone, serde::Deserialize, serde::Serialize)]
 pub struct BuildArgs {
     /// Path to the output directory for the compiled shaders.
@@ -17,24 +25,31 @@ pub struct BuildArgs {
     #[clap(long, short, action)]
     pub watch: bool,
 
+    /// the flattened [`SpirvBuilder`]
     #[clap(flatten)]
     #[serde(flatten)]
-    pub spirv_builder: spirv_builder::SpirvBuilder,
+    pub spirv_builder: SpirvBuilder,
 
     ///Renames the manifest.json file to the given name
     #[clap(long, short, default_value = "manifest.json")]
     pub manifest_file: String,
 }
 
+/// Args for an install
 #[derive(clap::Parser, Debug, Clone, serde::Deserialize, serde::Serialize)]
 pub struct InstallArgs {
+    /// path to the `rustc_codegen_spirv` dylib
     #[clap(long, hide(true), default_value = "INTERNALLY_SET")]
     pub dylib_path: std::path::PathBuf,
 
     /// Directory containing the shader crate to compile.
     #[clap(long, default_value = "./")]
     pub shader_crate: std::path::PathBuf,
 
+    #[expect(
+        clippy::doc_markdown,
+        reason = "The URL should appear literally like this. But Clippy wants it to be a in markdown clickable link"
+    )]
     /// Source of `spirv-builder` dependency
     /// Eg: "https://github.com/Rust-GPU/rust-gpu"
     #[clap(long)]
@@ -81,8 +96,8 @@ pub struct InstallArgs {
     ///
     /// This hack is possible because the change from v3 to v4 only involves a minor change to the
     /// 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
+    ///   * <https://github.com/rust-lang/cargo/pull/12280>
+    ///   * <https://github.com/rust-lang/cargo/pull/14595>
     #[clap(long, action, verbatim_doc_comment)]
     pub force_overwrite_lockfiles_v4_to_v3: bool,
 }

crates/cargo-gpu/src/build.rs

@@ -56,7 +56,7 @@ impl Build {
                             .spirv_builder
                             .target
                             .as_ref()
-                            .expect("target to be set")
+                            .context("expect target to be set")?
                     ))
                     .display()
                     .to_string(),

crates/cargo-gpu/src/install.rs

@@ -93,13 +93,13 @@ impl Install {
     }
 
     /// Create the `rustc_codegen_spirv_dummy` crate that depends on `rustc_codegen_spirv`
-    fn write_source_files(&self, spirv_cli: &SpirvCli, checkout: &Path) -> anyhow::Result<()> {
+    fn write_source_files(spirv_cli: &SpirvCli, checkout: &Path) -> anyhow::Result<()> {
         {
             let main = "fn main() {}";
             let src = checkout.join("src");
             std::fs::create_dir_all(&src).context("creating directory for 'src'")?;
             std::fs::write(src.join("main.rs"), main).context("writing 'main.rs'")?;
-        }
+        };
 
         {
             let version_spec = match &spirv_cli.source {
@@ -126,7 +126,7 @@ package = "rustc_codegen_spirv"
             );
             std::fs::write(checkout.join("Cargo.toml"), cargo_toml)
                 .context("writing 'Cargo.toml'")?;
-        }
+        };
         Ok(())
     }
 
@@ -185,8 +185,7 @@ package = "rustc_codegen_spirv"
                 "writing rustc_codegen_spirv_dummy source files into '{}'",
                 checkout.display()
             );
-            self.write_source_files(&spirv_version, &checkout)
-                .context("writing source files")?;
+            Self::write_source_files(&spirv_version, &checkout).context("writing source files")?;
             self.write_target_spec_files()
                 .context("writing target spec files")?;
 
@@ -201,7 +200,7 @@ package = "rustc_codegen_spirv"
                 .arg(format!("+{}", spirv_version.channel))
                 .args(["build", "--release"]);
 
-            log::debug!("building artifacts with `{:?}`", build_command);
+            log::debug!("building artifacts with `{build_command:?}`");
 
             build_command
                 .stdout(std::process::Stdio::inherit())

crates/cargo-gpu/src/linkage.rs

@@ -1,26 +1,35 @@
+//! Mainly for the Linkage struct, which is written to a json file. Previously in `spirv-tools-cli` but got moved here.
+
 /// Shader source and entry point that can be used to create shader linkage.
-#[derive(serde::Serialize, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(serde::Serialize, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Linkage {
+    /// File path to the entry point's source file
     pub source_path: String,
+    /// Name of the entry point for spirv and vulkan
     pub entry_point: String,
+    /// Name of the entry point for wgsl, where `::` characters have been removed
     pub wgsl_entry_point: String,
 }
 
 impl Linkage {
+    /// Make a new `Linkage` from an entry point and source path
+    #[expect(clippy::impl_trait_in_params, reason = "just a struct new")]
     pub fn new(entry_point: impl AsRef<str>, source_path: impl AsRef<std::path::Path>) -> Self {
         Self {
             // Force a forward slash convention here so it works on all OSs
             source_path: source_path
                 .as_ref()
                 .components()
-                .map(|c| c.as_os_str().to_string_lossy())
+                .map(|comp| comp.as_os_str().to_string_lossy())
                 .collect::<Vec<_>>()
                 .join("/"),
             wgsl_entry_point: entry_point.as_ref().replace("::", ""),
-            entry_point: entry_point.as_ref().to_string(),
+            entry_point: entry_point.as_ref().to_owned(),
         }
     }
 
+    /// The entry point function name, without the fully qualified mod path
+    #[expect(clippy::unwrap_used, reason = "unreachable")]
     pub fn fn_name(&self) -> &str {
         self.entry_point.split("::").last().unwrap()
     }
@@ -30,11 +39,15 @@ impl Linkage {
 /// a `build-manifest.json` used by `cargo-gpu`.
 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct ShaderModule {
+    /// Name of the entry point for spirv and vulkan
     pub entry: String,
+    /// File path to the entry point's source file
     pub path: std::path::PathBuf,
 }
 
 impl ShaderModule {
+    /// Make a new `ShaderModule` from an entry point and source path
+    #[expect(clippy::impl_trait_in_params, reason = "just a struct new")]
     pub fn new(entry: impl AsRef<str>, path: impl AsRef<std::path::Path>) -> Self {
         Self {
             entry: entry.as_ref().into(),

crates/cargo-gpu/src/main.rs

@@ -165,10 +165,10 @@ fn run() -> anyhow::Result<()> {
 #[derive(clap::Subcommand)]
 enum Command {
     /// Install rust-gpu compiler artifacts.
-    Install(Install),
+    Install(Box<Install>),
 
     /// Compile a shader crate to SPIR-V.
-    Build(Build),
+    Build(Box<Build>),
 
     /// Show some useful values.
     Show(Show),

crates/cargo-gpu/src/metadata.rs

@@ -64,7 +64,7 @@ impl Metadata {
                 let mut crate_meta = Self::get_crate_metadata(cargo_json, path)?;
                 log::trace!("crate_metadata: {crate_meta:#?}");
                 if let Some(output_path) = crate_meta.pointer_mut("/build/output_dir") {
-                    log::debug!("found output-dir path in crate metadata: {:?}", output_path);
+                    log::debug!("found output-dir path in crate metadata: {output_path:?}");
                     if let Some(output_dir) = output_path.clone().as_str() {
                         let new_output_path = path.join(output_dir);
                         *output_path = Value::String(format!("{}", new_output_path.display()));

crates/cargo-gpu/src/spirv_cli.rs

@@ -249,8 +249,7 @@ impl SpirvCli {
             RUST_VERSION_THAT_USES_V4_CARGO_LOCKS,
         ) {
             log::debug!(
-                "user's Rust is v{}, so no v3/v4 conflicts possible.",
-                workspace_rust_version
+                "user's Rust is v{workspace_rust_version}, so no v3/v4 conflicts possible."
             );
             return Ok(None);
         }
@@ -281,16 +280,12 @@ impl SpirvCli {
             &shader_rust_version,
             RUST_VERSION_THAT_USES_V4_CARGO_LOCKS,
         ) {
-            log::debug!(
-                "shader's Rust is v{}, so no v3/v4 conflicts possible.",
-                shader_rust_version
-            );
+            log::debug!("shader's Rust is v{shader_rust_version}, so no v3/v4 conflicts possible.");
             return Ok(None);
         }
 
         log::debug!(
-            "shader's Rust is v{}, so checking both shader and workspace `Cargo.lock` manifest versions...",
-            shader_rust_version
+            "shader's Rust is v{shader_rust_version}, so checking both shader and workspace `Cargo.lock` manifest versions..."
         );
 
         if shader_crate_path.join("Cargo.lock").exists() {