3 files changed, 75 insertions, 24 deletions

diff --git a/crates/ra_lsp_server/src/main_loop.rs b/crates/ra_lsp_server/src/main_loop.rs
index 0e1878906..41f70f263 100644
--- a/crates/ra_lsp_server/src/main_loop.rs
+++ b/crates/ra_lsp_server/src/main_loop.rs
@@ -9,7 +9,8 @@ use gen_lsp_server::{
 };
 use languageserver_types::NumberOrString;
 use ra_analysis::{Canceled, FileId, LibraryData};
-use rayon::{self, ThreadPool};
+use rayon;
+use threadpool::ThreadPool;
 use rustc_hash::FxHashSet;
 use serde::{de::DeserializeOwned, Serialize};
 use failure::{format_err, bail};
@@ -54,11 +55,7 @@ pub fn main_loop(
     msg_receiver: &Receiver<RawMessage>,
     msg_sender: &Sender<RawMessage>,
 ) -> Result<()> {
-    let pool = rayon::ThreadPoolBuilder::new()
-        .num_threads(4)
-        .panic_handler(|_| log::error!("thread panicked :("))
-        .build()
-        .unwrap();
+    let pool = ThreadPool::new(8);
     let (task_sender, task_receiver) = unbounded::<Task>();
     let (fs_worker, fs_watcher) = vfs::roots_loader();
     let (ws_worker, ws_watcher) = workspace_loader();
@@ -155,7 +152,7 @@ fn main_loop_inner(
                 } else {
                     let (files, resolver) = state.events_to_files(events);
                     let sender = libdata_sender.clone();
-                    pool.spawn(move || {
+                    pool.execute(move || {
                         let start = ::std::time::Instant::now();
                         log::info!("indexing {} ... ", root.display());
                         let data = LibraryData::prepare(files, resolver);
@@ -321,7 +318,14 @@ fn on_notification(
                     panic!("string id's not supported: {:?}", id);
                 }
             };
-            pending_requests.remove(&id);
+            if pending_requests.remove(&id) {
+                let response = RawResponse::err(
+                    id,
+                    ErrorCode::RequestCancelled as i32,
+                    "canceled by client".to_string(),
+                );
+                msg_sender.send(RawMessage::Response(response))
+            }
             return Ok(());
         }
         Err(not) => not,
@@ -402,7 +406,7 @@ impl<'a> PoolDispatcher<'a> {
             Ok((id, params)) => {
                 let world = self.world.snapshot();
                 let sender = self.sender.clone();
-                self.pool.spawn(move || {
+                self.pool.execute(move || {
                     let resp = match f(world, params) {
                         Ok(resp) => RawResponse::ok::<R>(id, &resp),
                         Err(e) => match e.downcast::<LspError>() {
@@ -452,7 +456,7 @@ fn update_file_notifications_on_threadpool(
     sender: Sender<Task>,
     subscriptions: Vec<FileId>,
 ) {
-    pool.spawn(move || {
+    pool.execute(move || {
         for file_id in subscriptions {
             match handlers::publish_diagnostics(&world, file_id) {
                 Err(e) => {
diff --git a/crates/ra_lsp_server/src/project_model.rs b/crates/ra_lsp_server/src/project_model.rs
index 3305d468a..cb91ada90 100644
--- a/crates/ra_lsp_server/src/project_model.rs
+++ b/crates/ra_lsp_server/src/project_model.rs
@@ -1,6 +1,5 @@
 use std::path::{Path, PathBuf};
 
-use serde_derive::Serialize;
 use cargo_metadata::{metadata_run, CargoOpt};
 use ra_syntax::SmolStr;
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -11,15 +10,22 @@ use crate::{
     thread_watcher::{ThreadWatcher, Worker},
 };
 
+/// `CargoWorksapce` represents the logical structure of, well, a Cargo
+/// workspace. It pretty closely mirrors `cargo metadata` output.
+///
+/// Note that internally, rust analyzer uses a differnet structure:
+/// `CrateGraph`. `CrateGraph` is lower-level: it knows only about the crates,
+/// while this knows about `Pacakges` & `Targets`: purely cargo-related
+/// concepts.
 #[derive(Debug, Clone)]
 pub struct CargoWorkspace {
     packages: Vec<PackageData>,
     targets: Vec<TargetData>,
 }
 
-#[derive(Clone, Copy, Debug, Serialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct Package(usize);
-#[derive(Clone, Copy, Debug, Serialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct Target(usize);
 
 #[derive(Debug, Clone)]
@@ -28,6 +34,13 @@ struct PackageData {
     manifest: PathBuf,
     targets: Vec<Target>,
     is_member: bool,
+    dependencies: Vec<PackageDependency>,
+}
+
+#[derive(Debug, Clone)]
+pub struct PackageDependency {
+    pub pkg: Package,
+    pub name: SmolStr,
 }
 
 #[derive(Debug, Clone)]
@@ -61,6 +74,12 @@ impl Package {
     pub fn is_member(self, ws: &CargoWorkspace) -> bool {
         ws.pkg(self).is_member
     }
+    pub fn dependencies<'a>(
+        self,
+        ws: &'a CargoWorkspace,
+    ) -> impl Iterator<Item = &'a PackageDependency> + 'a {
+        ws.pkg(self).dependencies.iter()
+    }
 }
 
 impl Target {
@@ -106,6 +125,7 @@ impl CargoWorkspace {
                 manifest: PathBuf::from(meta_pkg.manifest_path),
                 targets: Vec::new(),
                 is_member,
+                dependencies: Vec::new(),
             };
             for meta_tgt in meta_pkg.targets {
                 let tgt = Target(targets.len());
@@ -119,6 +139,16 @@ impl CargoWorkspace {
             }
             packages.push(pkg_data)
         }
+        let resolve = meta.resolve.expect("metadata executed with deps");
+        for node in resolve.nodes {
+            let source = pkg_by_id[&node.id];
+            for id in node.dependencies {
+                let target = pkg_by_id[&id];
+                let name: SmolStr = packages[target.0].name.replace('-', "_").into();
+                let dep = PackageDependency { name, pkg: target };
+                packages[source.0].dependencies.push(dep);
+            }
+        }
 
         Ok(CargoWorkspace { packages, targets })
     }
diff --git a/crates/ra_lsp_server/src/server_world.rs b/crates/ra_lsp_server/src/server_world.rs
index c3f89ad5f..ab4c2c8aa 100644
--- a/crates/ra_lsp_server/src/server_world.rs
+++ b/crates/ra_lsp_server/src/server_world.rs
@@ -13,7 +13,7 @@ use failure::{bail, format_err};
 
 use crate::{
     path_map::{PathMap, Root},
-    project_model::CargoWorkspace,
+    project_model::{CargoWorkspace, TargetKind},
     vfs::{FileEvent, FileEventKind},
     Result,
 };
@@ -142,17 +142,34 @@ impl ServerWorldState {
     }
     pub fn set_workspaces(&mut self, ws: Vec<CargoWorkspace>) {
         let mut crate_graph = CrateGraph::default();
-        ws.iter()
-            .flat_map(|ws| {
-                ws.packages()
-                    .flat_map(move |pkg| pkg.targets(ws))
-                    .map(move |tgt| tgt.root(ws))
-            })
-            .for_each(|root| {
-                if let Some(file_id) = self.path_map.get_id(root) {
-                    crate_graph.add_crate_root(file_id);
+        let mut pkg_to_lib_crate = FxHashMap::default();
+        let mut pkg_crates = FxHashMap::default();
+        for ws in ws.iter() {
+            for pkg in ws.packages() {
+                for tgt in pkg.targets(ws) {
+                    let root = tgt.root(ws);
+                    if let Some(file_id) = self.path_map.get_id(root) {
+                        let crate_id = crate_graph.add_crate_root(file_id);
+                        if tgt.kind(ws) == TargetKind::Lib {
+                            pkg_to_lib_crate.insert(pkg, crate_id);
+                        }
+                        pkg_crates
+                            .entry(pkg)
+                            .or_insert_with(Vec::new)
+                            .push(crate_id);
+                    }
+                }
+            }
+            for pkg in ws.packages() {
+                for dep in pkg.dependencies(ws) {
+                    if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
+                        for &from in pkg_crates.get(&pkg).into_iter().flatten() {
+                            crate_graph.add_dep(from, dep.name.clone(), to);
+                        }
+                    }
                 }
-            });
+            }
+        }
         self.workspaces = Arc::new(ws);
         let mut change = AnalysisChange::new();
         change.set_crate_graph(crate_graph);