Call Hierarchy Support

crates/server/src/caps.rs

@@ -1,7 +1,7 @@
 use lsp_types::{
-    ClientCapabilities, CompletionOptions, DeclarationCapability, OneOf, ReferencesOptions,
-    ServerCapabilities, TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions,
-    WorkDoneProgressOptions,
+    CallHierarchyServerCapability, ClientCapabilities, CompletionOptions, DeclarationCapability,
+    OneOf, ReferencesOptions, ServerCapabilities, TextDocumentSyncCapability, TextDocumentSyncKind,
+    TextDocumentSyncOptions, WorkDoneProgressOptions,
 };
 
 /// The capabilities provided by the client (editor)
@@ -29,6 +29,7 @@ pub fn new(client_caps: ClientCapabilities) -> ServerCapabilities {
         definition_provider: Some(OneOf::Left(true)),
         references_provider: Some(OneOf::Left(true)),
         rename_provider: Some(OneOf::Left(true)),
+        call_hierarchy_provider: Some(CallHierarchyServerCapability::Simple(true)),
         hover_provider: None,
         signature_help_provider: None,
         type_definition_provider: None,
@@ -48,7 +49,6 @@ pub fn new(client_caps: ClientCapabilities) -> ServerCapabilities {
         color_provider: None,
         execute_command_provider: None,
         workspace: None,
-        call_hierarchy_provider: None,
         semantic_tokens_provider: None,
         moniker_provider: None,
         experimental: None,

crates/server/src/handler/call_hierarchy.rs

@@ -0,0 +1,42 @@
+use log::debug;
+use lsp_server::{RequestId, Response};
+use lsp_types::CallHierarchyPrepareParams;
+
+use crate::global_state::GlobalState;
+
+pub fn call_hierarchy(
+    id: RequestId,
+    params: CallHierarchyPrepareParams,
+    global_state: GlobalState,
+) -> Response {
+    debug!("got call hierarchy prepear request #{}: {:#?}", id, params);
+    unimplemented!();
+
+    // let properties = global_state
+    //     .sources
+    //     .get(&params.text_document_position_params.text_document.uri)
+    //     .unwrap();
+    // let tree = &properties.ast;
+    // let scopes = &properties.ordered_scopes;
+    // let source_code = &properties.source_code;
+
+    // let node_position = params.text_document_position_params.position;
+    // let point = tree_sitter::Point::new(
+    //     node_position.line.try_into().unwrap(),
+    //     node_position.character.try_into().unwrap(),
+    // );
+
+    // // Find that node
+    // let root_node = tree.root_node();
+    // let tree_cursor = root_node.walk();
+
+    // Only can go to current files
+    // let call_hierarchy_items: Vec<CallHierarchyItem> = vec![];
+
+    // let result = serde_json::to_value(&call_hierarchy_items).unwrap();
+    // lsp_server::Response {
+    //     id,
+    //     result: Some(result),
+    //     error: None,
+    // }
+}

crates/server/src/handler/mod.rs

@@ -1,3 +1,4 @@
+mod call_hierarchy;
 mod completion;
 mod did_change;
 mod did_close;
@@ -7,6 +8,7 @@ mod publish_diagnostics;
 mod references;
 mod rename;
 
+pub use self::call_hierarchy::call_hierarchy;
 pub use self::completion::completion;
 pub use self::did_change::did_change;
 pub use self::did_close::did_close;

crates/server/src/main_loop.rs

@@ -88,6 +88,24 @@ pub fn main_loop(
                             Err(req) => req,
                         };
                     }
+                    lsp_types::request::CallHierarchyPrepare::METHOD => {
+                        let res: Result<
+                            (RequestId, lsp_types::CallHierarchyPrepareParams),
+                            lsp_server::Request,
+                        > = req.extract(lsp_types::request::Rename::METHOD);
+                        match res {
+                            Ok((id, params)) => {
+                                let resp = handler::call_hierarchy(
+                                    id,
+                                    params,
+                                    global_state.get_snapshot(),
+                                );
+                                connection.sender.send(Message::Response(resp))?;
+                                continue;
+                            }
+                            Err(req) => req,
+                        };
+                    }
                     _ => {
                         warn!("unhandled request: {:#?}", req);
                     }