Properly initialize build plan when Cargo-building for the first time

Author: Xanewok

src/build/cargo.rs

@@ -19,6 +19,7 @@ use serde_json;
 use crate::actions::progress::ProgressUpdate;
 use rls_data::Analysis;
 use crate::build::{BufWriter, BuildResult, CompilationContext, Internals, PackageArg};
+use crate::build::plan::Plan;
 use crate::build::environment::{self, Environment, EnvironmentLock};
 use crate::config::Config;
 use rls_vfs::Vfs;
@@ -123,7 +124,7 @@ fn run_cargo(
         let mut compilation_cx = compilation_cx.lock().unwrap();
         // Since Cargo build routine will try to regenerate the unit dep graph,
         // we need to clear the existing dep graph.
-        compilation_cx.build_plan.clear();
+        compilation_cx.build_plan = Plan::for_packages(package_arg.clone());
 
         compilation_cx.build_dir.as_ref().unwrap().clone()
     };
@@ -147,9 +148,9 @@ fn run_cargo(
     enable_nightly_features();
     let ws = Workspace::new(&manifest_path, &config)?;
 
-    let packages = match package_arg {
-        PackageArg::All => vec![],
-        PackageArg::Package(s) => vec![s]
+    let (all, packages) = match package_arg {
+        PackageArg::All => (true, vec![]),
+        PackageArg::Package(s) => (false, vec![s])
     };
 
     // TODO: It might be feasible to keep this CargoOptions structure cached and regenerate
@@ -172,7 +173,7 @@ fn run_cargo(
             (opts, rustflags, rls_config.clear_env_rust_log, rls_config.cfg_test)
         };
 
-    let spec = Packages::from_flags(false, Vec::new(), packages)?;
+    let spec = Packages::from_flags(all, Vec::new(), packages)?;
 
     let compile_opts = CompileOptions {
         spec,

src/build/plan.rs

@@ -60,29 +60,27 @@ crate struct Plan {
     // An object for finding the package which a file belongs to and this inferring
     // a package argument.
     package_map: Option<PackageMap>,
-    // The package argument used in the last Cargo build.
-    prev_package_arg: Option<PackageArg>,
+    /// Packages for which this build plan was prepared.
+    /// Used to detect if the plan can reused when building certain packages.
+    built_packages: PackageArg,
 }
 
 impl Plan {
     crate fn new() -> Plan {
+        Self::for_packages(PackageArg::All)
+    }
+
+    crate fn for_packages(pkgs: PackageArg) -> Plan {
         Plan {
             units: HashMap::new(),
             dep_graph: HashMap::new(),
             rev_dep_graph: HashMap::new(),
             compiler_jobs: HashMap::new(),
             package_map: None,
-            prev_package_arg: None,
+            built_packages: pkgs,
         }
     }
 
-    crate fn clear(&mut self) {
-        self.units = HashMap::new();
-        self.dep_graph = HashMap::new();
-        self.rev_dep_graph = HashMap::new();
-        self.compiler_jobs = HashMap::new();
-    }
-
     /// Returns whether a build plan has cached compiler invocations and dep
     /// graph so it's at all able to return a job queue via `prepare_work`.
     crate fn is_ready(&self) -> bool {
@@ -315,11 +313,7 @@ impl Plan {
             .as_ref()
             .unwrap()
             .compute_package_arg(modified);
-        let package_arg_changed = match self.prev_package_arg {
-            Some(ref ppa) => ppa != &package_arg,
-            None => true,
-        };
-        self.prev_package_arg = Some(package_arg.clone());
+        let package_arg_changed = self.built_packages != package_arg;
 
         if !self.is_ready() || requested_cargo || package_arg_changed {
             return WorkStatus::NeedsCargo(package_arg);
@@ -405,7 +399,7 @@ impl PackageMap {
         }
     }
 
-    // Fine each package in the workspace and record the root directory and package name.
+    // Find each package in the workspace and record the root directory and package name.
     fn discover_package_paths(manifest_path: &Path) -> HashMap<PathBuf, String> {
         trace!("read metadata {:?}", manifest_path);
         let metadata = match cargo_metadata::metadata(Some(manifest_path)) {