Cache executed processes during in the build plan during Cargo routine

Author: Xanewok

src/build/cargo.rs

@@ -10,7 +10,7 @@
 
 use cargo::core::{PackageId, Shell, Target, Workspace, Verbosity};
 use cargo::ops::{compile_with_exec, Executor, Context, Packages, CompileOptions, CompileMode, CompileFilter, Unit};
-use cargo::util::{Config as CargoConfig, ProcessBuilder, homedir, important_paths, ConfigValue, CargoResult};
+use cargo::util::{Config as CargoConfig, process_builder, ProcessBuilder, homedir, important_paths, ConfigValue, CargoResult};
 use cargo::util::errors::{CargoErrorKind, process_error};
 use serde_json;
 
@@ -271,7 +271,7 @@ impl Executor for RlsExecutor {
         self.is_primary_crate(id)
     }
 
-    fn exec(&self, cargo_cmd: ProcessBuilder, id: &PackageId, _target: &Target) -> CargoResult<()> {
+    fn exec(&self, cargo_cmd: ProcessBuilder, id: &PackageId, target: &Target) -> CargoResult<()> {
         // Delete any stale data. We try and remove any json files with
         // the same crate name as Cargo would emit. This includes files
         // with the same crate name but different hashes, e.g., those
@@ -386,6 +386,24 @@ impl Executor for RlsExecutor {
             }
         }
 
+        // Cache executed command for the build plan
+        {
+            let mut cx = self.compilation_cx.lock().unwrap();
+
+            let mut store_cmd = process_builder::process(&rustc_exe);
+            store_cmd.args(&args.iter().map(OsString::from).collect::<Vec<_>>());
+            for (k, v) in cargo_cmd.get_envs().clone() {
+                if let Some(v) = v {
+                    store_cmd.env(&k, v);
+                }
+            }
+            if let Some(cwd) = cargo_cmd.get_cwd() {
+                cmd.current_dir(cwd);
+            }
+
+            cx.build_plan.cache_compiler_job(id, target, &store_cmd);
+        }
+
         // Prepare modified cargo-generated args/envs for future rustc calls
         args.insert(0, rustc_exe);
         let envs = cargo_cmd.get_envs().clone();

src/build/plan.rs

@@ -11,26 +11,39 @@
 use std::collections::HashMap;
 use std::fmt;
 
-use cargo::core::{PackageId, Profile, Target};
+use cargo::core::{PackageId, Profile, Target, TargetKind};
 use cargo::ops::{Kind, Unit, Context};
-use cargo::util::{CargoResult};
+use cargo::util::{CargoResult, ProcessBuilder};
 
+pub type DependencyGraph = HashMap<OwnedUnit, Vec<OwnedUnit>>;
 /// Holds the information how exactly the build will be performed for a given
 /// workspace with given, specified features.
 /// **TODO:** Use it to schedule an analysis build instead of relying on Cargo
 /// invocations.
-pub type DependencyGraph = HashMap<OwnedUnit, Vec<OwnedUnit>>;
 pub struct Plan {
-    pub dep_graph: DependencyGraph
+    pub dep_graph: DependencyGraph,
+    /// We don't make a distinction between Units with different Profiles,
+    /// as we're practically interested in bin, lib and (built, not run)
+    /// build scripts for each package, because for these we can run `rustc` job
+    pub compiler_jobs: HashMap<(PackageId, TargetKind), ProcessBuilder>,
 }
 
 impl Plan {
     pub fn new() -> Plan {
         Plan {
-            dep_graph: HashMap::new()
+            dep_graph: HashMap::new(),
+            compiler_jobs: HashMap::new(),
         }
     }
 
+
+    /// Cache a given compiler invocation in `ProcessBuilder` for a given `PackageId`
+    /// and `TargetKind` in `Target`, to be used when processing cached  build plan
+    pub fn cache_compiler_job(&mut self, id: &PackageId, target: &Target, cmd: &ProcessBuilder) {
+        let pkg_key = (id.clone(), target.kind().clone());
+        self.compiler_jobs.insert(pkg_key, cmd.clone());
+    }
+
     /// Emplace a given `Unit`, along with its `Unit` dependencies (recursively)
     /// into dependency graph
     #[allow(dead_code)]
@@ -71,18 +84,21 @@ impl Plan {
     }
 
     pub fn clear(&mut self) {
-        self.dep_graph.clear()
+        self.dep_graph.clear();
+        self.compiler_jobs.clear();
     }
 }
 
 impl fmt::Debug for Plan {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("Dep graph:\n")?;
         for (key, deps) in &self.dep_graph {
             f.write_str(&format!("{:?}\n", key))?;
             for dep in deps {
                 f.write_str(&format!("- {:?}\n", dep))?;
             }
         }
+        f.write_str(&format!("Compiler jobs: {:?}\n", self.compiler_jobs))?;
         Ok(())
     }
 }