add more logs, fix deadlock for neovim

Author: CppCXY

crates/emmylua_ls/src/context/workspace_manager.rs

@@ -1,5 +1,6 @@
 use std::collections::HashSet;
 use std::path::Path;
+use std::sync::atomic::AtomicBool;
 use std::{path::PathBuf, sync::Arc, time::Duration};
 
 use super::{ClientProxy, FileDiagnostic, StatusBar};
@@ -24,6 +25,8 @@ pub struct WorkspaceManager {
     pub watcher: Option<notify::RecommendedWatcher>,
     pub current_open_files: HashSet<Uri>,
     pub match_file_pattern: WorkspaceFileMatcher,
+    // 原子变量
+    pub workspace_initialized: Arc<AtomicBool>,
 }
 
 impl WorkspaceManager {
@@ -44,9 +47,20 @@ impl WorkspaceManager {
             watcher: None,
             current_open_files: HashSet::new(),
             match_file_pattern: WorkspaceFileMatcher::default(),
+            workspace_initialized: Arc::new(AtomicBool::new(false)),
         }
     }
 
+    pub fn is_workspace_initialized(&self) -> bool {
+        self.workspace_initialized
+            .load(std::sync::atomic::Ordering::SeqCst)
+    }
+
+    pub fn set_workspace_initialized(&self) {
+        self.workspace_initialized
+            .store(true, std::sync::atomic::Ordering::SeqCst);
+    }
+
     pub async fn add_update_emmyrc_task(&self, file_dir: PathBuf) {
         let mut update_token = self.update_token.lock().await;
         if let Some(token) = update_token.as_ref() {
@@ -139,6 +153,7 @@ impl WorkspaceManager {
     }
 
     pub async fn reindex_workspace(&self, delay: Duration) -> Option<()> {
+        log::info!("reindex workspace with delay: {:?}", delay);
         let mut update_token = self.update_token.lock().await;
         if let Some(token) = update_token.as_ref() {
             token.cancel();
@@ -274,6 +289,7 @@ pub fn load_emmy_config(config_root: Option<PathBuf>, client_config: ClientConfi
         emmyrc.pre_process_emmyrc(workspace_root);
     }
 
+    log::info!("loaded emmyrc complete");
     emmyrc.into()
 }
 

crates/emmylua_ls/src/handlers/configuration/mod.rs

@@ -11,17 +11,23 @@ pub async fn on_did_change_configuration(
     let pretty_json = serde_json::to_string_pretty(&params).ok()?;
     log::info!("on_did_change_configuration: {}", pretty_json);
 
-    let config_manager = context.workspace_manager.read().await;
-    if config_manager.client_config.client_id.is_vscode() {
+    let workspace_manager = context.workspace_manager.read().await;
+    if !workspace_manager.is_workspace_initialized() {
         return Some(());
     }
-    let client_id = config_manager.client_config.client_id;
-    drop(config_manager);
 
+    if workspace_manager.client_config.client_id.is_vscode() {
+        return Some(());
+    }
+    let client_id = workspace_manager.client_config.client_id;
+    drop(workspace_manager);
+
+    log::info!("change config client_id: {:?}", client_id);
     let new_client_config = get_client_config(&context, client_id).await;
     let mut config_manager = context.workspace_manager.write().await;
     config_manager.client_config = new_client_config;
 
+    log::info!("reloading workspace folders");
     config_manager.reload_workspace().await;
     Some(())
 }

crates/emmylua_ls/src/handlers/initialized/client_config/neovim_config.rs

@@ -18,9 +18,10 @@ pub async fn get_client_config_neovim(
         .await
         .workspace_folders
         .clone();
-    let main_workspace_folder = workspace_folders.get(0);
+
+    let main_workspace_folder = workspace_folders.get(0)?;
     let client = &context.client;
-    let scope_uri = main_workspace_folder.map(|p| file_path_to_uri(p).unwrap());
+    let scope_uri = file_path_to_uri(main_workspace_folder);
     let params = lsp_types::ConfigurationParams {
         items: vec![lsp_types::ConfigurationItem {
             scope_uri: scope_uri,
@@ -37,9 +38,10 @@ pub async fn get_client_config_neovim(
 
     if let Some(pretty_json) = serde_json::to_string_pretty(&configs).ok() {
         info!("load neovim client config: {}", pretty_json);
+    } else {
+        info!("not found neovim client config");
     }
 
     config.partial_emmyrcs = Some(configs);
-
     Some(())
 }

crates/emmylua_ls/src/handlers/initialized/codestyle.rs

@@ -43,6 +43,7 @@ pub fn load_editorconfig(workspace_folders: Vec<PathBuf>) -> Option<()> {
         let file_normalized = file.to_string_lossy().to_string().replace("\\", "/");
         update_code_style(&parent_dir, &file_normalized);
     }
+    log::info!("loaded editorconfig complete");
 
     Some(())
 }

crates/emmylua_ls/src/handlers/initialized/mod.rs

@@ -21,7 +21,6 @@ pub use client_config::{ClientConfig, get_client_config};
 use codestyle::load_editorconfig;
 use collect_files::collect_files;
 use emmylua_code_analysis::{EmmyLuaAnalysis, Emmyrc, uri_to_file_path};
-use log::info;
 use lsp_types::InitializeParams;
 use tokio::sync::RwLock;
 
@@ -30,21 +29,33 @@ pub async fn initialized_handler(
     params: InitializeParams,
     cmd_args: CmdArgs,
 ) -> Option<()> {
-    let client_id = get_client_id(&params.client_info);
-    let client_config = get_client_config(&context, client_id).await;
+    // init locale
+    locale::set_ls_locale(&params);
     let workspace_folders = get_workspace_folders(&params);
     let main_root: Option<&str> = match workspace_folders.first() {
         Some(path) => path.to_str(),
         None => None,
     };
-    // init locale
-    locale::set_ls_locale(&params);
 
     // init logger
     init_logger(main_root, &cmd_args);
-    info!("client_id: {:?}", client_id);
+    log::info!("main root: {:?}", main_root);
+
+    let client_id = get_client_id(&params.client_info);
+    log::info!("client_id: {:?}", client_id);
+
+    {
+        log::info!("set workspace folders: {:?}", workspace_folders);
+        let mut workspace_manager = context.workspace_manager.write().await;
+        workspace_manager.workspace_folders = workspace_folders.clone();
+        log::info!("workspace folders set");
+    }
+
+    let client_config = get_client_config(&context, client_id).await;
+    log::info!("client_config: {:?}", client_config);
+
     let params_json = serde_json::to_string_pretty(&params).unwrap();
-    info!("initialization_params: {}", params_json);
+    log::info!("initialization_params: {}", params_json);
 
     // init config
     // todo! support multi config
@@ -59,25 +70,26 @@ pub async fn initialized_handler(
     // init std lib
     init_std_lib(context.analysis.clone(), &cmd_args, emmyrc.clone()).await;
 
-    let mut workspace_manager = context.workspace_manager.write().await;
-    workspace_manager.workspace_folders = workspace_folders.clone();
-    workspace_manager.client_config = client_config.clone();
-    let (include, exclude, exclude_dir) = calculate_include_and_exclude(&emmyrc);
-    workspace_manager.match_file_pattern = WorkspaceFileMatcher::new(include, exclude, exclude_dir);
-    drop(workspace_manager);
-    // let file_diagnostic = context.file_diagnostic.clone();
-
     init_analysis(
         context.analysis.clone(),
         context.client.clone(),
         &context.status_bar,
         workspace_folders,
-        emmyrc,
+        emmyrc.clone(),
         client_id,
         context.file_diagnostic.clone(),
     )
     .await;
 
+    {
+        let mut workspace_manager = context.workspace_manager.write().await;
+        workspace_manager.client_config = client_config.clone();
+        let (include, exclude, exclude_dir) = calculate_include_and_exclude(&emmyrc);
+        workspace_manager.match_file_pattern =
+            WorkspaceFileMatcher::new(include, exclude, exclude_dir);
+        workspace_manager.set_workspace_initialized();
+        log::info!("workspace manager initialized");
+    }
     register_files_watch(context.clone(), &params.capabilities).await;
     Some(())
 }
@@ -97,7 +109,7 @@ pub async fn init_analysis(
     mut_analysis.update_config(emmyrc.clone());
 
     if let Ok(emmyrc_json) = serde_json::to_string_pretty(emmyrc.as_ref()) {
-        info!("current config : {}", emmyrc_json);
+        log::info!("current config : {}", emmyrc_json);
     }
 
     status_bar.create_progress_task(client_id, ProgressTask::LoadWorkspace);
@@ -110,17 +122,17 @@ pub async fn init_analysis(
 
     let mut workspace_folders = workspace_folders;
     for workspace_root in &workspace_folders {
-        info!("add workspace root: {:?}", workspace_root);
+        log::info!("add workspace root: {:?}", workspace_root);
         mut_analysis.add_main_workspace(workspace_root.clone());
     }
 
     for workspace_root in &emmyrc.workspace.workspace_roots {
-        info!("add workspace root: {:?}", workspace_root);
+        log::info!("add workspace root: {:?}", workspace_root);
         mut_analysis.add_main_workspace(PathBuf::from_str(workspace_root).unwrap());
     }
 
     for lib in &emmyrc.workspace.library {
-        info!("add library: {:?}", lib);
+        log::info!("add library: {:?}", lib);
         mut_analysis.add_library_workspace(PathBuf::from_str(lib).unwrap());
         workspace_folders.push(PathBuf::from_str(lib).unwrap());
     }
@@ -190,10 +202,16 @@ pub async fn init_std_lib(
     cmd_args: &CmdArgs,
     emmyrc: Arc<Emmyrc>,
 ) {
+    log::info!(
+        "initializing std lib with resources path: {:?}",
+        cmd_args.resources_path
+    );
     let mut analysis = analysis.write().await;
     if cmd_args.load_stdlib.0 {
         // double update config
         analysis.update_config(emmyrc);
         analysis.init_std_lib(cmd_args.resources_path.0.clone());
     }
+
+    log::info!("initialized std lib complete");
 }