4 files changed, 185 insertions, 186 deletions

diff --git a/crates/ra_proc_macro_srv/src/dylib.rs b/crates/ra_proc_macro_srv/src/dylib.rs
index ec63d587b..7d6e5d323 100644
--- a/crates/ra_proc_macro_srv/src/dylib.rs
+++ b/crates/ra_proc_macro_srv/src/dylib.rs
@@ -16,55 +16,53 @@ fn invalid_data_err(e: impl Into<Box<dyn std::error::Error + Send + Sync>>) -> I
     IoError::new(IoErrorKind::InvalidData, e)
 }
 
-fn get_symbols_from_lib(file: &Path) -> Result<Vec<String>, IoError> {
+fn is_derive_registrar_symbol(symbol: &str) -> bool {
+    symbol.contains(NEW_REGISTRAR_SYMBOL)
+}
+
+fn find_registrar_symbol(file: &Path) -> Result<Option<String>, IoError> {
     let buffer = std::fs::read(file)?;
     let object = Object::parse(&buffer).map_err(invalid_data_err)?;
 
     match object {
         Object::Elf(elf) => {
             let symbols = elf.dynstrtab.to_vec().map_err(invalid_data_err)?;
-            let names = symbols.iter().map(|s| s.to_string()).collect();
-            Ok(names)
+            let name =
+                symbols.iter().find(|s| is_derive_registrar_symbol(s)).map(|s| s.to_string());
+            Ok(name)
         }
         Object::PE(pe) => {
-            let symbol_names =
-                pe.exports.iter().flat_map(|s| s.name).map(|n| n.to_string()).collect();
-            Ok(symbol_names)
+            let name = pe
+                .exports
+                .iter()
+                .flat_map(|s| s.name)
+                .find(|s| is_derive_registrar_symbol(s))
+                .map(|s| s.to_string());
+            Ok(name)
         }
-        Object::Mach(mach) => match mach {
-            Mach::Binary(binary) => {
-                let exports = binary.exports().map_err(invalid_data_err)?;
-                let names = exports
-                    .into_iter()
-                    .map(|s| {
-                        // In macos doc:
-                        // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/dlsym.3.html
-                        // Unlike other dyld API's, the symbol name passed to dlsym() must NOT be
-                        // prepended with an underscore.
-                        if s.name.starts_with("_") {
-                            s.name[1..].to_string()
-                        } else {
-                            s.name
-                        }
-                    })
-                    .collect();
-                Ok(names)
-            }
-            Mach::Fat(_) => Ok(vec![]),
-        },
-        Object::Archive(_) | Object::Unknown(_) => Ok(vec![]),
+        Object::Mach(Mach::Binary(binary)) => {
+            let exports = binary.exports().map_err(invalid_data_err)?;
+            let name = exports
+                .iter()
+                .map(|s| {
+                    // In macos doc:
+                    // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/dlsym.3.html
+                    // Unlike other dyld API's, the symbol name passed to dlsym() must NOT be
+                    // prepended with an underscore.
+                    if s.name.starts_with("_") {
+                        &s.name[1..]
+                    } else {
+                        &s.name
+                    }
+                })
+                .find(|s| is_derive_registrar_symbol(&s))
+                .map(|s| s.to_string());
+            Ok(name)
+        }
+        _ => Ok(None),
     }
 }
 
-fn is_derive_registrar_symbol(symbol: &str) -> bool {
-    symbol.contains(NEW_REGISTRAR_SYMBOL)
-}
-
-fn find_registrar_symbol(file: &Path) -> Result<Option<String>, IoError> {
-    let symbols = get_symbols_from_lib(file)?;
-    Ok(symbols.into_iter().find(|s| is_derive_registrar_symbol(s)))
-}
-
 /// Loads dynamic library in platform dependent manner.
 ///
 /// For unix, you have to use RTLD_DEEPBIND flag to escape problems described
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index 0ab64a1e0..03f2629da 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -5,9 +5,8 @@ mod json_project;
 mod sysroot;
 
 use std::{
-    error::Error,
     fs::{read_dir, File, ReadDir},
-    io::BufReader,
+    io::{self, BufReader},
     path::{Path, PathBuf},
     process::Command,
 };
@@ -25,25 +24,6 @@ pub use crate::{
 };
 pub use ra_proc_macro::ProcMacroClient;
 
-#[derive(Clone, PartialEq, Eq, Hash, Debug)]
-pub struct CargoTomlNotFoundError {
-    pub searched_at: PathBuf,
-    pub reason: String,
-}
-
-impl std::fmt::Display for CargoTomlNotFoundError {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            fmt,
-            "can't find Cargo.toml at {}, due to {}",
-            self.searched_at.display(),
-            self.reason
-        )
-    }
-}
-
-impl Error for CargoTomlNotFoundError {}
-
 #[derive(Debug, Clone)]
 pub enum ProjectWorkspace {
     /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`.
@@ -77,31 +57,119 @@ impl PackageRoot {
     }
 }
 
-impl ProjectWorkspace {
-    pub fn discover(path: &Path, cargo_features: &CargoConfig) -> Result<ProjectWorkspace> {
-        ProjectWorkspace::discover_with_sysroot(path, true, cargo_features)
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ProjectRoot {
+    ProjectJson(PathBuf),
+    CargoToml(PathBuf),
+}
+
+impl ProjectRoot {
+    pub fn from_manifest_file(path: PathBuf) -> Result<ProjectRoot> {
+        if path.ends_with("rust-project.json") {
+            return Ok(ProjectRoot::ProjectJson(path));
+        }
+        if path.ends_with("Cargo.toml") {
+            return Ok(ProjectRoot::CargoToml(path));
+        }
+        bail!("project root must point to Cargo.toml or rust-project.json: {}", path.display())
     }
 
-    pub fn discover_with_sysroot(
-        path: &Path,
-        with_sysroot: bool,
+    pub fn discover_single(path: &Path) -> Result<ProjectRoot> {
+        let mut candidates = ProjectRoot::discover(path)?;
+        let res = match candidates.pop() {
+            None => bail!("no projects"),
+            Some(it) => it,
+        };
+
+        if !candidates.is_empty() {
+            bail!("more than one project")
+        }
+        Ok(res)
+    }
+
+    pub fn discover(path: &Path) -> io::Result<Vec<ProjectRoot>> {
+        if let Some(project_json) = find_rust_project_json(path) {
+            return Ok(vec![ProjectRoot::ProjectJson(project_json)]);
+        }
+        return find_cargo_toml(path)
+            .map(|paths| paths.into_iter().map(ProjectRoot::CargoToml).collect());
+
+        fn find_rust_project_json(path: &Path) -> Option<PathBuf> {
+            if path.ends_with("rust-project.json") {
+                return Some(path.to_path_buf());
+            }
+
+            let mut curr = Some(path);
+            while let Some(path) = curr {
+                let candidate = path.join("rust-project.json");
+                if candidate.exists() {
+                    return Some(candidate);
+                }
+                curr = path.parent();
+            }
+
+            None
+        }
+
+        fn find_cargo_toml(path: &Path) -> io::Result<Vec<PathBuf>> {
+            if path.ends_with("Cargo.toml") {
+                return Ok(vec![path.to_path_buf()]);
+            }
+
+            if let Some(p) = find_cargo_toml_in_parent_dir(path) {
+                return Ok(vec![p]);
+            }
+
+            let entities = read_dir(path)?;
+            Ok(find_cargo_toml_in_child_dir(entities))
+        }
+
+        fn find_cargo_toml_in_parent_dir(path: &Path) -> Option<PathBuf> {
+            let mut curr = Some(path);
+            while let Some(path) = curr {
+                let candidate = path.join("Cargo.toml");
+                if candidate.exists() {
+                    return Some(candidate);
+                }
+                curr = path.parent();
+            }
+
+            None
+        }
+
+        fn find_cargo_toml_in_child_dir(entities: ReadDir) -> Vec<PathBuf> {
+            // Only one level down to avoid cycles the easy way and stop a runaway scan with large projects
+            let mut valid_canditates = vec![];
+            for entity in entities.filter_map(Result::ok) {
+                let candidate = entity.path().join("Cargo.toml");
+                if candidate.exists() {
+                    valid_canditates.push(candidate)
+                }
+            }
+            valid_canditates
+        }
+    }
+}
+
+impl ProjectWorkspace {
+    pub fn load(
+        root: ProjectRoot,
         cargo_features: &CargoConfig,
+        with_sysroot: bool,
     ) -> Result<ProjectWorkspace> {
-        match find_rust_project_json(path) {
-            Some(json_path) => {
-                let file = File::open(&json_path)
-                    .with_context(|| format!("Failed to open json file {}", json_path.display()))?;
+        let res = match root {
+            ProjectRoot::ProjectJson(project_json) => {
+                let file = File::open(&project_json).with_context(|| {
+                    format!("Failed to open json file {}", project_json.display())
+                })?;
                 let reader = BufReader::new(file);
-                Ok(ProjectWorkspace::Json {
+                ProjectWorkspace::Json {
                     project: from_reader(reader).with_context(|| {
-                        format!("Failed to deserialize json file {}", json_path.display())
+                        format!("Failed to deserialize json file {}", project_json.display())
                     })?,
-                })
+                }
             }
-            None => {
-                let cargo_toml = find_cargo_toml(path).with_context(|| {
-                    format!("Failed to find Cargo.toml for path {}", path.display())
-                })?;
+            ProjectRoot::CargoToml(cargo_toml) => {
                 let cargo = CargoWorkspace::from_cargo_metadata(&cargo_toml, cargo_features)
                     .with_context(|| {
                         format!(
@@ -119,9 +187,11 @@ impl ProjectWorkspace {
                 } else {
                     Sysroot::default()
                 };
-                Ok(ProjectWorkspace::Cargo { cargo, sysroot })
+                ProjectWorkspace::Cargo { cargo, sysroot }
             }
-        }
+        };
+
+        Ok(res)
     }
 
     /// Returns the roots for the current `ProjectWorkspace`
@@ -469,87 +539,6 @@ impl ProjectWorkspace {
     }
 }
 
-fn find_rust_project_json(path: &Path) -> Option<PathBuf> {
-    if path.ends_with("rust-project.json") {
-        return Some(path.to_path_buf());
-    }
-
-    let mut curr = Some(path);
-    while let Some(path) = curr {
-        let candidate = path.join("rust-project.json");
-        if candidate.exists() {
-            return Some(candidate);
-        }
-        curr = path.parent();
-    }
-
-    None
-}
-
-fn find_cargo_toml_in_parent_dir(path: &Path) -> Option<PathBuf> {
-    let mut curr = Some(path);
-    while let Some(path) = curr {
-        let candidate = path.join("Cargo.toml");
-        if candidate.exists() {
-            return Some(candidate);
-        }
-        curr = path.parent();
-    }
-
-    None
-}
-
-fn find_cargo_toml_in_child_dir(entities: ReadDir) -> Vec<PathBuf> {
-    // Only one level down to avoid cycles the easy way and stop a runaway scan with large projects
-    let mut valid_canditates = vec![];
-    for entity in entities.filter_map(Result::ok) {
-        let candidate = entity.path().join("Cargo.toml");
-        if candidate.exists() {
-            valid_canditates.push(candidate)
-        }
-    }
-    valid_canditates
-}
-
-fn find_cargo_toml(path: &Path) -> Result<PathBuf> {
-    if path.ends_with("Cargo.toml") {
-        return Ok(path.to_path_buf());
-    }
-
-    if let Some(p) = find_cargo_toml_in_parent_dir(path) {
-        return Ok(p);
-    }
-
-    let entities = match read_dir(path) {
-        Ok(entities) => entities,
-        Err(e) => {
-            return Err(CargoTomlNotFoundError {
-                searched_at: path.to_path_buf(),
-                reason: format!("file system error: {}", e),
-            }
-            .into());
-        }
-    };
-
-    let mut valid_canditates = find_cargo_toml_in_child_dir(entities);
-    match valid_canditates.len() {
-        1 => Ok(valid_canditates.remove(0)),
-        0 => Err(CargoTomlNotFoundError {
-            searched_at: path.to_path_buf(),
-            reason: "no Cargo.toml file found".to_string(),
-        }
-        .into()),
-        _ => Err(CargoTomlNotFoundError {
-            searched_at: path.to_path_buf(),
-            reason: format!(
-                "multiple equally valid Cargo.toml files found: {:?}",
-                valid_canditates
-            ),
-        }
-        .into()),
-    }
-}
-
 pub fn get_rustc_cfg_options() -> CfgOptions {
     let mut cfg_options = CfgOptions::default();
 
diff --git a/crates/rust-analyzer/src/cli/load_cargo.rs b/crates/rust-analyzer/src/cli/load_cargo.rs
index 018be70ee..762f776fe 100644
--- a/crates/rust-analyzer/src/cli/load_cargo.rs
+++ b/crates/rust-analyzer/src/cli/load_cargo.rs
@@ -8,7 +8,7 @@ use crossbeam_channel::{unbounded, Receiver};
 use ra_db::{ExternSourceId, FileId, SourceRootId};
 use ra_ide::{AnalysisChange, AnalysisHost};
 use ra_project_model::{
-    get_rustc_cfg_options, CargoConfig, PackageRoot, ProcMacroClient, ProjectWorkspace,
+    get_rustc_cfg_options, CargoConfig, PackageRoot, ProcMacroClient, ProjectRoot, ProjectWorkspace,
 };
 use ra_vfs::{RootEntry, Vfs, VfsChange, VfsTask, Watch};
 use rustc_hash::{FxHashMap, FxHashSet};
@@ -28,9 +28,11 @@ pub(crate) fn load_cargo(
     with_proc_macro: bool,
 ) -> Result<(AnalysisHost, FxHashMap<SourceRootId, PackageRoot>)> {
     let root = std::env::current_dir()?.join(root);
-    let ws = ProjectWorkspace::discover(
-        root.as_ref(),
+    let root = ProjectRoot::discover_single(&root)?;
+    let ws = ProjectWorkspace::load(
+        root,
         &CargoConfig { load_out_dirs_from_check, ..Default::default() },
+        true,
     )?;
 
     let mut extern_dirs = FxHashSet::default();
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 8d1429196..fc4c77f8a 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -15,6 +15,7 @@ use std::{
 };
 
 use crossbeam_channel::{never, select, unbounded, RecvError, Sender};
+use itertools::Itertools;
 use lsp_server::{Connection, ErrorCode, Message, Notification, Request, RequestId, Response};
 use lsp_types::{
     NumberOrString, WorkDoneProgress, WorkDoneProgressBegin, WorkDoneProgressCreateParams,
@@ -88,37 +89,46 @@ pub fn main_loop(ws_roots: Vec<PathBuf>, config: Config, connection: Connection)
 
     let mut loop_state = LoopState::default();
     let mut world_state = {
-        // FIXME: support dynamic workspace loading.
         let workspaces = {
-            let mut loaded_workspaces = Vec::new();
-            for ws_root in &ws_roots {
-                let workspace = ra_project_model::ProjectWorkspace::discover_with_sysroot(
-                    ws_root.as_path(),
-                    config.with_sysroot,
-                    &config.cargo,
-                );
-                match workspace {
-                    Ok(workspace) => loaded_workspaces.push(workspace),
-                    Err(e) => {
-                        log::error!("loading workspace failed: {:?}", e);
-
-                        if let Some(ra_project_model::CargoTomlNotFoundError { .. }) =
-                            e.downcast_ref()
-                        {
-                            if !config.notifications.cargo_toml_not_found {
-                                continue;
-                            }
-                        }
+            // FIXME: support dynamic workspace loading.
+            let mut visited = FxHashSet::default();
+            let project_roots = ws_roots
+                .iter()
+                .filter_map(|it| ra_project_model::ProjectRoot::discover(it).ok())
+                .flatten()
+                .filter(|it| visited.insert(it.clone()))
+                .collect::<Vec<_>>();
+
+            if project_roots.is_empty() && config.notifications.cargo_toml_not_found {
+                show_message(
+                        req::MessageType::Error,
+                        format!(
+                            "rust-analyzer failed to discover workspace, no Cargo.toml found, dirs searched: {}",
+                            ws_roots.iter().format_with(", ", |it, f| f(&it.display()))
+                        ),
+                        &connection.sender,
+                    );
+            };
 
+            project_roots
+                .into_iter()
+                .filter_map(|root| {
+                    ra_project_model::ProjectWorkspace::load(
+                        root,
+                        &config.cargo,
+                        config.with_sysroot,
+                    )
+                    .map_err(|err| {
+                        log::error!("failed to load workspace: {:#}", err);
                         show_message(
                             req::MessageType::Error,
-                            format!("rust-analyzer failed to load workspace: {:?}", e),
+                            format!("rust-analyzer failed to load workspace: {:#}", err),
                             &connection.sender,
                         );
-                    }
-                }
-            }
-            loaded_workspaces
+                    })
+                    .ok()
+                })
+                .collect::<Vec<_>>()
         };
 
         let globs = config