[IMP] Workspace Symbol request and $/Cancel support

Author: fda-odoo

server/src/core/odoo.rs

@@ -5,6 +5,7 @@ use crate::core::xml_data::OdooData;
 use crate::core::xml_validation::XmlValidator;
 use crate::features::document_symbols::DocumentSymbolFeature;
 use crate::features::references::ReferenceFeature;
+use crate::features::workspace_symbols::WorkspaceSymbolFeature;
 use crate::threads::SessionInfo;
 use crate::features::completion::CompletionFeature;
 use crate::features::definition::DefinitionFeature;
@@ -14,9 +15,9 @@ use std::cell::RefCell;
 use std::ffi::OsStr;
 use std::rc::{Rc, Weak};
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use std::time::Instant;
-use lsp_server::ResponseError;
+use lsp_server::{RequestId, ResponseError};
 use lsp_types::*;
 use request::{RegisterCapability, Request, WorkspaceConfiguration};
 use serde_json::Value;
@@ -78,6 +79,8 @@ pub struct SyncOdoo {
     pub models: HashMap<OYarn, Rc<RefCell<Model>>>,
     pub interrupt_rebuild: Arc<AtomicBool>,
     pub terminate_rebuild: Arc<AtomicBool>,
+    pub current_request_id: Option<RequestId>,
+    pub running_request_ids: Arc<Mutex<Vec<RequestId>>>, //Arc to Server mutex for cancellation support
     pub watched_file_updates: u32,
     rebuild_arch: PtrWeakHashSet<Weak<RefCell<Symbol>>>,
     rebuild_arch_eval: PtrWeakHashSet<Weak<RefCell<Symbol>>>,
@@ -117,6 +120,8 @@ impl SyncOdoo {
             models: HashMap::new(),
             interrupt_rebuild: Arc::new(AtomicBool::new(false)),
             terminate_rebuild: Arc::new(AtomicBool::new(false)),
+            current_request_id: None,
+            running_request_ids: Arc::new(Mutex::new(vec![])),
             watched_file_updates: 0,
             rebuild_arch: PtrWeakHashSet::new(),
             rebuild_arch_eval: PtrWeakHashSet::new(),
@@ -842,6 +847,13 @@ impl SyncOdoo {
         false
     }
 
+    pub fn is_request_cancelled(&self) -> bool {
+        if let Some(request_id) = self.current_request_id.as_ref() {
+            return !self.running_request_ids.lock().unwrap().contains(request_id);
+        }
+        false
+    }
+
     pub fn get_file_mgr(&self) -> Rc<RefCell<FileMgr>> {
         self.file_mgr.clone()
     }
@@ -1629,6 +1641,21 @@ impl Odoo {
         }
         Ok(None)
     }
+
+    pub fn handle_workspace_symbols(session: &mut SessionInfo<'_>, params: WorkspaceSymbolParams) -> Result<Option<WorkspaceSymbolResponse>, ResponseError> {
+        session.log_message(MessageType::INFO, format!("Workspace Symbol requested with query {}",
+            params.query,
+        ));
+        WorkspaceSymbolFeature::get_workspace_symbols(session, params.query)
+    }
+
+    pub fn handle_workspace_symbols_resolve(session: &mut SessionInfo<'_>, symbol: WorkspaceSymbol) -> Result<WorkspaceSymbol, ResponseError> {
+        session.log_message(MessageType::INFO, format!("Workspace Symbol Resolve for symbol {}",
+            symbol.name,
+        ));
+        WorkspaceSymbolFeature::resolve_workspace_symbol(session, &symbol)
+    }
+
     /// Checks if the given path is a configuration file under one of the workspace folders.
     fn is_config_workspace_file(session: &mut SessionInfo, path: &PathBuf) -> bool {
         for (_, ws_dir) in session.sync_odoo.get_file_mgr().borrow().get_workspace_folders().iter() {

server/src/core/symbols/symbol.rs

@@ -22,7 +22,7 @@ use std::path::PathBuf;
 use std::rc::{Rc, Weak};
 use std::cell::RefCell;
 use std::vec;
-use lsp_types::{Diagnostic, DiagnosticTag, Position, Range};
+use lsp_types::{Diagnostic, DiagnosticTag, Position, Range, SymbolKind};
 
 use crate::core::symbols::function_symbol::FunctionSymbol;
 use crate::core::symbols::module_symbol::ModuleSymbol;
@@ -2354,7 +2354,12 @@ impl Symbol {
                 for symbol in root.module_symbols.values().cloned() {
                     iter.push(symbol.clone());
                 }
-            }
+            },
+            Symbol::DiskDir(d) => {
+                for symbol in d.module_symbols.values().cloned() {
+                    iter.push(symbol.clone());
+                }
+            },
             _ => {}
         }
         iter.into_iter()
@@ -3050,6 +3055,19 @@ impl Symbol {
         return -1;
     }
 
+    pub fn get_lsp_symbol_kind(&self) -> SymbolKind {
+        match self.typ() {
+            SymType::CLASS => SymbolKind::CLASS,
+            SymType::FUNCTION => SymbolKind::FUNCTION,
+            SymType::VARIABLE => SymbolKind::VARIABLE,
+            SymType::FILE | SymType::CSV_FILE | SymType::XML_FILE => SymbolKind::FILE,
+            SymType::PACKAGE(_) => SymbolKind::PACKAGE,
+            SymType::NAMESPACE => SymbolKind::NAMESPACE,
+            SymType::DISK_DIR | SymType::COMPILED => SymbolKind::FILE,
+            SymType::ROOT => SymbolKind::NAMESPACE
+        }
+    }
+
     /*fn _debug_print_graph_node(&self, acc: &mut String, level: u32) {
         for _ in 0..level {
             acc.push_str(" ");

server/src/features/mod.rs

@@ -6,4 +6,5 @@ pub mod features_utils;
 pub mod hover;
 pub mod node_index_ast;
 pub mod references;
+pub mod workspace_symbols;
 pub mod xml_ast_utils;

server/src/features/workspace_symbols.rs

@@ -0,0 +1,140 @@
+use std::{cell::RefCell, rc::Rc};
+
+use lsp_server::ResponseError;
+use lsp_types::{Location, WorkspaceLocation, WorkspaceSymbol, WorkspaceSymbolResponse};
+use ruff_text_size::{TextRange, TextSize};
+
+use crate::{S, constants::SymType, core::{entry_point::EntryPointType, file_mgr::FileMgr, symbols::symbol::Symbol}, threads::SessionInfo};
+
+pub struct WorkspaceSymbolFeature;
+
+impl WorkspaceSymbolFeature {
+
+    pub fn get_workspace_symbols(session: &mut SessionInfo<'_>, query: String) -> Result<Option<WorkspaceSymbolResponse>, ResponseError> {
+        if query.is_empty() { //It would lead to too much results, let's cancel it
+            return Ok(None);
+        }
+        let mut symbols = vec![];
+        let ep_mgr = session.sync_odoo.entry_point_mgr.clone();
+        let mut can_resolve_location_range = false;
+        if let Some(cap_workspace) = session.sync_odoo.capabilities.workspace.as_ref() {
+            if let Some(workspace_symb) = cap_workspace.symbol.as_ref() {
+                if let Some(resolve_support) = workspace_symb.resolve_support.as_ref() {
+                    for resolvable_property in &resolve_support.properties {
+                        if resolvable_property == "location.range" {
+                            can_resolve_location_range = true;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        for entry in ep_mgr.borrow().iter_all() {
+            if entry.borrow().typ == EntryPointType::BUILTIN || entry.borrow().typ == EntryPointType::PUBLIC { //We don't want to search in builtins
+                continue;
+            }
+            WorkspaceSymbolFeature::browse_symbol(session, &entry.borrow().root, &query, None, None, can_resolve_location_range, &mut symbols);
+        }
+        Ok(Some(WorkspaceSymbolResponse::Nested(symbols)))
+    }
+
+    fn browse_symbol(session: &mut SessionInfo, symbol: &Rc<RefCell<Symbol>>, query: &String, parent: Option<String>, parent_path: Option<&String>, can_resolve_location_range: bool, results: &mut Vec<WorkspaceSymbol>) {
+        let symbol_borrowed = symbol.borrow();
+        if symbol_borrowed.typ() == SymType::VARIABLE {
+            return;
+        }
+        if symbol_borrowed.typ() == SymType::FILE { //to avoid too many locks
+            if session.sync_odoo.is_request_cancelled() {
+                return;
+            }
+        }
+        let container_name = match &parent {
+            Some(p) => Some(p.clone()),
+            None => None,
+        };
+        let path = symbol_borrowed.paths();
+        let path = if path.len() == 1 {
+            Some(&path[0])
+        } else if path.len() == 0{
+            parent_path
+        } else {
+            None
+        };
+        if path.is_some() {
+            let file_info = session.sync_odoo.get_file_mgr().borrow().get_file_info(path.unwrap());
+            if let Some(file_info) = file_info {
+                if symbol_borrowed.has_range() {
+                    let location = if can_resolve_location_range {
+                        lsp_types::OneOf::Right(WorkspaceLocation {
+                            uri: FileMgr::pathname2uri(path.unwrap())
+                        })
+                    } else {
+                        lsp_types::OneOf::Left(Location::new(
+                            FileMgr::pathname2uri(path.unwrap()),
+                            file_info.borrow().text_range_to_range(symbol_borrowed.range())
+                        ))
+                    };
+                    let data = if can_resolve_location_range {
+                        Some(lsp_types::LSPAny::Array(vec![
+                            lsp_types::LSPAny::Number(serde_json::Number::from(symbol_borrowed.range().start().to_u32())),
+                            lsp_types::LSPAny::Number(serde_json::Number::from(symbol_borrowed.range().end().to_u32())),
+                        ]))
+                    } else {
+                        None
+                    };
+                    results.push(WorkspaceSymbol {
+                        name: symbol_borrowed.name().to_string(),
+                        kind: symbol_borrowed.get_lsp_symbol_kind(),
+                        tags: None,
+                        container_name,
+                        location: location,
+                        data: data,
+                    });
+                }
+            }
+        }
+        for sym in symbol_borrowed.all_symbols() {
+            WorkspaceSymbolFeature::browse_symbol(session, &sym, query, Some(symbol_borrowed.name().to_string()), path, can_resolve_location_range, results);
+        }
+    }
+
+    pub fn resolve_workspace_symbol(session: &mut SessionInfo<'_>, symbol: &WorkspaceSymbol) -> Result<WorkspaceSymbol, ResponseError> {
+        let mut resolved_symbol = symbol.clone();
+        let location = match &symbol.location {
+            lsp_types::OneOf::Left(_) => None,
+            lsp_types::OneOf::Right(wl) => Some(wl.clone()),
+        };
+        if let Some(location) = location {
+            let uri = FileMgr::uri2pathname(location.uri.as_str());
+            let file_info = session.sync_odoo.get_file_mgr().borrow().get_file_info(&uri);
+            if let Some(file_info) = file_info {
+                if let Some(data) = symbol.data.as_ref() {
+                    if data.is_array() {
+                        let arr = data.as_array().unwrap();
+                        if arr.len() == 2 {
+                            let start_u32 = arr[0].as_u64().unwrap() as u32;
+                            let end_u32 = arr[1].as_u64().unwrap() as u32;
+                            let range = file_info.borrow().text_range_to_range(&TextRange::new(TextSize::new(start_u32), TextSize::new(end_u32)));
+                            resolved_symbol.location = lsp_types::OneOf::Left(Location::new(
+                                location.uri.clone(),
+                                range,
+                            ));
+                            return Ok(resolved_symbol)
+                        } else {
+                            return Err(ResponseError { code: 1, message: S!("Unable to resolve Workspace Symbol - Invalid data to resolve range"), data: None })
+                        }
+                    } else {
+                        return Err(ResponseError { code: 1, message: S!("Unable to resolve Workspace Symbol - Invalid data to resolve range"), data: None })
+                    }
+                } else {
+                    return Err(ResponseError { code: 1, message: S!("Unable to resolve Workspace Symbol - No data to resolve range"), data: None })
+                }
+            } else {
+                return Err(ResponseError { code: 1, message: S!("Unable to resolve Workspace Symbol - No file info"), data: None })
+            }
+        } else {
+            return Err(ResponseError { code: 1, message: S!("Unable to resolve Workspace Symbol - no provided location to resolve"), data: None })
+        }
+    }
+
+}

server/src/server.rs

@@ -1,9 +1,8 @@
-use std::{io::Error, panic, sync::{atomic::AtomicBool, Arc, Mutex}, thread::JoinHandle};
+use std::{io::Error, panic, sync::{self, Arc, Mutex, atomic::AtomicBool}, thread::JoinHandle};
 
 use crossbeam_channel::{Receiver, Select, Sender};
 use lsp_server::{Connection, IoThreads, Message, ProtocolError, RequestId, ResponseError};
-use lsp_types::{notification::{DidChangeConfiguration, DidChangeTextDocument, DidChangeWatchedFiles, DidChangeWorkspaceFolders, DidCloseTextDocument,
-    DidCreateFiles, DidDeleteFiles, DidOpenTextDocument, DidRenameFiles, DidSaveTextDocument, Notification}, request::{Completion, DocumentSymbolRequest, GotoDefinition, HoverRequest, References, Request, ResolveCompletionItem, Shutdown}, CompletionOptions, DefinitionOptions, DocumentSymbolOptions, FileOperationFilter, FileOperationPattern, FileOperationRegistrationOptions, HoverProviderCapability, InitializeParams, InitializeResult, OneOf, ReferencesOptions, SaveOptions, ServerCapabilities, ServerInfo, TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions, WorkDoneProgressOptions, WorkspaceFileOperationsServerCapabilities, WorkspaceFoldersServerCapabilities, WorkspaceServerCapabilities};
+use lsp_types::{CancelParams, CompletionOptions, DefinitionOptions, DocumentSymbolOptions, FileOperationFilter, FileOperationPattern, FileOperationRegistrationOptions, HoverProviderCapability, InitializeParams, InitializeResult, OneOf, ReferencesOptions, SaveOptions, ServerCapabilities, ServerInfo, TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions, WorkDoneProgressOptions, WorkspaceFileOperationsServerCapabilities, WorkspaceFoldersServerCapabilities, WorkspaceServerCapabilities, WorkspaceSymbolOptions, notification::{Cancel, DidChangeConfiguration, DidChangeTextDocument, DidChangeWatchedFiles, DidChangeWorkspaceFolders, DidCloseTextDocument, DidCreateFiles, DidDeleteFiles, DidOpenTextDocument, DidRenameFiles, DidSaveTextDocument, Notification}, request::{Completion, DocumentSymbolRequest, GotoDefinition, HoverRequest, References, Request, ResolveCompletionItem, Shutdown, WorkspaceSymbolRequest, WorkspaceSymbolResolve}};
 use serde_json::json;
 #[cfg(target_os = "linux")]
 use nix;
@@ -28,8 +27,9 @@ pub struct Server {
     delayed_process_thread: JoinHandle<()>,
     sender_to_delayed_process: Sender<DelayedProcessingMessage>, //unique channel to delayed process thread
     sync_odoo: Arc<Mutex<SyncOdoo>>,
-    interrupt_rebuild_boolean: Arc<AtomicBool>,
-    terminate_rebuild_boolean: Arc<AtomicBool>,
+    interrupt_rebuild_boolean: Arc<AtomicBool>, //ref to the one on sync_odoo
+    terminate_rebuild_boolean: Arc<AtomicBool>, //ref to the one on sync_odoo
+    running_request_ids: Arc<Mutex<Vec<RequestId>>>, //ref to the one on sync_odoo, but with dedicated mutex
 }
 
 #[derive(Debug)]
@@ -73,6 +73,7 @@ impl Server {
         let sync_odoo = Arc::new(Mutex::new(SyncOdoo::new()));
         let interrupt_rebuild_boolean = sync_odoo.lock().unwrap().interrupt_rebuild.clone();
         let terminate_rebuild_boolean = sync_odoo.lock().unwrap().terminate_rebuild.clone();
+        let running_request_ids = sync_odoo.lock().unwrap().running_request_ids.clone();
         let mut receivers_w_to_s = vec![];
         let (sender_to_delayed_process, receiver_delayed_process) = crossbeam_channel::unbounded();
         let (req_sender_s_to_main, generic_receiver_s_to_main) = crossbeam_channel::unbounded(); //unique channel to dispatch to any ready main thread
@@ -83,8 +84,9 @@ impl Server {
         let main_thread = {
             let sync_odoo = sync_odoo.clone();
             let sender_to_delayed_process = sender_to_delayed_process.clone();
+            let running_request_ids = running_request_ids.clone();
             std::thread::spawn(move || {
-                message_processor_thread_main(sync_odoo, generic_receiver_s_to_main, sender_main_to_s.clone(), receiver_s_to_main.clone(), sender_to_delayed_process);
+                message_processor_thread_main(sync_odoo, generic_receiver_s_to_main, sender_main_to_s.clone(), receiver_s_to_main.clone(), sender_to_delayed_process, running_request_ids);
             })
         };
 
@@ -108,7 +110,8 @@ impl Server {
             delayed_process_thread,
             sync_odoo: sync_odoo,
             interrupt_rebuild_boolean: interrupt_rebuild_boolean,
-            terminate_rebuild_boolean
+            terminate_rebuild_boolean,
+            running_request_ids: running_request_ids,
         }
     }
 
@@ -175,6 +178,12 @@ impl Server {
                         work_done_progress: Some(false)
                     },
                 })),
+                workspace_symbol_provider: Some(OneOf::Right(WorkspaceSymbolOptions {
+                    resolve_provider: Some(true),
+                    work_done_progress_options: WorkDoneProgressOptions {
+                        work_done_progress: Some(false)
+                    },
+                })),
                 workspace: Some(WorkspaceServerCapabilities {
                     workspace_folders: Some(WorkspaceFoldersServerCapabilities {
                         supported: Some(true),
@@ -310,6 +319,14 @@ impl Server {
                         }
                         self.shutdown_threads("Got a client exit notification. Exiting.");
                         break;
+                    } else if n.method == Cancel::METHOD {
+                        let cancel_params = serde_json::from_value::<CancelParams>(n.params.clone()).unwrap();
+                        let req_id: RequestId = match cancel_params.id {
+                            lsp_types::NumberOrString::Number(id) => id.into(),
+                            lsp_types::NumberOrString::String(id) => id.into(),
+                        };
+                        self.running_request_ids.lock().unwrap().retain(|id| id != &req_id);
+                        break;
                     }
                 }
                 self.forward_message(msg);
@@ -352,15 +369,10 @@ impl Server {
     fn forward_message(&mut self, msg: Message) {
         match msg {
             Message::Request(r) => {
+                self.running_request_ids.lock().unwrap().push(r.id.clone());
                 match r.method.as_str() {
-                    HoverRequest::METHOD | GotoDefinition::METHOD | References::METHOD | DocumentSymbolRequest::METHOD=> {
-                        self.interrupt_rebuild_boolean.store(true, std::sync::atomic::Ordering::SeqCst);
-                        if DEBUG_THREADS {
-                            info!("Sending request to main thread : {} - {}", r.method, r.id);
-                        }
-                        self.req_sender_s_to_main.send(Message::Request(r)).unwrap();
-                    },
-                    Completion::METHOD => {
+                    HoverRequest::METHOD | GotoDefinition::METHOD | References::METHOD | DocumentSymbolRequest::METHOD |
+                    WorkspaceSymbolRequest::METHOD | WorkspaceSymbolResolve::METHOD | Completion::METHOD => {
                         self.interrupt_rebuild_boolean.store(true, std::sync::atomic::Ordering::SeqCst);
                         if DEBUG_THREADS {
                             info!("Sending request to main thread : {} - {}", r.method, r.id);