fix clippy

Author: Firestar99

crates/cargo-gpu/src/build.rs

@@ -24,7 +24,6 @@ pub struct Build {
 
 impl Build {
     /// Entrypoint
-    #[expect(clippy::too_many_lines, reason = "It's not too confusing")]
     pub fn run(&mut self) -> anyhow::Result<()> {
         let (rustc_codegen_spirv_location, toolchain_channel) = self.install.run()?;
 
@@ -76,7 +75,7 @@ impl Build {
 
         let shaders = match &result.module {
             ModuleResult::MultiModule(modules) => {
-                assert!(!modules.is_empty(), "No shader modules to compile");
+                anyhow::ensure!(!modules.is_empty(), "No shader modules were compiled");
                 modules.iter().collect::<Vec<_>>()
             }
             ModuleResult::SingleModule(filepath) => result
@@ -95,7 +94,7 @@ impl Build {
                         .context("Couldn't parse file name from shader module path")?,
                 );
                 log::debug!("copying {} to {}", filepath.display(), path.display());
-                std::fs::copy(&filepath, &path)?;
+                std::fs::copy(filepath, &path)?;
                 log::debug!(
                     "linkage of {} relative to {}",
                     path.display(),

crates/cargo-gpu/src/install.rs

@@ -43,7 +43,7 @@ impl Install {
             trace!("writing dummy Cargo.toml");
             let version_spec = match &source {
                 SpirvSource::CratesIO(version) => {
-                    format!("version = \"{}\"", version)
+                    format!("version = \"{version}\"")
                 }
                 SpirvSource::Git { url, rev } => format!("git = \"{url}\"\nrev = \"{rev}\""),
                 SpirvSource::Path {
@@ -52,7 +52,7 @@ impl Install {
                 } => {
                     let mut new_path = rust_gpu_path.to_owned();
                     new_path.push("crates/spirv-builder");
-                    format!("path = \"{new_path}\"\nversion = \"{}\"", version)
+                    format!("path = \"{new_path}\"\nversion = \"{version}\"")
                 }
             };
             let cargo_toml = format!(
@@ -90,6 +90,7 @@ package = "rustc_codegen_spirv"
     }
 
     /// Install the binary pair and return the `(dylib_path, toolchain_channel)`.
+    #[expect(clippy::too_many_lines, reason = "it's fine")]
     pub fn run(&mut self) -> anyhow::Result<(PathBuf, String)> {
         // Ensure the cache dir exists
         let cache_dir = cache_dir()?;
@@ -164,7 +165,7 @@ package = "rustc_codegen_spirv"
             let mut build_command = std::process::Command::new("cargo");
             build_command
                 .current_dir(&checkout)
-                .arg(format!("+{}", toolchain_channel))
+                .arg(format!("+{toolchain_channel}"))
                 .args(["build", "--release"])
                 .env_remove("RUSTC");
             if source_is_path {
@@ -207,7 +208,7 @@ package = "rustc_codegen_spirv"
                 .context("writing target spec files")?;
         }
 
-        self.spirv_install.dylib_path = dest_dylib_path.clone();
+        self.spirv_install.dylib_path.clone_from(&dest_dylib_path);
         Ok((dest_dylib_path, toolchain_channel))
     }
 }

crates/cargo-gpu/src/install_toolchain.rs

@@ -1,4 +1,6 @@
-use anyhow::Context;
+//! toolchain installation logic
+
+use anyhow::Context as _;
 
 /// Use `rustup` to install the toolchain and components, if not already installed.
 ///
@@ -22,11 +24,11 @@ pub fn ensure_toolchain_and_components_exist(
     let string_toolchain_list = String::from_utf8_lossy(&output_toolchain_list.stdout);
     if string_toolchain_list
         .split_whitespace()
-        .any(|toolchain| toolchain.starts_with(&channel))
+        .any(|toolchain| toolchain.starts_with(channel))
     {
-        log::debug!("toolchain {} is already installed", channel);
+        log::debug!("toolchain {channel} is already installed");
     } else {
-        let message = format!("Rust {} with `rustup`", channel);
+        let message = format!("Rust {channel} with `rustup`");
         get_consent_for_toolchain_install(
             format!("Install {message}").as_ref(),
             skip_toolchain_install_consent,
@@ -35,7 +37,7 @@ pub fn ensure_toolchain_and_components_exist(
 
         let output_toolchain_add = std::process::Command::new("rustup")
             .args(["toolchain", "add"])
-            .arg(&channel)
+            .arg(channel)
             .stdout(std::process::Stdio::inherit())
             .stderr(std::process::Stdio::inherit())
             .output()
@@ -49,7 +51,7 @@ pub fn ensure_toolchain_and_components_exist(
     // Check for the required components
     let output_component_list = std::process::Command::new("rustup")
         .args(["component", "list", "--toolchain"])
-        .arg(&channel)
+        .arg(channel)
         .output()
         .context("getting toolchain list")?;
     anyhow::ensure!(
@@ -78,7 +80,7 @@ pub fn ensure_toolchain_and_components_exist(
 
         let output_component_add = std::process::Command::new("rustup")
             .args(["component", "add", "--toolchain"])
-            .arg(&channel)
+            .arg(channel)
             .args(["rust-src", "rustc-dev", "llvm-tools"])
             .stdout(std::process::Stdio::inherit())
             .stderr(std::process::Stdio::inherit())
@@ -126,6 +128,7 @@ fn get_consent_for_toolchain_install(
         Ok(())
     } else {
         crate::user_output!("Exiting...\n");
+        #[expect(clippy::exit, reason = "user requested abort")]
         std::process::exit(0);
     }
 }

crates/cargo-gpu/src/linkage.rs

@@ -27,10 +27,4 @@ impl Linkage {
             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()
-    }
 }

crates/cargo-gpu/src/lockfile.rs

@@ -40,7 +40,7 @@ impl LockfileMismatchHandler {
         let maybe_workspace_crate_lock =
             Self::ensure_shader_rust_version_doesnt_conflict_with_any_cargo_locks(
                 shader_crate_path,
-                &toolchain_channel,
+                toolchain_channel,
                 is_force_overwrite_lockfiles_v4_to_v3,
             )
             .context("ensure_shader_rust_version_doesnt_conflict_with_any_cargo_locks")?;

crates/cargo-gpu/src/metadata.rs

@@ -80,9 +80,9 @@ impl Metadata {
     /// Get any `rust-gpu` metadata set in the crate's `Cargo.toml`
     fn get_crate_metadata(
         json: &cargo_metadata::Metadata,
-        shader_crate_path: &std::path::Path,
+        path: &std::path::Path,
     ) -> anyhow::Result<Value> {
-        let shader_crate_path = std::fs::canonicalize(shader_crate_path)?.join("Cargo.toml");
+        let shader_crate_path = std::fs::canonicalize(path)?.join("Cargo.toml");
 
         for package in &json.packages {
             let manifest_path = std::fs::canonicalize(package.manifest_path.as_std_path())?;
@@ -99,6 +99,7 @@ impl Metadata {
         Ok(serde_json::json!({}))
     }
 
+    /// Get `rust-gpu` value from some metadata
     fn get_rust_gpu_from_metadata(metadata: &Value) -> Value {
         Self::keys_to_snake_case(
             metadata
@@ -112,6 +113,7 @@ impl Metadata {
     ///
     /// Detection of keys for serde deserialization must match the case in the Rust structs.
     /// However clap defaults to detecting CLI args in kebab case. So here we do the conversion.
+    #[expect(clippy::wildcard_enum_match_arm, reason = "we only want objects")]
     fn keys_to_snake_case(json: Value) -> Value {
         match json {
             Value::Object(object) => Value::Object(
@@ -120,7 +122,7 @@ impl Metadata {
                     .map(|(key, value)| (key.replace('-', "_"), Self::keys_to_snake_case(value)))
                     .collect(),
             ),
-            e => e,
+            other => other,
         }
     }
 }
@@ -182,7 +184,7 @@ mod test {
         let cargo_gpu = metadata
             .packages
             .iter_mut()
-            .find(|p| p.name.contains("cargo-gpu"))
+            .find(|package| package.name.contains("cargo-gpu"))
             .unwrap();
         cargo_gpu.metadata = serde_json::json!({
             "rust-gpu": {

crates/cargo-gpu/src/spirv_source.rs

@@ -4,7 +4,7 @@
 //! version. Then with that we `git checkout` the `rust-gpu` repo that corresponds to that version.
 //! From there we can look at the source code to get the required Rust toolchain.
 
-use anyhow::{anyhow, Context as _};
+use anyhow::Context as _;
 use cargo_metadata::camino::{Utf8Path, Utf8PathBuf};
 use cargo_metadata::semver::Version;
 use cargo_metadata::{MetadataCommand, Package};
@@ -65,30 +65,31 @@ impl core::fmt::Display for SpirvSource {
 }
 
 impl SpirvSource {
+    /// Figures out which source of `rust-gpu` to use
     pub fn new(
         shader_crate_path: &Path,
         maybe_rust_gpu_source: Option<&str>,
         maybe_rust_gpu_version: Option<&str>,
     ) -> anyhow::Result<Self> {
         let source = if let Some(rust_gpu_version) = maybe_rust_gpu_version {
             if let Some(rust_gpu_source) = maybe_rust_gpu_source {
-                SpirvSource::Git {
+                Self::Git {
                     url: rust_gpu_source.to_owned(),
                     rev: rust_gpu_version.to_owned(),
                 }
             } else {
-                SpirvSource::CratesIO(Version::parse(&rust_gpu_version)?)
+                Self::CratesIO(Version::parse(rust_gpu_version)?)
             }
         } else {
-            SpirvSource::get_rust_gpu_deps_from_shader(shader_crate_path)
+            Self::get_rust_gpu_deps_from_shader(shader_crate_path)
                 .context("get_rust_gpu_deps_from_shader")?
         };
         Ok(source)
     }
 
     /// Look into the shader crate to get the version of `rust-gpu` it's using.
     pub fn get_rust_gpu_deps_from_shader(shader_crate_path: &Path) -> anyhow::Result<Self> {
-        let spirv_std_package = get_package_from_crate(&shader_crate_path, "spirv-std")?;
+        let spirv_std_package = get_package_from_crate(shader_crate_path, "spirv-std")?;
         let spirv_source = Self::parse_spirv_std_source_and_version(&spirv_std_package)?;
         log::debug!(
             "Parsed `SpirvSource` from crate `{}`: \
@@ -103,10 +104,10 @@ impl SpirvSource {
     /// maybe using their own fork for example.
     pub fn install_dir(&self) -> anyhow::Result<PathBuf> {
         match self {
-            SpirvSource::Path {
+            Self::Path {
                 rust_gpu_repo_root, ..
             } => Ok(rust_gpu_repo_root.as_std_path().to_owned()),
-            SpirvSource::CratesIO { .. } | SpirvSource::Git { .. } => {
+            Self::CratesIO { .. } | Self::Git { .. } => {
                 let dir = crate::to_dirname(self.to_string().as_ref());
                 Ok(crate::cache_dir()?
                     .join("rustc_backend_spirv_install")
@@ -120,53 +121,47 @@ impl SpirvSource {
     /// Which would return:
     ///   `SpirvSource::Git("https://github.com/Rust-GPU/rust-gpu", "54f6978c")`
     fn parse_spirv_std_source_and_version(spirv_std_package: &Package) -> anyhow::Result<Self> {
-        log::trace!(
-            "parsing spirv-std source and version from package: '{:?}'",
-            spirv_std_package
-        );
+        log::trace!("parsing spirv-std source and version from package: '{spirv_std_package:?}'");
 
-        let result = match &spirv_std_package.source {
-            Some(source) => {
-                let is_git = source.repr.starts_with("git+");
-                let is_crates_io = source.is_crates_io();
+        let result = if let Some(source) = &spirv_std_package.source {
+            let is_git = source.repr.starts_with("git+");
+            let is_crates_io = source.is_crates_io();
 
-                match (is_git, is_crates_io) {
-                    (true, true) => unreachable!(),
-                    (true, false) => {
-                        let link = &source.repr[4..];
-                        let sharp_index = link.find('#').ok_or(anyhow!(
-                            "Git url of spirv-std package does not contain revision!"
-                        ))?;
-                        let question_mark_index = link.find('?').ok_or(anyhow!(
-                            "Git url of spirv-std package does not contain revision!"
-                        ))?;
-                        let url = link[..question_mark_index].to_string();
-                        let rev = link[sharp_index + 1..].to_string();
-                        Self::Git { url, rev }
-                    }
-                    (false, true) => Self::CratesIO(spirv_std_package.version.clone()),
-                    (false, false) => {
-                        anyhow::bail!("Metadata of spirv-std package uses unknown url format!")
-                    }
+            match (is_git, is_crates_io) {
+                (true, true) => anyhow::bail!("parsed both git and crates.io?"),
+                (true, false) => {
+                    let parse_git = || {
+                        let link = &source.repr.get(4..)?;
+                        let sharp_index = link.find('#')?;
+                        let question_mark_index = link.find('?')?;
+                        let url = link.get(..question_mark_index)?.to_owned();
+                        let rev = link.get(sharp_index + 1..)?.to_owned();
+                        Some(Self::Git { url, rev })
+                    };
+                    parse_git()
+                        .with_context(|| format!("Failed to parse git url {}", &source.repr))?
                 }
-            }
-            None => {
-                let rust_gpu_repo_root = spirv_std_package
-                    .manifest_path // rust-gpu/crates/spirv-std/Cargo.toml
-                    .parent() // rust-gpu/crates/spirv-std
-                    .and_then(Utf8Path::parent) // rust-gpu/crates
-                    .and_then(Utf8Path::parent) // rust-gpu
-                    .context("selecting rust-gpu workspace root dir in local path")?
-                    .to_owned();
-                if !rust_gpu_repo_root.is_dir() {
-                    anyhow::bail!("path {rust_gpu_repo_root} is not a directory");
-                }
-                let version = spirv_std_package.version.clone();
-                Self::Path {
-                    rust_gpu_repo_root,
-                    version,
+                (false, true) => Self::CratesIO(spirv_std_package.version.clone()),
+                (false, false) => {
+                    anyhow::bail!("Metadata of spirv-std package uses unknown url format!")
                 }
             }
+        } else {
+            let rust_gpu_repo_root = spirv_std_package
+                .manifest_path // rust-gpu/crates/spirv-std/Cargo.toml
+                .parent() // rust-gpu/crates/spirv-std
+                .and_then(Utf8Path::parent) // rust-gpu/crates
+                .and_then(Utf8Path::parent) // rust-gpu
+                .context("selecting rust-gpu workspace root dir in local path")?
+                .to_owned();
+            if !rust_gpu_repo_root.is_dir() {
+                anyhow::bail!("path {rust_gpu_repo_root} is not a directory");
+            }
+            let version = spirv_std_package.version.clone();
+            Self::Path {
+                rust_gpu_repo_root,
+                version,
+            }
         };
 
         log::debug!("Parsed `rust-gpu` source and version: {result:?}");
@@ -234,8 +229,10 @@ pub fn get_channel_from_rustc_codegen_spirv_build_script(
         .lines()
         .find_map(|line| line.strip_prefix(channel_start))
         .context(format!("Can't find `{channel_start}` line in {build_rs:?}"))?;
-    let channel = &channel_line[..channel_line.find("\"").context("ending \" missing")?];
-    Ok(channel.to_string())
+    let channel = channel_line
+        .get(..channel_line.find('"').context("ending \" missing")?)
+        .context("can't slice version")?;
+    Ok(channel.to_owned())
 }
 
 #[cfg(test)]