improved heuristic to find project root

We're now trying to look at a few directories, instead of just the git
root.

Fixes #49

Author: Leandros

src/bacon.rs

@@ -344,11 +344,13 @@ impl Bacon {
                     .to_file_path()
                     .expect("the workspace folder sent by the editor is not a file path");
                 if let Some(git_root) = BaconLs::find_git_root_directory(&folder_path).await {
-                    tracing::debug!(
-                        "found git root directory {}, using it for files base path",
-                        git_root.display()
-                    );
-                    folder_path = Cow::Owned(git_root);
+                    if git_root.join("Cargo.toml").exists() {
+                        tracing::debug!(
+                            "found git root directory {}, using it for files base path",
+                            git_root.display()
+                        );
+                        folder_path = Cow::Owned(git_root);
+                    }
                 }
                 let mut bacon_locations = Vec::new();
                 if let Err(e) = Bacon::find_bacon_locations(&folder_path, locations_file_name, &mut bacon_locations) {
@@ -437,10 +439,11 @@ impl Bacon {
         tracing::info!("starting background task in charge of syncronizing diagnostics for all open files");
         let (tx, rx) = flume::unbounded::<DebounceEventResult>();
 
-        let (locations_file, wait_time, cancel_token) = {
+        let (locations_file, proj_root, wait_time, cancel_token) = {
             let state = state.read().await;
             (
                 state.locations_file.clone(),
+                state.project_root.clone(),
                 state.syncronize_all_open_files_wait_millis,
                 state.cancel_token.clone(),
             )
@@ -452,12 +455,20 @@ impl Bacon {
         })
         .expect("failed to create file watcher");
 
+        let locations_file_path =
+            proj_root.map_or_else(|| PathBuf::from(&locations_file), |root| root.join(&locations_file));
         loop {
-            match watcher.watch(PathBuf::from(&locations_file), notify::RecursiveMode::Recursive) {
-                Ok(_) => break,
+            match watcher.watch(PathBuf::from(&locations_file_path), notify::RecursiveMode::Recursive) {
+                Ok(_) => {
+                    tracing::info!("watching '{}' for changes...", locations_file_path.display());
+                    break;
+                }
                 Err(e) => {
-                    tracing::info!("unable to start .bacon_locations file watcher, retrying in 1 second");
-                    tracing::debug!(".bacon_locations watcher: {e}");
+                    tracing::warn!(
+                        "unable to watch '{}', retrying in 1 second",
+                        locations_file_path.display()
+                    );
+                    tracing::error!(".bacon_locations watcher error: {e}");
                     tokio::time::sleep(Duration::from_secs(1)).await;
                 }
             }
@@ -485,7 +496,6 @@ impl Bacon {
 
             let loop_state = state.read().await;
             let open_files = loop_state.open_files.clone();
-            let locations_file = loop_state.locations_file.clone();
             let workspace_folders = loop_state.workspace_folders.clone();
             drop(loop_state);
             tracing::debug!(

src/lib.rs

@@ -48,6 +48,7 @@ enum Backend {
 
 #[derive(Debug)]
 struct State {
+    project_root: Option<PathBuf>,
     workspace_folders: Option<Vec<WorkspaceFolder>>,
     locations_file: String,
     update_on_save: bool,
@@ -75,6 +76,7 @@ struct State {
 impl Default for State {
     fn default() -> Self {
         Self {
+            project_root: None,
             workspace_folders: None,
             locations_file: LOCATIONS_FILE.to_string(),
             update_on_save: true,

src/lsp.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, env, path::PathBuf, time::Duration};
+use std::{collections::HashMap, env, time::Duration};
 
 use tokio::{fs, time::Instant};
 use tower_lsp_server::{
@@ -19,6 +19,8 @@ impl LanguageServer for BaconLs {
     async fn initialize(&self, params: InitializeParams) -> jsonrpc::Result<InitializeResult> {
         tracing::info!("initializing {PKG_NAME} v{PKG_VERSION}",);
         tracing::debug!("initializing with input parameters: {params:#?}");
+        let project_root = Cargo::find_project_root(&params).await;
+        tracing::debug!("Found project root: {project_root:?}");
 
         if let Some(TextDocumentClientCapabilities {
             publish_diagnostics: Some(PublishDiagnosticsClientCapabilities { .. }),
@@ -48,6 +50,7 @@ impl LanguageServer for BaconLs {
         }
 
         let mut state = self.state.write().await;
+        state.project_root = project_root;
         state.workspace_folders = params.workspace_folders;
         state.diagnostics_data_supported = diagnostics_data_supported;
 
@@ -145,30 +148,8 @@ impl LanguageServer for BaconLs {
             state.update_on_save = true;
             state.update_on_save_wait_millis = Duration::ZERO;
             if !state.update_on_change {
-                if let Some(git_root) = Cargo::find_git_root_directory().await {
-                    // We only chose the git root as our workspace root if a
-                    // `Cargo.toml` actually exists in the git root.
-                    if git_root.join("Cargo.toml").exists() {
-                        state.build_folder = git_root;
-                    } else {
-                        #[allow(deprecated)]
-                        if let Some(root_path) = params.root_path {
-                            state.build_folder = PathBuf::from(root_path);
-                        } else if let Some(root_uri) = params.root_uri {
-                            state.build_folder = PathBuf::from(root_uri.path().as_str());
-                        } else if let Some(workspace_folders) = &state.workspace_folders {
-                            if let Some(first) = workspace_folders.get(0) {
-                                state.build_folder = PathBuf::from(first.uri.path().as_str());
-                            } else {
-                                // This duplication can be avoided when let chains are finally
-                                // stabilized.
-                                state.build_folder = git_root;
-                            }
-                        } else {
-                            // We know this is broken, but it's our best guess.
-                            state.build_folder = git_root;
-                        }
-                    }
+                if let Some(root) = &state.project_root {
+                    state.build_folder = root.clone();
                 }
             }
         }
@@ -198,6 +179,7 @@ impl LanguageServer for BaconLs {
 
     async fn initialized(&self, _: InitializedParams) {
         let state = self.state.read().await;
+        let proj_root = state.project_root.clone();
         let run_bacon = state.run_bacon_in_background;
         let bacon_command_args = state.run_bacon_in_background_command_args.clone();
         let create_bacon_prefs = state.create_bacon_preferences_file;
@@ -253,7 +235,15 @@ impl LanguageServer for BaconLs {
                 let mut current_dir = None;
                 if let Ok(cwd) = env::current_dir() {
                     current_dir = Self::find_git_root_directory(&cwd).await;
+                    if let Some(dir) = &current_dir {
+                        if !dir.join("Cargo.toml").exists() {
+                            current_dir = proj_root;
+                        }
+                    } else {
+                        current_dir = proj_root;
+                    }
                 }
+
                 match Bacon::run_in_background("bacon", &bacon_command_args, current_dir.as_ref(), cancel_token).await {
                     Ok(command) => {
                         tracing::info!("bacon was started successfully and is running in the background");

src/native.rs

@@ -9,7 +9,7 @@ use std::{
 
 use serde::{Deserialize, Deserializer};
 use tokio::{fs, process::Command};
-use tower_lsp_server::lsp_types::{Diagnostic, DiagnosticSeverity, Position, Range, Uri};
+use tower_lsp_server::lsp_types::{Diagnostic, DiagnosticSeverity, InitializeParams, Position, Range, Uri};
 
 use crate::{DiagnosticData, PKG_NAME};
 
@@ -210,6 +210,48 @@ impl Cargo {
         }
     }
 
+    pub(crate) async fn find_project_root(params: &InitializeParams) -> Option<PathBuf> {
+        let git_root = Self::find_git_root_directory().await?;
+
+        // We only chose the git root as our workspace root if a
+        // `Cargo.toml` actually exists in the git root.
+        if git_root.join("Cargo.toml").exists() {
+            return Some(git_root);
+        }
+
+        if let Some(workspace_folders) = &params.workspace_folders {
+            for folder in workspace_folders {
+                let root_path = PathBuf::from(folder.uri.path().as_str());
+                if root_path.join("Cargo.toml").exists() {
+                    return Some(root_path);
+                }
+            }
+        }
+
+        #[allow(deprecated)]
+        if let Some(root_uri) = &params.root_uri {
+            let root_path = PathBuf::from(root_uri.path().as_str());
+            if root_path.join("Cargo.toml").exists() {
+                return Some(root_path);
+            }
+        }
+
+        #[allow(deprecated)]
+        if let Some(root_path) = &params.root_path {
+            let root_path = PathBuf::from(root_path);
+            if root_path.join("Cargo.toml").exists() {
+                return Some(root_path);
+            }
+        }
+
+        let cwd = std::env::current_dir().ok()?;
+        if cwd.join("Cargo.toml").exists() {
+            return Some(cwd);
+        }
+
+        None
+    }
+
     pub(crate) async fn copy_source_code(destination_folder: &Path) -> Result<(), io::Error> {
         let source_repo = Self::find_git_root_directory()
             .await