fix: resolve clippy warnings for CI

- Add const fn and #[must_use] to ResolvedInputConfig methods
- Add #[expect(too_many_arguments)] to plan_spawn_execution
- Fix disallowed types/methods in glob_inputs.rs with #[expect]
- Remove unfulfilled large_enum_variant expectation on FingerprintMismatch
- Use HashMap::default() instead of Default::default()
- Fix doc comment backtick formatting in spawn.rs
- Rewrite if-let-else to map_or in execute_spawn
- Replace [x].into_iter() with std::iter::once(x) in tests

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: branchseer

crates/vite_task/src/session/cache/mod.rs

@@ -33,17 +33,21 @@ pub struct PreRunFingerprint {
     pub glob_base: RelativePathBuf,
     /// Hashes of explicit input files computed from positive globs.
     /// Files matching negative globs are already filtered out.
-    /// Path is relative to workspace root, value is xxHash3_64 of file content.
+    /// Path is relative to workspace root, value is `xxHash3_64` of file content.
     pub globbed_inputs: BTreeMap<RelativePathBuf, u64>,
 }
 
 impl PreRunFingerprint {
     /// Build a pre-run fingerprint from cache metadata and globbed inputs.
     ///
     /// # Arguments
-    /// * `cache_metadata` - Cache metadata from plan stage (contains absolute glob_base)
+    /// * `cache_metadata` - Cache metadata from plan stage (contains absolute `glob_base`)
     /// * `globbed_inputs` - Hashes of explicit input files computed from positive globs
-    /// * `workspace_root` - Workspace root for converting absolute glob_base to relative
+    /// * `workspace_root` - Workspace root for converting absolute `glob_base` to relative
+    #[expect(
+        clippy::disallowed_macros,
+        reason = "anyhow::anyhow! internally uses std::format! for error messages"
+    )]
     fn from_cache_metadata(
         cache_metadata: &CacheMetadata,
         globbed_inputs: BTreeMap<RelativePathBuf, u64>,
@@ -98,10 +102,6 @@ pub enum CacheMiss {
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-#[expect(
-    clippy::large_enum_variant,
-    reason = "SpawnFingerprintMismatch holds two SpawnFingerprints for comparison; boxing would add unnecessary indirection for a short-lived enum"
-)]
 pub enum FingerprintMismatch {
     /// Found the cache entry of the same task run, but the spawn fingerprint mismatches
     /// this happens when the command itself or an env changes.
@@ -205,17 +205,14 @@ impl ExecutionCache {
         // Try to directly find the cache by pre-run fingerprint first
         if let Some(cache_value) = self.get_by_pre_run_fingerprint(&pre_run_fingerprint).await? {
             // Validate post-run fingerprint (inferred inputs) only if auto inference is enabled
-            if input_config.includes_auto {
-                if let Some(post_run_fingerprint_mismatch) =
+            if input_config.includes_auto
+                && let Some(post_run_fingerprint_mismatch) =
                     cache_value.post_run_fingerprint.validate(workspace_root)?
-                {
-                    // Found the cache with the same pre-run fingerprint, but the post-run fingerprint mismatches
-                    return Ok(Err(CacheMiss::FingerprintMismatch(
-                        FingerprintMismatch::PostRunFingerprintMismatch(
-                            post_run_fingerprint_mismatch,
-                        ),
-                    )));
-                }
+            {
+                // Found the cache with the same pre-run fingerprint, but the post-run fingerprint mismatches
+                return Ok(Err(CacheMiss::FingerprintMismatch(
+                    FingerprintMismatch::PostRunFingerprintMismatch(post_run_fingerprint_mismatch),
+                )));
             }
             // Associate the execution key to the spawn fingerprint if not already,
             // so that next time we can find it and report spawn fingerprint mismatch

crates/vite_task/src/session/execute/glob_inputs.rs

@@ -26,7 +26,7 @@ use wax::{Glob, walk::Entry as _};
 /// * `negative_globs` - Glob patterns that should exclude files from the result
 ///
 /// # Returns
-/// A sorted map of relative paths (from workspace_root) to their content hashes.
+/// A sorted map of relative paths (from `workspace_root`) to their content hashes.
 /// Only files are included (directories are skipped).
 ///
 /// # Example
@@ -40,6 +40,10 @@ use wax::{Glob, walk::Entry as _};
 /// )?;
 /// // Returns: { "packages/foo/src/index.ts" => 0x1234..., ... }
 /// ```
+#[expect(
+    clippy::disallowed_methods,
+    reason = "str::replace needed for path normalization; cow_replace unavailable in this crate"
+)]
 pub fn compute_globbed_inputs(
     base_dir: &AbsolutePath,
     workspace_root: &AbsolutePath,
@@ -65,9 +69,8 @@ pub fn compute_globbed_inputs(
     for pattern in positive_globs {
         let glob = Glob::new(pattern.as_str())?;
         for entry in glob.walk(base_dir.as_path()) {
-            let entry = match entry {
-                Ok(e) => e,
-                Err(_) => continue,
+            let Ok(entry) = entry else {
+                continue;
             };
 
             // Skip non-files
@@ -78,11 +81,9 @@ pub fn compute_globbed_inputs(
             let absolute_path = entry.path();
 
             // Compute path relative to base_dir for negative pattern matching
-            let relative_to_base: &std::path::Path =
-                match absolute_path.strip_prefix(base_dir.as_path()) {
-                    Ok(rel) => rel,
-                    Err(_) => continue, // Skip if path is outside base_dir
-                };
+            let Ok(relative_to_base) = absolute_path.strip_prefix(base_dir.as_path()) else {
+                continue; // Skip if path is outside base_dir
+            };
 
             // Apply negative patterns (relative to base_dir)
             if let Some(ref matcher) = negative_matcher {
@@ -98,7 +99,7 @@ pub fn compute_globbed_inputs(
             let Some(relative_to_workspace) = absolute_path
                 .strip_prefix(workspace_root.as_path())
                 .ok()
-                .and_then(|p: &std::path::Path| RelativePathBuf::new(p.to_path_buf()).ok())
+                .and_then(|p| RelativePathBuf::new(p).ok())
             else {
                 continue; // Skip if path is outside workspace_root
             };
@@ -110,7 +111,6 @@ pub fn compute_globbed_inputs(
                 }
                 Err(err) if err.kind() == io::ErrorKind::NotFound => {
                     // File was deleted between walk and hash, skip it
-                    continue;
                 }
                 Err(err) => {
                     return Err(err.into());
@@ -122,7 +122,8 @@ pub fn compute_globbed_inputs(
     Ok(result)
 }
 
-/// Hash file content using xxHash3_64
+/// Hash file content using `xxHash3_64`.
+#[expect(clippy::disallowed_types, reason = "receives std::path::Path from wax glob walker")]
 fn hash_file_content(path: &std::path::Path) -> io::Result<u64> {
     let file = File::open(path)?;
     let mut reader = io::BufReader::new(file);
@@ -187,7 +188,7 @@ mod tests {
     fn test_single_positive_glob() {
         let (_temp, workspace, package) = create_test_workspace();
         let positive: std::collections::BTreeSet<Str> =
-            ["src/**/*.ts".into()].into_iter().collect();
+            std::iter::once("src/**/*.ts".into()).collect();
         let negative = std::collections::BTreeSet::new();
 
         let result = compute_globbed_inputs(&package, &workspace, &positive, &negative).unwrap();
@@ -217,9 +218,9 @@ mod tests {
     fn test_positive_with_negative_exclusion() {
         let (_temp, workspace, package) = create_test_workspace();
         let positive: std::collections::BTreeSet<Str> =
-            ["src/**/*.ts".into()].into_iter().collect();
+            std::iter::once("src/**/*.ts".into()).collect();
         let negative: std::collections::BTreeSet<Str> =
-            ["**/*.test.ts".into()].into_iter().collect();
+            std::iter::once("**/*.test.ts".into()).collect();
 
         let result = compute_globbed_inputs(&package, &workspace, &positive, &negative).unwrap();
 
@@ -251,7 +252,7 @@ mod tests {
         let positive: std::collections::BTreeSet<Str> =
             ["src/**/*.ts".into(), "package.json".into()].into_iter().collect();
         let negative: std::collections::BTreeSet<Str> =
-            ["**/*.test.ts".into()].into_iter().collect();
+            std::iter::once("**/*.test.ts".into()).collect();
 
         let result = compute_globbed_inputs(&package, &workspace, &positive, &negative).unwrap();
 
@@ -302,7 +303,7 @@ mod tests {
         let (_temp, workspace, package) = create_test_workspace();
         let positive: std::collections::BTreeSet<Str> = std::collections::BTreeSet::new();
         let negative: std::collections::BTreeSet<Str> =
-            ["**/*.test.ts".into()].into_iter().collect();
+            std::iter::once("**/*.test.ts".into()).collect();
 
         let result = compute_globbed_inputs(&package, &workspace, &positive, &negative).unwrap();
 
@@ -314,7 +315,7 @@ mod tests {
     fn test_file_hashes_are_consistent() {
         let (_temp, workspace, package) = create_test_workspace();
         let positive: std::collections::BTreeSet<Str> =
-            ["src/index.ts".into()].into_iter().collect();
+            std::iter::once("src/index.ts".into()).collect();
         let negative = std::collections::BTreeSet::new();
 
         // Run twice and compare hashes
@@ -328,7 +329,7 @@ mod tests {
     fn test_file_hashes_change_with_content() {
         let (temp, workspace, package) = create_test_workspace();
         let positive: std::collections::BTreeSet<Str> =
-            ["src/index.ts".into()].into_iter().collect();
+            std::iter::once("src/index.ts".into()).collect();
         let negative = std::collections::BTreeSet::new();
 
         // Get initial hash
@@ -352,7 +353,7 @@ mod tests {
     fn test_skips_directories() {
         let (_temp, workspace, package) = create_test_workspace();
         // This glob could match the `src/lib` directory if not filtered
-        let positive: std::collections::BTreeSet<Str> = ["src/*".into()].into_iter().collect();
+        let positive: std::collections::BTreeSet<Str> = std::iter::once("src/*".into()).collect();
         let negative = std::collections::BTreeSet::new();
 
         let result = compute_globbed_inputs(&package, &workspace, &positive, &negative).unwrap();
@@ -368,7 +369,7 @@ mod tests {
     fn test_no_matching_files_returns_empty() {
         let (_temp, workspace, package) = create_test_workspace();
         let positive: std::collections::BTreeSet<Str> =
-            ["nonexistent/**/*.xyz".into()].into_iter().collect();
+            std::iter::once("nonexistent/**/*.xyz".into()).collect();
         let negative = std::collections::BTreeSet::new();
 
         let result = compute_globbed_inputs(&package, &workspace, &positive, &negative).unwrap();
@@ -382,7 +383,7 @@ mod tests {
         let positive: std::collections::BTreeSet<Str> =
             ["src/**/*.ts".into(), "src/index.ts".into()].into_iter().collect();
         let negative: std::collections::BTreeSet<Str> =
-            ["**/*.test.ts".into()].into_iter().collect();
+            std::iter::once("**/*.test.ts".into()).collect();
 
         let result = compute_globbed_inputs(&package, &workspace, &positive, &negative).unwrap();
 

crates/vite_task/src/session/execute/mod.rs

@@ -28,7 +28,7 @@ use super::{
         StdioSuggestion,
     },
 };
-use crate::Session;
+use crate::{Session, collections::HashMap};
 
 /// Outcome of a spawned execution.
 ///
@@ -311,16 +311,14 @@ pub async fn execute_spawn(
     //    - std_outputs: always captured when caching is enabled (for cache replay)
     //    - path_accesses: only tracked when includes_auto is true (fspy inference)
     let (mut std_outputs, mut path_accesses, cache_metadata_and_inputs) =
-        if let Some(cache_metadata) = cache_metadata {
+        cache_metadata.map_or((None, None, None), |cache_metadata| {
             let path_accesses = if cache_metadata.input_config.includes_auto {
                 Some(TrackedPathAccesses::default())
             } else {
                 None // Skip fspy when inference is disabled
             };
             (Some(Vec::new()), path_accesses, Some((cache_metadata, globbed_inputs)))
-        } else {
-            (None, None, None)
-        };
+        });
 
     #[expect(
         clippy::large_futures,
@@ -356,9 +354,8 @@ pub async fn execute_spawn(
     {
         if result.exit_status.success() {
             // path_reads is empty when inference is disabled (path_accesses is None)
-            let empty_path_reads = Default::default();
-            let path_reads =
-                path_accesses.as_ref().map(|pa| &pa.path_reads).unwrap_or(&empty_path_reads);
+            let empty_path_reads = HashMap::default();
+            let path_reads = path_accesses.as_ref().map_or(&empty_path_reads, |pa| &pa.path_reads);
 
             // Execution succeeded — attempt to create fingerprint and update cache
             match PostRunFingerprint::create(

crates/vite_task/src/session/execute/spawn.rs

@@ -44,7 +44,7 @@ pub struct SpawnResult {
 }
 
 /// Tracked file accesses from fspy.
-/// Only populated when fspy tracking is enabled (includes_auto is true).
+/// Only populated when fspy tracking is enabled (`includes_auto` is true).
 #[derive(Default, Debug)]
 pub struct TrackedPathAccesses {
     /// Tracked path reads
@@ -77,7 +77,7 @@ pub async fn spawn_with_tracking(
     path_accesses: Option<&mut TrackedPathAccesses>,
 ) -> anyhow::Result<SpawnResult> {
     /// The tracking state of the spawned process.
-    /// Determined by whether path_accesses is Some (fspy enabled) or None (fspy disabled).
+    /// Determined by whether `path_accesses` is `Some` (fspy enabled) or `None` (fspy disabled).
     enum TrackingState {
         /// fspy tracking is enabled
         FspyEnabled(fspy::TrackedChild),

crates/vite_task_graph/src/config/mod.rs

@@ -110,7 +110,7 @@ pub struct ResolvedInputConfig {
 impl ResolvedInputConfig {
     /// Default configuration: auto-inference enabled, no explicit patterns
     #[must_use]
-    pub fn default_auto() -> Self {
+    pub const fn default_auto() -> Self {
         Self {
             includes_auto: true,
             positive_globs: BTreeSet::new(),
@@ -123,6 +123,7 @@ impl ResolvedInputConfig {
     /// - `None`: defaults to auto-inference (`[{auto: true}]`)
     /// - `Some([])`: no inputs, inference disabled
     /// - `Some([...])`: explicit patterns
+    #[must_use]
     pub fn from_user_config(user_inputs: Option<&UserInputsConfig>) -> Self {
         let Some(entries) = user_inputs else {
             // None means default to auto-inference
@@ -155,7 +156,7 @@ impl ResolvedInputConfig {
     /// Inference is disabled when `includes_auto` is false.
     #[inline]
     #[must_use]
-    pub fn inference_disabled(&self) -> bool {
+    pub const fn inference_disabled(&self) -> bool {
         !self.includes_auto
     }
 }

crates/vite_task_plan/src/plan.rs

@@ -482,6 +482,7 @@ fn strip_prefix_for_cache(
     clippy::needless_pass_by_value,
     reason = "program_path ownership is needed for Arc construction"
 )]
+#[expect(clippy::too_many_arguments, reason = "internal function with closely-related parameters")]
 fn plan_spawn_execution(
     workspace_path: &Arc<AbsolutePath>,
     execution_cache_key: Option<ExecutionCacheKey>,