Merge branch 'master' of github.com:rust-lang-nursery/rls

Author: nrc

contributing.md

@@ -123,12 +123,12 @@ temporary logging you may find the `eprintln` macro useful.
 Test using `cargo test`.
 
 Testing is unfortunately minimal. There is support for regression tests, but not
-many actual tests exists yet. There is signifcant [work to do](https://github.com/rust-lang-nursery/rls/issues/12)
+many actual tests exists yet. There is significant [work to do](https://github.com/rust-lang-nursery/rls/issues/12)
 before we have a comprehensive testing story.
 
 You can run the RLS in command line mode by running with an argument (any
 argument), e.g., `cargo run -- foo`. You need to run it in the root directory of
-the project to be analysed. This should initialise the RLS (which will take some
+the project to be analyzed. This should initialize the RLS (which will take some
 time for large projects) and then give you a `>` prompt. Type `help` (or just
 `h`) to see the commands available.
 
@@ -223,7 +223,7 @@ inside your project's target directory.
 
 The goal of the RLS project is to provide an awesome IDE experience *now*. That
 means not waiting for incremental compilation support in the compiler. However,
-Rust is a somewhat complex language to analyse and providing precise and
+Rust is a somewhat complex language to analyze and providing precise and
 complete information about programs requires using the compiler.
 
 The RLS has two data sources - the compiler and Racer. The compiler is always
@@ -271,7 +271,7 @@ change](https://github.com/rust-lang-nursery/rls/issues/25)).
 
 ### Analysis data
 
-From the compiler, we get a serialised dump of its analysis data (from name
+From the compiler, we get a serialized dump of its analysis data (from name
 resolution and type checking). We combine data from all crates and the standard
 libraries and combine this into an index for the whole project. We cross-
 reference and store this data in HashMaps and use it to look up data for the

debugging.md

@@ -149,7 +149,7 @@ Some crates can have surprisingly large data files. Large data files can slow
 down the RLS to the point of crashing (or appearing to crash). Check the json
 files in the `target/rls/deps/save-analysis` directory. Anything over 1mb is
 suspicious. You can test if this is important by deleting the json file(s) and
-restating the extension (you'd have to do this every time you do a full build,
+restarting the extension (you'd have to do this every time you do a full build,
 for example after `cargo clean` or updating the toolchain).
 
 If you find such large data files, please report an issue on this repo. We can

src/actions/mod.rs

@@ -11,6 +11,8 @@
 use analysis::AnalysisHost;
 use vfs::Vfs;
 use config::{Config, FmtConfig};
+use serde_json;
+use url::Url;
 use span;
 use Span;
 
@@ -211,6 +213,51 @@ fn find_word_at_pos(line: &str, pos: &Column) -> (Column, Column) {
     (span::Column::new_zero_indexed(start), span::Column::new_zero_indexed(end))
 }
 
+// TODO include workspace Cargo.tomls in watchers / relevant
+/// Client file-watching request / filtering logic
+/// We want to watch workspace 'Cargo.toml', root 'Cargo.lock' & the root 'target' dir
+pub struct FileWatch<'ctx> {
+    project_str: &'ctx str,
+    project_uri: String,
+}
+
+impl<'ctx> FileWatch<'ctx> {
+    pub fn new(ctx: &'ctx InitActionContext) -> Self {
+        Self {
+            project_str: ctx.current_project.to_str().unwrap(),
+            project_uri: Url::from_file_path(&ctx.current_project).unwrap().into_string(),
+        }
+    }
+
+    /// Returns json config for desired file watches
+    pub fn watchers_config(&self) -> serde_json::Value {
+        let pattern = format!("{}/Cargo{{.toml,.lock}}", self.project_str);
+        let target_pattern = format!("{}/target", self.project_str);
+        // For target, we only watch if it gets deleted.
+        json!({
+            "watchers": [{ "globPattern": pattern }, { "globPattern": target_pattern, "kind": 4 }]
+        })
+    }
+
+    /// Returns if a file change is relevant to the files we actually wanted to watch
+    // Implementation note: This is expected to be called a large number of times in a loop
+    // so should be fast / avoid allocation.
+    #[inline]
+    pub fn is_relevant(&self, change: &FileEvent) -> bool {
+        let path = change.uri.as_str();
+
+        if !path.starts_with(&self.project_uri) {
+            return false;
+        }
+
+        let local = &path[self.project_uri.len()..];
+
+        local == "/Cargo.lock" || local == "/Cargo.toml"
+            || local == "/target" && change.typ == FileChangeType::Deleted
+    }
+}
+
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -244,4 +291,4 @@ mod test {
         assert_range("span::Position<|T>", (15, 16));
         assert_range("span::Position<T|>", (15, 16));
     }
-}
+}

src/actions/notifications.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use actions::ActionContext;
+use actions::FileWatch;
 use vfs::Change;
 use config::Config;
 use serde::Deserialize;
@@ -42,13 +43,7 @@ impl<'a> NotificationAction<'a> for Initialized {
 
         let ctx = ctx.inited();
 
-        // TODO we should watch for workspace Cargo.tomls too
-        let pattern = format!("{}/Cargo{{.toml,.lock}}", ctx.current_project.to_str().unwrap());
-        let target_pattern = format!("{}/target", ctx.current_project.to_str().unwrap());
-        // For target, we only watch if it gets deleted.
-        let options = json!({
-            "watchers": [{ "globPattern": pattern }, { "globPattern": target_pattern, "kind": 4 }]
-        });
+        let options = FileWatch::new(&ctx).watchers_config();
         let output = serde_json::to_string(
             &RequestMessage::new(out.provide_id(),
                                  NOTIFICATION__RegisterCapability.to_owned(),
@@ -271,10 +266,20 @@ impl<'a> Action<'a> for DidChangeWatchedFiles {
 }
 
 impl<'a> NotificationAction<'a> for DidChangeWatchedFiles {
-    fn handle<O: Output>(&mut self, _params: DidChangeWatchedFilesParams, ctx: &mut ActionContext, out: O) -> Result<(), ()> {
+    fn handle<O: Output>(
+        &mut self,
+        params: DidChangeWatchedFilesParams,
+        ctx: &mut ActionContext,
+        out: O,
+    ) -> Result<(), ()> {
         trace!("on_cargo_change: thread: {:?}", thread::current().id());
+
         let ctx = ctx.inited();
-        ctx.build_current_project(BuildPriority::Cargo, out);
+        let file_watch = FileWatch::new(&ctx);
+
+        if params.changes.iter().any(|c| file_watch.is_relevant(c)) {
+            ctx.build_current_project(BuildPriority::Cargo, out);
+        }
 
         Ok(())
     }

src/actions/requests.rs

@@ -795,10 +795,10 @@ fn pos_to_racer_location(pos: Position) -> racer::Location {
     racer::Location::Coords(racer_coord(pos.row.one_indexed(), pos.col))
 }
 
-fn location_from_racer_match(mtch: racer::Match) -> Option<Location> {
-    let source_path = &mtch.filepath;
+fn location_from_racer_match(a_match: racer::Match) -> Option<Location> {
+    let source_path = &a_match.filepath;
 
-    mtch.coords.map(|coord| {
+    a_match.coords.map(|coord| {
         let (row, col) = from_racer_coord(coord);
         let loc = span::Location::new(row.zero_indexed(), col, source_path);
         ls_util::rls_location_to_location(&loc)

src/build/cargo.rs

@@ -39,8 +39,8 @@ pub(super) fn cargo(internals: &Internals) -> BuildResult {
 
     let diagnostics = Arc::new(Mutex::new(vec![]));
     let diagnostics_clone = diagnostics.clone();
-    let analyses = Arc::new(Mutex::new(vec![]));
-    let analyses_clone = analyses.clone();
+    let analysis = Arc::new(Mutex::new(vec![]));
+    let analysis_clone = analysis.clone();
     let out = Arc::new(Mutex::new(vec![]));
     let out_clone = out.clone();
 
@@ -49,13 +49,13 @@ pub(super) fn cargo(internals: &Internals) -> BuildResult {
     // However, if Cargo doesn't run a separate thread, then we'll just wait
     // forever. Therefore, we spawn an extra thread here to be safe.
     let handle = thread::spawn(|| run_cargo(compilation_cx, config, vfs, env_lock,
-                                            diagnostics, analyses, out));
+                                            diagnostics, analysis, out));
 
     match handle.join().map_err(|_| "thread panicked".into()).and_then(|res| res) {
         Ok(_) if workspace_mode => {
             let diagnostics = Arc::try_unwrap(diagnostics_clone).unwrap().into_inner().unwrap();
-            let analyses = Arc::try_unwrap(analyses_clone).unwrap().into_inner().unwrap();
-            BuildResult::Success(diagnostics, analyses)
+            let analysis = Arc::try_unwrap(analysis_clone).unwrap().into_inner().unwrap();
+            BuildResult::Success(diagnostics, analysis)
         },
         Ok(_) => BuildResult::Success(vec![], vec![]),
         Err(err) => {
@@ -71,7 +71,7 @@ fn run_cargo(compilation_cx: Arc<Mutex<CompilationContext>>,
              vfs: Arc<Vfs>,
              env_lock: Arc<EnvironmentLock>,
              compiler_messages: Arc<Mutex<Vec<String>>>,
-             analyses: Arc<Mutex<Vec<Analysis>>>,
+             analysis: Arc<Mutex<Vec<Analysis>>>,
              out: Arc<Mutex<Vec<u8>>>) -> CargoResult<()> {
     // Lock early to guarantee synchronized access to env var for the scope of Cargo routine.
     // Additionally we need to pass inner lock to RlsExecutor, since it needs to hand it down
@@ -169,7 +169,7 @@ fn run_cargo(compilation_cx: Arc<Mutex<CompilationContext>>,
                                 inner_lock,
                                 vfs,
                                 compiler_messages,
-                                analyses);
+                                analysis);
 
     compile_with_exec(&ws, &compile_opts, Arc::new(exec))?;
 
@@ -188,7 +188,7 @@ struct RlsExecutor {
     /// env var access during underlying `rustc()` calls during parallel `exec()` callback threads.
     env_lock: environment::InnerLock,
     vfs: Arc<Vfs>,
-    analyses: Arc<Mutex<Vec<Analysis>>>,
+    analysis: Arc<Mutex<Vec<Analysis>>>,
     workspace_mode: bool,
     /// Packages which are directly a member of the workspace, for which
     /// analysis and diagnostics will be provided
@@ -204,7 +204,7 @@ impl RlsExecutor {
            env_lock: environment::InnerLock,
            vfs: Arc<Vfs>,
            compiler_messages: Arc<Mutex<Vec<String>>>,
-           analyses: Arc<Mutex<Vec<Analysis>>>)
+           analysis: Arc<Mutex<Vec<Analysis>>>)
     -> RlsExecutor {
         let workspace_mode = config.lock().unwrap().workspace_mode;
         let (cur_package_id, member_packages) = if workspace_mode {
@@ -225,21 +225,21 @@ impl RlsExecutor {
             config,
             env_lock,
             vfs,
-            analyses,
+            analysis,
             workspace_mode,
             member_packages: Mutex::new(member_packages),
             compiler_messages,
         }
     }
 
-    /// Returns wheter a given package is a primary one (every member of the
+    /// Returns whether a given package is a primary one (every member of the
     /// workspace is considered as such).
     fn is_primary_crate(&self, id: &PackageId) -> bool {
         if self.workspace_mode {
             self.member_packages.lock().unwrap().contains(id)
         } else {
             let cur_package_id = self.cur_package_id.lock().unwrap();
-            id == cur_package_id.as_ref().expect("Executor has not been initialised")
+            id == cur_package_id.as_ref().expect("Executor has not been initialized")
         }
     }
 }
@@ -352,7 +352,7 @@ impl Executor for RlsExecutor {
         {
             let config = self.config.lock().unwrap();
             let crate_type = parse_arg(cargo_args, "--crate-type");
-            // Becase we only try to emulate `cargo test` using `cargo check`, so for now
+            // Because we only try to emulate `cargo test` using `cargo check`, so for now
             // assume crate_type arg (i.e. in `cargo test` it isn't specified for --test targets)
             // and build test harness only for final crate type
             let crate_type = crate_type.expect("no crate-type in rustc command line");
@@ -417,7 +417,7 @@ impl Executor for RlsExecutor {
                 BuildResult::Success(mut messages, mut analysis) |
                 BuildResult::Failure(mut messages, mut analysis) => {
                     self.compiler_messages.lock().unwrap().append(&mut messages);
-                    self.analyses.lock().unwrap().append(&mut analysis);
+                    self.analysis.lock().unwrap().append(&mut analysis);
                 }
                 _ => {}
             }

src/build/environment.rs

@@ -67,7 +67,7 @@ impl<'a> Drop for Environment<'a> {
 /// It uses two locks instead of one, because RLS, while executing a Cargo build routine, not only
 /// needs to guarantee consistent env vars across the Cargo invocation, but also, while holding it,
 /// it needs to provide a more fine-grained way to synchronize env vars across different inner
-/// compiler invokations, for which Cargo sets specific env vars.
+/// compiler invocations, for which Cargo sets specific env vars.
 /// To enforce proper env var guarantees, regular rustc and Cargo build routines must first acquire
 /// the first, outer lock. Only then, if needed, nested rustc calls inside Cargo routine can
 /// acquire the second, inner lock.

src/build/mod.rs

@@ -88,11 +88,11 @@ struct Internals {
 
 #[derive(Debug)]
 pub enum BuildResult {
-    // Build was succesful, argument is warnings.
+    // Build was successful, argument is warnings.
     Success(Vec<String>, Vec<Analysis>),
     // Build finished with errors, argument is errors and warnings.
     Failure(Vec<String>, Vec<Analysis>),
-    // Build was coelesced with another build.
+    // Build was coalesced with another build.
     Squashed,
     // There was an error attempting to build.
     Err,
@@ -320,11 +320,11 @@ impl BuildQueue {
                 thread::sleep(Duration::from_millis(wait_to_build));
 
                 // Check if a new build arrived while we were sleeping.
-                let interupt = {
+                let interrupt = {
                     let queued = queued.lock().unwrap();
                     queued.0.is_pending() || queued.1.is_pending()
                 };
-                if interupt {
+                if interrupt {
                     and_then(BuildResult::Squashed);
                     continue;
                 }
@@ -398,7 +398,7 @@ impl Internals {
         }
 
         let result = self.build();
-        // On a successful build, clear dirty files that were successfuly built
+        // On a successful build, clear dirty files that were successfully 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 {

src/build/rustc.rs

@@ -73,7 +73,7 @@ pub fn rustc(vfs: &Vfs, args: &[String], envs: &HashMap<String, Option<OsString>
     });
 
     // FIXME(#25) given that we are running the compiler directly, there is no need
-    // to serialise the error messages - we should pass them in memory.
+    // to serialize the error messages - we should pass them in memory.
     let err_buf = Arc::try_unwrap(err_buf).unwrap().into_inner().unwrap();
     let err_buf = String::from_utf8(err_buf).unwrap();
     let stderr_json_msgs: Vec<_> = err_buf.lines().map(String::from).collect();

src/cmd.rs

@@ -228,8 +228,8 @@ impl server::MessageReader for ChannelMsgReader {
     }
 }
 
-// Initialise a server, returns the sender end of a channel for posting messages.
-// The initialised server will live on its own thread and look after the receiver.
+// Initialize a server, returns the sender end of a channel for posting messages.
+// The initialized server will live on its own thread and look after the receiver.
 fn init() -> Sender<String> {
     let analysis = Arc::new(AnalysisHost::new(Target::Debug));
     let vfs = Arc::new(Vfs::new());
@@ -243,7 +243,7 @@ fn init() -> Sender<String> {
     thread::spawn(move || LsService::run(service));
 
     sender.send(initialize(::std::env::current_dir().unwrap().to_str().unwrap().to_owned()).to_string()).expect("Error sending init");
-    println!("Initialising (look for `diagnosticsEnd` message)...");
+    println!("Initializing (look for `diagnosticsEnd` message)...");
 
     sender
 }

src/server/io.rs

@@ -107,7 +107,7 @@ pub trait Output: Sync + Send + Clone + 'static {
         let data = match serde_json::to_string(data) {
             Ok(data) => data,
             Err(e) => {
-                debug!("Could not serialise data for success message. ");
+                debug!("Could not serialize data for success message. ");
                 debug!("  Data: `{:?}`", data);
                 debug!("  Error: {:?}", e);
                 return;