adapt commandcachekey with should_cache logic

Author: Shourya742

src/bootstrap/src/utils/exec.rs

@@ -57,9 +57,9 @@ impl OutputMode {
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Default)]
 pub struct CommandCacheKey {
-    program: String,
-    args: Vec<String>,
-    envs: Vec<(String, String)>,
+    program: OsString,
+    args: Vec<OsString>,
+    envs: Vec<(OsString, OsString)>,
     cwd: Option<PathBuf>,
 }
 
@@ -77,28 +77,31 @@ pub struct CommandCacheKey {
 /// [allow_failure]: BootstrapCommand::allow_failure
 /// [delay_failure]: BootstrapCommand::delay_failure
 pub struct BootstrapCommand {
-    program: OsString,
-    args: Vec<OsString>,
-    envs: Vec<(OsString, OsString)>,
-    cwd: Option<PathBuf>,
-    should_cache: bool,
-
+    cache_key: CommandCacheKey,
     command: Command,
     pub failure_behavior: BehaviorOnFailure,
     // Run the command even during dry run
     pub run_always: bool,
     // This field makes sure that each command is executed (or disarmed) before it is dropped,
     // to avoid forgetting to execute a command.
     drop_bomb: DropBomb,
+    should_cache: bool,
 }
 
 impl<'a> BootstrapCommand {
     #[track_caller]
     pub fn new<S: AsRef<OsStr>>(program: S) -> Self {
-        Self { should_cache: true, ..Command::new(program).into() }
+        Self {
+            should_cache: true,
+            cache_key: CommandCacheKey {
+                program: program.as_ref().to_os_string(),
+                ..CommandCacheKey::default()
+            },
+            ..Command::new(program).into()
+        }
     }
     pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self {
-        self.args.push(arg.as_ref().to_os_string());
+        self.cache_key.args.push(arg.as_ref().to_os_string());
         self.command.arg(arg.as_ref());
         self
     }
@@ -123,7 +126,7 @@ impl<'a> BootstrapCommand {
         K: AsRef<OsStr>,
         V: AsRef<OsStr>,
     {
-        self.envs.push((key.as_ref().to_os_string(), val.as_ref().to_os_string()));
+        self.cache_key.envs.push((key.as_ref().to_os_string(), val.as_ref().to_os_string()));
         self.command.env(key, val);
         self
     }
@@ -142,7 +145,7 @@ impl<'a> BootstrapCommand {
     }
 
     pub fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Self {
-        self.cwd = Some(dir.as_ref().to_path_buf());
+        self.cache_key.cwd = Some(dir.as_ref().to_path_buf());
         self.command.current_dir(dir);
         self
     }
@@ -237,12 +240,7 @@ impl<'a> BootstrapCommand {
     }
 
     pub fn cache_key(&self) -> CommandCacheKey {
-        CommandCacheKey {
-            program: self.program.clone(),
-            args: self.args.clone(),
-            envs: self.envs.clone(),
-            cwd: self.cwd.clone(),
-        }
+        self.cache_key.clone()
     }
 }
 
@@ -259,10 +257,7 @@ impl From<Command> for BootstrapCommand {
         let program = command.get_program().to_owned();
 
         Self {
-            program: program.clone(),
-            args: Vec::new(),
-            envs: Vec::new(),
-            cwd: None,
+            cache_key: CommandCacheKey::default(),
             should_cache: false,
             command,
             failure_behavior: BehaviorOnFailure::Exit,

src/bootstrap/src/utils/execution_context.rs

@@ -149,7 +149,8 @@ impl ExecutionContext {
         let cache_key = command.cache_key();
 
         if command.should_cache()
-            && let Some(cached_output) = self.command_cache.get(&cache_key) {
+            && let Some(cached_output) = self.command_cache.get(&cache_key)
+        {
             command.mark_as_executed();
             if self.dry_run() && !command.run_always {
                 return CommandOutput::default();