rename CommandCacheKey to CommandFingerprint

Author: Shourya742

src/bootstrap/src/utils/exec.rs

@@ -66,7 +66,7 @@ impl OutputMode {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Default)]
-pub struct CommandCacheKey {
+pub struct CommandFingerprint {
     program: OsString,
     args: Vec<OsString>,
     envs: Vec<(OsString, Option<OsString>)>,
@@ -80,11 +80,11 @@ pub struct CommandProfile {
 
 #[derive(Default)]
 pub struct CommandProfiler {
-    stats: Mutex<HashMap<CommandCacheKey, CommandProfile>>,
+    stats: Mutex<HashMap<CommandFingerprint, CommandProfile>>,
 }
 
 impl CommandProfiler {
-    pub fn record_execution(&self, key: CommandCacheKey, start_time: Instant) {
+    pub fn record_execution(&self, key: CommandFingerprint, start_time: Instant) {
         let mut stats = self.stats.lock().unwrap();
         let entry = stats.entry(key).or_default();
         entry.traces.push(ExecutionTrace::Executed {
@@ -93,7 +93,7 @@ impl CommandProfiler {
         });
     }
 
-    pub fn record_cache_hit(&self, key: CommandCacheKey) {
+    pub fn record_cache_hit(&self, key: CommandFingerprint) {
         let mut stats = self.stats.lock().unwrap();
         let entry = stats.entry(key).or_default();
         entry.traces.push(ExecutionTrace::CacheHit { timestamp: Instant::now() });
@@ -113,27 +113,24 @@ impl CommandProfiler {
                 match trace {
                     ExecutionTrace::CacheHit { timestamp } => {
                         hits += 1;
-                        println!("  - Cache hit at:   {:?}", timestamp);
+                        println!("  - Cache hit at: {timestamp:?}");
                     }
                     ExecutionTrace::Executed { duration, timestamp } => {
                         runs += 1;
-                        if max_duration.map_or(true, |d| *duration > d) {
+                        if max_duration.is_none_or(|d| *duration > d) {
                             max_duration = Some(*duration);
                         }
-                        println!("  - Executed at:    {:?}, duration: {:.2?}", timestamp, duration);
+                        println!("  - Executed at: {timestamp:?}, duration: {duration:.2?}");
                     }
                 }
             }
 
             let duration_str = match max_duration {
-                Some(d) => format!("{:.2?}", d),
+                Some(d) => format!("{d:.2?}"),
                 None => "-".into(),
             };
 
-            println!(
-                "  => Summary: {} run(s), {} hit(s), max_duration={}",
-                runs, hits, duration_str
-            );
+            println!("Summary: {runs} run(s), {hits} hit(s), max_duration={duration_str}");
         }
     }
 }
@@ -316,9 +313,9 @@ impl<'a> BootstrapCommand {
         }
     }
 
-    pub fn cache_key(&self) -> CommandCacheKey {
+    pub fn cache_key(&self) -> CommandFingerprint {
         let command = &self.command;
-        CommandCacheKey {
+        CommandFingerprint {
             program: command.get_program().into(),
             args: command.get_args().map(OsStr::to_os_string).collect(),
             envs: command
@@ -505,7 +502,7 @@ pub struct ExecutionContext {
 
 #[derive(Default)]
 pub struct CommandCache {
-    cache: Mutex<HashMap<CommandCacheKey, CommandOutput>>,
+    cache: Mutex<HashMap<CommandFingerprint, CommandOutput>>,
 }
 
 enum CommandState<'a> {
@@ -516,7 +513,7 @@ enum CommandState<'a> {
         stdout: OutputMode,
         stderr: OutputMode,
         executed_at: &'a Location<'a>,
-        cache_key: CommandCacheKey,
+        cache_key: CommandFingerprint,
         start_time: Instant,
     },
 }
@@ -533,11 +530,11 @@ pub struct DeferredCommand<'a> {
 }
 
 impl CommandCache {
-    pub fn get(&self, key: &CommandCacheKey) -> Option<CommandOutput> {
+    pub fn get(&self, key: &CommandFingerprint) -> Option<CommandOutput> {
         self.cache.lock().unwrap().get(key).cloned()
     }
 
-    pub fn insert(&self, key: CommandCacheKey, output: CommandOutput) {
+    pub fn insert(&self, key: CommandFingerprint, output: CommandOutput) {
         self.cache.lock().unwrap().insert(key, output);
     }
 }