Track versioned dirty files since last build

Previously only `rustc` was called on a single file or whole `cargo` routine
was executed  to perform the build and since the build plan, cached from the
`cargo` run, is used now in the `workspace_mode` instead, RLS needs to feed
it files changed since last build.
Since while the build is being performed, the user can further modify files
that are currently being built, only files that were modified prior to that
will be marked as clean.

Author: Xanewok

src/actions/notifications.rs

@@ -98,7 +98,7 @@ impl<'a> NotificationAction<'a> for DidChange {
         let ctx = ctx.inited();
         let file_path = parse_file_path!(&params.text_document.uri, "on_change")?;
 
-        let changes: Vec<Change> = params.content_changes.iter().map(move |i| {
+        let changes: Vec<Change> = params.content_changes.iter().map(|i| {
             if let Some(range) = i.range {
                 let range = ls_util::range_to_rls(range);
                 Change::ReplaceText {
@@ -114,6 +114,9 @@ impl<'a> NotificationAction<'a> for DidChange {
             }
         }).collect();
         ctx.vfs.on_changes(&changes).expect("error committing to VFS");
+        if !changes.is_empty() {
+            ctx.build_queue.mark_file_dirty(file_path, params.text_document.version)
+        }
 
         if !ctx.config.lock().unwrap().build_on_save {
             ctx.build_current_project(BuildPriority::Normal, out);

src/build/mod.rs

@@ -68,13 +68,18 @@ pub struct BuildQueue {
     queued: Arc<Mutex<(Build, Build)>>,
 }
 
+/// Used when tracking modified files across different builds.
+type FileVersion = u64;
+
 // Information needed to run and configure builds.
 struct Internals {
     // Arguments and environment with which we call rustc.
     // This can be further expanded for multi-crate target configuration.
     // This lock should only be held transiently.
     compilation_cx: Arc<Mutex<CompilationContext>>,
     env_lock: Arc<EnvironmentLock>,
+    /// Set of files that were modified since last build.
+    dirty_files: Arc<Mutex<HashMap<PathBuf, FileVersion>>>,
     vfs: Arc<Vfs>,
     // This lock should only be held transiently.
     config: Arc<Mutex<Config>>,
@@ -146,7 +151,8 @@ enum Build {
 struct PendingBuild {
     build_dir: PathBuf,
     priority: BuildPriority,
-    // Closure to execture once the build is complete.
+    built_files: HashMap<PathBuf, FileVersion>,
+    // Closure to execute once the build is complete.
     and_then: Box<FnBox(BuildResult) + Send + 'static>,
 }
 
@@ -228,6 +234,7 @@ impl BuildQueue {
 
         let build = PendingBuild {
             build_dir: new_build_dir.to_owned(),
+            built_files: self.internals.dirty_files.lock().unwrap().clone(),
             priority,
             and_then: Box::new(and_then),
         };
@@ -324,7 +331,8 @@ impl BuildQueue {
             }
 
             // Run the build.
-            let result = internals.run_build(&build.build_dir, build.priority);
+            let result = internals.run_build(&build.build_dir, build.priority,
+                                             &build.built_files);
             // Assert that the build was not squashed.
             if let BuildResult::Squashed = result {
                 unreachable!();
@@ -340,6 +348,14 @@ impl BuildQueue {
             }
         }
     }
+
+    /// Marks a given versioned file as dirty since last build. The dirty flag
+    /// will be cleared by a successful build that builds this or a more recent
+    /// version of this file.
+    pub fn mark_file_dirty(&self, file: PathBuf, version: FileVersion) {
+        trace!("Marking file as dirty: {:?} ({})", file, version);
+        self.internals.dirty_files.lock().unwrap().insert(file, version);
+    }
 }
 
 impl Internals {
@@ -348,6 +364,7 @@ impl Internals {
             compilation_cx: Arc::new(Mutex::new(CompilationContext::new())),
             vfs,
             config,
+            dirty_files: Arc::new(Mutex::new(HashMap::new())),
             // Since environment is global mutable state and we can run multiple server
             // instances, be sure to use a global lock to ensure env var consistency
             env_lock: EnvironmentLock::get(),
@@ -356,7 +373,12 @@ impl Internals {
     }
 
     // Entry point method for building.
-    fn run_build(&self, new_build_dir: &Path, priority: BuildPriority) -> BuildResult {
+    fn run_build(
+        &self,
+        new_build_dir: &Path,
+        priority: BuildPriority,
+        built_files: &HashMap<PathBuf, FileVersion>,
+    ) -> BuildResult {
         trace!("run_build, {:?} {:?}", new_build_dir, priority);
 
         // Check if the build directory changed and update it.
@@ -375,7 +397,23 @@ impl Internals {
             }
         }
 
-        self.build()
+        let result = self.build();
+        // On a successful build, clear dirty files that were successfuly built
+        // now. It's possible that a build was scheduled with given files, but
+        // user later changed them. These should still be left as dirty (not built).
+        match *&result {
+            BuildResult::Success(_, _) | BuildResult::Failure(_, _) => {
+                let mut dirty_files = self.dirty_files.lock().unwrap();
+                dirty_files.retain(|file, dirty_version| {
+                    built_files.get(file)
+                    .map(|built_version| built_version < dirty_version)
+                    .unwrap_or(false)
+                });
+                trace!("Files still dirty after the build: {:?}", *dirty_files);
+            },
+            _ => {}
+        };
+        result
     }
 
     // Build the project.
@@ -405,9 +443,9 @@ impl Internals {
             // If the build plan has already been cached, use it, unless Cargo
             // has to be specifically rerun (e.g. when build scripts changed)
             let work = {
+                let modified: Vec<_> = self.dirty_files.lock().unwrap()
+                                           .keys().cloned().collect();
                 let cx = self.compilation_cx.lock().unwrap();
-                let modified: Vec<_> = self.vfs.get_changes().keys().cloned().collect();
-
                 cx.build_plan.prepare_work(&modified)
             };
             return match work {