Merge #1137

1137: Adds support for multiple editor workspaces on initialization r=matklad a=jrvidal

OK, so this "simple hack" turned out to be way more contrived than I expected :joy:

### What works
This patch only handles multi-folder editor workspaces _on initialization_.
  * I've found that modifying the layout of a workspace in VSCode just reloads the extension, so this hack should be enough for now.
  * Not sure about how emacs-lsp behaves, but we fallback gracefully to the mono-folder workspace, so it should be fine.

### What doesn't work
* [x] `cargo watch` can only watch a single root folder with a `Cargo.toml`. I've left this part untouched but we could either warn that it's not supported or launch _multiple_ `cargo-watch` processes.
* [x] The `rust-analyzer/runnables` command is not functional, since we don't send the correct `cwd`.
* [x] Should we add some happy path test to `heavy_tests`?
* [ ] Going from a single `root` to multiple `roots` leaves us with a couple of `n * m` loops that smell a bit. The number of folders in the editor workspace is probably low though.

Co-authored-by: Roberto Vidal <[email protected]>

2 files changed, 76 insertions, 29 deletions

diff --git a/crates/ra_lsp_server/tests/heavy_tests/main.rs b/crates/ra_lsp_server/tests/heavy_tests/main.rs
index 407719080..6f37a980d 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/main.rs
+++ b/crates/ra_lsp_server/tests/heavy_tests/main.rs
@@ -14,7 +14,7 @@ use ra_lsp_server::req::{
 use serde_json::json;
 use tempfile::TempDir;
 
-use crate::support::{project, project_with_tmpdir};
+use crate::support::{project, Project};
 
 const LOG: &'static str = "";
 
@@ -62,6 +62,7 @@ fn foo() {
             "args": [ "test", "--", "foo", "--nocapture" ],
             "bin": "cargo",
             "env": { "RUST_BACKTRACE": "short" },
+            "cwd": null,
             "label": "test foo",
             "range": {
               "end": { "character": 1, "line": 2 },
@@ -75,6 +76,7 @@ fn foo() {
             ],
             "bin": "cargo",
             "env": {},
+            "cwd": null,
             "label": "cargo check --all",
             "range": {
               "end": {
@@ -93,25 +95,34 @@ fn foo() {
 
 #[test]
 fn test_runnables_project() {
-    let server = project(
-        r#"
-//- Cargo.toml
+    let code = r#"
+//- foo/Cargo.toml
 [package]
 name = "foo"
 version = "0.0.0"
 
-//- src/lib.rs
+//- foo/src/lib.rs
 pub fn foo() {}
 
-//- tests/spam.rs
+//- foo/tests/spam.rs
 #[test]
 fn test_eggs() {}
-"#,
-    );
+
+//- bar/Cargo.toml
+[package]
+name = "bar"
+version = "0.0.0"
+
+//- bar/src/main.rs
+fn main() {}
+"#;
+
+    let server = Project::with_fixture(code).root("foo").root("bar").server();
+
     server.wait_until_workspace_is_loaded();
     server.request::<Runnables>(
         RunnablesParams {
-            text_document: server.doc_id("tests/spam.rs"),
+            text_document: server.doc_id("foo/tests/spam.rs"),
             position: None,
         },
         json!([
@@ -123,7 +134,8 @@ fn test_eggs() {}
             "range": {
               "end": { "character": 17, "line": 1 },
               "start": { "character": 0, "line": 0 }
-            }
+            },
+            "cwd": server.path().join("foo")
           },
           {
             "args": [
@@ -135,6 +147,7 @@ fn test_eggs() {}
             ],
             "bin": "cargo",
             "env": {},
+            "cwd": server.path().join("foo"),
             "label": "cargo check -p foo",
             "range": {
               "end": {
@@ -283,7 +296,9 @@ fn main() {{}}
 "#,
         PROJECT = project.to_string(),
     );
-    let server = project_with_tmpdir(tmp_dir, &code);
+
+    let server = Project::with_fixture(&code).tmp_dir(tmp_dir).server();
+
     server.wait_until_workspace_is_loaded();
     let empty_context = || CodeActionContext { diagnostics: Vec::new(), only: None };
     server.request::<CodeActionRequest>(
diff --git a/crates/ra_lsp_server/tests/heavy_tests/support.rs b/crates/ra_lsp_server/tests/heavy_tests/support.rs
index ab9db3dd4..b07882700 100644
--- a/crates/ra_lsp_server/tests/heavy_tests/support.rs
+++ b/crates/ra_lsp_server/tests/heavy_tests/support.rs
@@ -1,7 +1,7 @@
 use std::{
     cell::{Cell, RefCell},
     fs,
-    path::PathBuf,
+    path::{Path, PathBuf},
     sync::Once,
     time::Duration,
 };
@@ -26,26 +26,51 @@ use ra_lsp_server::{
     InitializationOptions,
 };
 
-pub fn project(fixture: &str) -> Server {
-    let tmp_dir = TempDir::new().unwrap();
-    project_with_tmpdir(tmp_dir, fixture)
+pub struct Project<'a> {
+    fixture: &'a str,
+    tmp_dir: Option<TempDir>,
+    roots: Vec<PathBuf>,
 }
 
-pub fn project_with_tmpdir(tmp_dir: TempDir, fixture: &str) -> Server {
-    static INIT: Once = Once::new();
-    INIT.call_once(|| {
-        let _ = Logger::with_env_or_str(crate::LOG).start().unwrap();
-    });
+impl<'a> Project<'a> {
+    pub fn with_fixture(fixture: &str) -> Project {
+        Project { fixture, tmp_dir: None, roots: vec![] }
+    }
 
-    let mut paths = vec![];
+    pub fn tmp_dir(mut self, tmp_dir: TempDir) -> Project<'a> {
+        self.tmp_dir = Some(tmp_dir);
+        self
+    }
 
-    for entry in parse_fixture(fixture) {
-        let path = tmp_dir.path().join(entry.meta);
-        fs::create_dir_all(path.parent().unwrap()).unwrap();
-        fs::write(path.as_path(), entry.text.as_bytes()).unwrap();
-        paths.push((path, entry.text));
+    pub fn root(mut self, path: &str) -> Project<'a> {
+        self.roots.push(path.into());
+        self
     }
-    Server::new(tmp_dir, paths)
+
+    pub fn server(self) -> Server {
+        let tmp_dir = self.tmp_dir.unwrap_or_else(|| TempDir::new().unwrap());
+        static INIT: Once = Once::new();
+        INIT.call_once(|| {
+            let _ = Logger::with_env_or_str(crate::LOG).start().unwrap();
+        });
+
+        let mut paths = vec![];
+
+        for entry in parse_fixture(self.fixture) {
+            let path = tmp_dir.path().join(entry.meta);
+            fs::create_dir_all(path.parent().unwrap()).unwrap();
+            fs::write(path.as_path(), entry.text.as_bytes()).unwrap();
+            paths.push((path, entry.text));
+        }
+
+        let roots = self.roots.into_iter().map(|root| tmp_dir.path().join(root)).collect();
+
+        Server::new(tmp_dir, roots, paths)
+    }
+}
+
+pub fn project(fixture: &str) -> Server {
+    Project::with_fixture(fixture).server()
 }
 
 pub struct Server {
@@ -56,14 +81,17 @@ pub struct Server {
 }
 
 impl Server {
-    fn new(dir: TempDir, files: Vec<(PathBuf, String)>) -> Server {
+    fn new(dir: TempDir, roots: Vec<PathBuf>, files: Vec<(PathBuf, String)>) -> Server {
         let path = dir.path().to_path_buf();
+
+        let roots = if roots.is_empty() { vec![path] } else { roots };
+
         let worker = Worker::<RawMessage, RawMessage>::spawn(
             "test server",
             128,
             move |mut msg_receiver, mut msg_sender| {
                 main_loop(
-                    path,
+                    roots,
                     InitializationOptions::default(),
                     &mut msg_receiver,
                     &mut msg_sender,
@@ -177,6 +205,10 @@ impl Server {
     fn send_notification(&self, not: RawNotification) {
         self.worker.as_ref().unwrap().sender().send(RawMessage::Notification(not)).unwrap();
     }
+
+    pub fn path(&self) -> &Path {
+        self.dir.path()
+    }
 }
 
 impl Drop for Server {