refactor(cache): rename FingerprintMismatch variants and fix lint warnings

Drop redundant suffixes from FingerprintMismatch variants (e.g.
SpawnFingerprintMismatch → SpawnFingerprint) to fix enum_variant_names
lint. Also fix if_not_else and doc_markdown warnings.

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

Author: branchseer

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

@@ -155,7 +155,7 @@ pub fn format_cache_status_inline(cache_status: &CacheStatus) -> Option<Str> {
         CacheStatus::Miss(CacheMiss::FingerprintMismatch(mismatch)) => {
             // Show "cache miss" with reason why cache couldn't be used
             let reason = match mismatch {
-                FingerprintMismatch::SpawnFingerprintMismatch { old, new } => {
+                FingerprintMismatch::SpawnFingerprint { old, new } => {
                     let changes = detect_spawn_fingerprint_changes(old, new);
                     match changes.first() {
                         Some(
@@ -173,13 +173,13 @@ pub fn format_cache_status_inline(cache_status: &CacheStatus) -> Option<Str> {
                         None => "configuration changed",
                     }
                 }
-                FingerprintMismatch::InputConfigChanged => "inputs configuration changed",
-                FingerprintMismatch::GlobbedInputChanged { path } => {
+                FingerprintMismatch::InputConfig => "inputs configuration changed",
+                FingerprintMismatch::GlobbedInput { path } => {
                     return Some(vite_str::format!(
                         "✗ cache miss: content of input '{path}' changed, executing"
                     ));
                 }
-                FingerprintMismatch::PostRunFingerprintMismatch(diff) => {
+                FingerprintMismatch::PostRunFingerprint(diff) => {
                     use crate::session::execute::fingerprint::PostRunFingerprintMismatch;
                     match diff {
                         PostRunFingerprintMismatch::InputContentChanged { path } => {

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

@@ -101,33 +101,33 @@ pub enum CacheMiss {
 pub enum FingerprintMismatch {
     /// Found a previous cache entry key for the same task, but the spawn fingerprint differs.
     /// This happens when the command itself or an env changes.
-    SpawnFingerprintMismatch {
+    SpawnFingerprint {
         /// The fingerprint from the cached entry
         old: SpawnFingerprint,
         /// The fingerprint of the current execution
         new: SpawnFingerprint,
     },
     /// Found a previous cache entry key for the same task, but `input_config` or `glob_base` differs.
-    InputConfigChanged,
+    InputConfig,
     /// Found the cache entry with the same spawn fingerprint, but an explicit globbed input changed
-    GlobbedInputChanged { path: RelativePathBuf },
+    GlobbedInput { path: RelativePathBuf },
     /// Found the cache entry with the same spawn fingerprint, but the post-run fingerprint mismatches
-    PostRunFingerprintMismatch(PostRunFingerprintMismatch),
+    PostRunFingerprint(PostRunFingerprintMismatch),
 }
 
 impl Display for FingerprintMismatch {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::SpawnFingerprintMismatch { old, new } => {
+            Self::SpawnFingerprint { old, new } => {
                 write!(f, "Spawn fingerprint changed: old={old:?}, new={new:?}")
             }
-            Self::InputConfigChanged => {
+            Self::InputConfig => {
                 write!(f, "inputs configuration changed")
             }
-            Self::GlobbedInputChanged { path } => {
+            Self::GlobbedInput { path } => {
                 write!(f, "content of input '{path}' changed")
             }
-            Self::PostRunFingerprintMismatch(diff) => Display::fmt(diff, f),
+            Self::PostRunFingerprint(diff) => Display::fmt(diff, f),
         }
     }
 }
@@ -222,7 +222,7 @@ impl ExecutionCache {
                     cache_value.post_run_fingerprint.validate(workspace_root)?
             {
                 return Ok(Err(CacheMiss::FingerprintMismatch(
-                    FingerprintMismatch::PostRunFingerprintMismatch(post_run_fingerprint_mismatch),
+                    FingerprintMismatch::PostRunFingerprint(post_run_fingerprint_mismatch),
                 )));
             }
             // Associate the execution key to the cache entry key if not already,
@@ -237,14 +237,14 @@ impl ExecutionCache {
             self.get_cache_key_by_execution_key(execution_cache_key).await?
         {
             // Determine what changed: spawn fingerprint or config (input_config / glob_base)
-            let mismatch = if old_cache_key.spawn_fingerprint != *spawn_fingerprint {
-                FingerprintMismatch::SpawnFingerprintMismatch {
+            let mismatch = if old_cache_key.spawn_fingerprint == *spawn_fingerprint {
+                // spawn fingerprint is the same but input_config or glob_base changed
+                FingerprintMismatch::InputConfig
+            } else {
+                FingerprintMismatch::SpawnFingerprint {
                     old: old_cache_key.spawn_fingerprint,
                     new: spawn_fingerprint.clone(),
                 }
-            } else {
-                // spawn fingerprint is the same but input_config or glob_base changed
-                FingerprintMismatch::InputConfigChanged
             };
             return Ok(Err(CacheMiss::FingerprintMismatch(mismatch)));
         }
@@ -291,21 +291,21 @@ fn detect_globbed_input_change(
         match (s, c) {
             (None, None) => return None,
             (Some((path, _)), None) | (None, Some((path, _))) => {
-                return Some(FingerprintMismatch::GlobbedInputChanged { path: path.clone() });
+                return Some(FingerprintMismatch::GlobbedInput { path: path.clone() });
             }
             (Some((sp, sh)), Some((cp, ch))) => match sp.cmp(cp) {
                 std::cmp::Ordering::Equal => {
                     if sh != ch {
-                        return Some(FingerprintMismatch::GlobbedInputChanged { path: sp.clone() });
+                        return Some(FingerprintMismatch::GlobbedInput { path: sp.clone() });
                     }
                     s = stored_iter.next();
                     c = current_iter.next();
                 }
                 std::cmp::Ordering::Less => {
-                    return Some(FingerprintMismatch::GlobbedInputChanged { path: sp.clone() });
+                    return Some(FingerprintMismatch::GlobbedInput { path: sp.clone() });
                 }
                 std::cmp::Ordering::Greater => {
-                    return Some(FingerprintMismatch::GlobbedInputChanged { path: cp.clone() });
+                    return Some(FingerprintMismatch::GlobbedInput { path: cp.clone() });
                 }
             },
         }

crates/vite_task/src/session/reporter/summary.rs

@@ -112,7 +112,7 @@ pub enum SavedCacheMissReason {
     NotFound,
     /// Spawn fingerprint changed (command, envs, cwd, etc.).
     SpawnFingerprintChanged(Vec<SpawnFingerprintChange>),
-    /// Task configuration changed (input_config or glob_base).
+    /// Task configuration changed (`input_config` or `glob_base`).
     ConfigChanged,
     /// Content of an input file changed.
     InputContentChanged { path: Str },
@@ -237,14 +237,14 @@ impl SavedCacheMissReason {
         match cache_miss {
             CacheMiss::NotFound => Self::NotFound,
             CacheMiss::FingerprintMismatch(mismatch) => match mismatch {
-                FingerprintMismatch::SpawnFingerprintMismatch { old, new } => {
+                FingerprintMismatch::SpawnFingerprint { old, new } => {
                     Self::SpawnFingerprintChanged(detect_spawn_fingerprint_changes(old, new))
                 }
-                FingerprintMismatch::InputConfigChanged => Self::ConfigChanged,
-                FingerprintMismatch::GlobbedInputChanged { path } => {
+                FingerprintMismatch::InputConfig => Self::ConfigChanged,
+                FingerprintMismatch::GlobbedInput { path } => {
                     Self::InputContentChanged { path: Str::from(path.as_str()) }
                 }
-                FingerprintMismatch::PostRunFingerprintMismatch(diff) => {
+                FingerprintMismatch::PostRunFingerprint(diff) => {
                     use crate::session::execute::fingerprint::PostRunFingerprintMismatch;
                     match diff {
                         PostRunFingerprintMismatch::InputContentChanged { path } => {