support for call hierarchy

Close #353

Author: CppCXY

crates/emmylua_code_analysis/src/semantic/mod.rs

@@ -16,6 +16,7 @@ pub use cache::{CacheEntry, CacheKey, CacheOptions, LuaAnalysisPhase, LuaInferCa
 use emmylua_parser::{LuaCallExpr, LuaChunk, LuaExpr, LuaSyntaxNode, LuaSyntaxToken, LuaTableExpr};
 use infer::{infer_left_value_type_from_right_value, infer_multi_value_adjusted_expression_types};
 pub use infer::{infer_table_field_value_should_be, infer_table_should_be};
+use lsp_types::Uri;
 pub use member::infer_member_map;
 use member::infer_members;
 pub use member::LuaMemberInfo;
@@ -80,6 +81,11 @@ impl<'a> SemanticModel<'a> {
         self.db.get_vfs().get_document(&file_id)
     }
 
+    pub fn get_document_by_uri(&self, uri: &Uri) -> Option<LuaDocument> {
+        let file_id = self.db.get_vfs().get_file_id(&uri)?;
+        self.db.get_vfs().get_document(&file_id)
+    }
+
     pub fn get_root_by_file_id(&self, file_id: FileId) -> Option<LuaChunk> {
         Some(
             self.db

crates/emmylua_ls/src/handlers/call_hierarchy/build_call_hierarchy.rs

@@ -0,0 +1,252 @@
+use emmylua_code_analysis::{
+    DbIndex, FileId, LuaCompilation, LuaDeclId, LuaMemberId, LuaSemanticDeclId, LuaTypeOwner,
+    SemanticModel,
+};
+use emmylua_parser::{
+    LuaAst, LuaAstNode, LuaAstToken, LuaBlock, LuaGeneralToken, LuaStat, LuaTokenKind, LuaVarExpr,
+    PathTrait,
+};
+use lsp_types::{CallHierarchyIncomingCall, CallHierarchyItem, Location, SymbolKind};
+use rowan::TokenAtOffset;
+use serde::{Deserialize, Serialize};
+
+use crate::handlers::references::{search_decl_references, search_member_references};
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct CallHierarchyItemData {
+    pub semantic_decl: LuaSemanticDeclId,
+    pub file_id: FileId,
+}
+
+pub fn build_call_hierarchy_item(
+    semantic_model: &SemanticModel,
+    semantic_decl: LuaSemanticDeclId,
+) -> Option<CallHierarchyItem> {
+    let db = semantic_model.get_db();
+    let file_id = semantic_model.get_file_id();
+    let data = CallHierarchyItemData {
+        semantic_decl: semantic_decl.clone(),
+        file_id,
+    };
+    match semantic_decl {
+        LuaSemanticDeclId::LuaDecl(decl_id) => {
+            let decl = db.get_decl_index().get_decl(&decl_id)?;
+            let range = decl.get_range();
+            let file_id = decl.get_file_id();
+            let document = semantic_model.get_document_by_file_id(file_id)?;
+            let uri = document.get_uri();
+            let name = decl.get_name().to_string();
+            let lsp_range = document.to_lsp_range(range)?;
+
+            Some(CallHierarchyItem {
+                name,
+                kind: get_kind(db, decl_id.into()),
+                tags: None,
+                detail: None,
+                uri,
+                range: lsp_range,
+                selection_range: lsp_range,
+                data: Some(serde_json::to_value(data).ok()?),
+            })
+        }
+        LuaSemanticDeclId::Member(member_id) => {
+            let member = db.get_member_index().get_member(&member_id)?;
+            let range = member.get_range();
+            let file_id = member.get_file_id();
+            let document = semantic_model.get_document_by_file_id(file_id)?;
+            let uri = document.get_uri();
+            let name = member.get_key().get_name()?.to_string();
+            let lsp_range = document.to_lsp_range(range)?;
+
+            Some(CallHierarchyItem {
+                name,
+                kind: get_kind(db, member_id.into()),
+                tags: None,
+                detail: None,
+                uri,
+                range: lsp_range,
+                selection_range: lsp_range,
+                data: Some(serde_json::to_value(data).ok()?),
+            })
+        }
+        _ => None,
+    }
+}
+
+fn get_kind(db: &DbIndex, type_owner: LuaTypeOwner) -> SymbolKind {
+    let type_cache = db.get_type_index().get_type_cache(&type_owner);
+    match type_cache {
+        Some(typ) => {
+            if typ.is_function() {
+                return SymbolKind::FUNCTION;
+            } else if typ.is_ref() || typ.is_def() {
+                return SymbolKind::CLASS;
+            } else if typ.is_const() {
+                return SymbolKind::CONSTANT;
+            } else {
+                return SymbolKind::VARIABLE;
+            }
+        }
+        None => SymbolKind::VARIABLE,
+    }
+}
+
+pub fn build_incoming_hierarchy(
+    semantic_model: &SemanticModel,
+    compilation: &LuaCompilation,
+    semantic_decl: LuaSemanticDeclId,
+) -> Option<Vec<CallHierarchyIncomingCall>> {
+    let mut result = vec![];
+    let mut locations = vec![];
+    match semantic_decl {
+        LuaSemanticDeclId::LuaDecl(decl_id) => {
+            search_decl_references(semantic_model, decl_id, &mut locations);
+        }
+        LuaSemanticDeclId::Member(member_id) => {
+            search_member_references(semantic_model, compilation, member_id, &mut locations);
+        }
+        _ => return None,
+    }
+
+    for location in locations {
+        build_incoming_hierarchy_item(compilation, &location, &mut result);
+    }
+
+    Some(result)
+}
+
+fn build_incoming_hierarchy_item(
+    compilation: &LuaCompilation,
+    location: &Location,
+    result: &mut Vec<CallHierarchyIncomingCall>,
+) -> Option<()> {
+    let db = compilation.get_db();
+    let uri = location.uri.clone();
+    let range = location.range;
+    let file_id = db.get_vfs().get_file_id(&uri)?;
+    let tree = db.get_vfs().get_syntax_tree(&file_id)?;
+    let root_chunk = tree.get_chunk_node();
+    let document = db.get_vfs().get_document(&file_id)?;
+    let pos = document.get_offset(range.start.line as usize, range.start.character as usize)?;
+    let token = match root_chunk.syntax().token_at_offset(pos) {
+        TokenAtOffset::Single(token) => token,
+        TokenAtOffset::Between(left, right) => {
+            if left.kind() == LuaTokenKind::TkName.into() {
+                left
+            } else {
+                right
+            }
+        }
+        TokenAtOffset::None => {
+            return None;
+        }
+    };
+
+    let general_token = LuaGeneralToken::cast(token)?;
+    let blocks = general_token.ancestors::<LuaBlock>();
+    for block in blocks {
+        let block_parent = block.get_parent::<LuaAst>()?;
+        match block_parent {
+            LuaAst::LuaChunk(_) => {
+                let item = CallHierarchyItem {
+                    name: document.get_file_name()?,
+                    kind: SymbolKind::MODULE,
+                    tags: None,
+                    detail: None,
+                    uri: uri.clone(),
+                    range: document.get_document_lsp_range(),
+                    selection_range: document.get_document_lsp_range(),
+                    data: None,
+                };
+
+                result.push(CallHierarchyIncomingCall {
+                    from: item,
+                    from_ranges: vec![range],
+                });
+            }
+            LuaAst::LuaClosureExpr(closure) => {
+                let closure_parent = match closure.get_parent::<LuaStat>() {
+                    Some(stat) => stat,
+                    None => continue,
+                };
+
+                match closure_parent {
+                    LuaStat::FuncStat(func_stat) => {
+                        let func_name = func_stat.get_func_name()?;
+                        let name_lsp_range = document.to_lsp_range(func_name.get_range())?;
+                        let access_path = func_name.get_access_path()?;
+                        let semantic_decl = match func_name {
+                            LuaVarExpr::IndexExpr(index_expr) => LuaSemanticDeclId::Member(
+                                LuaMemberId::new(index_expr.get_syntax_id(), file_id),
+                            ),
+                            LuaVarExpr::NameExpr(name_expr) => LuaSemanticDeclId::LuaDecl(
+                                LuaDeclId::new(file_id, name_expr.get_position()),
+                            ),
+                        };
+
+                        let item = CallHierarchyItem {
+                            name: access_path,
+                            kind: SymbolKind::FUNCTION,
+                            tags: None,
+                            detail: None,
+                            uri: uri.clone(),
+                            range: name_lsp_range,
+                            selection_range: name_lsp_range,
+                            data: Some(
+                                serde_json::to_value(CallHierarchyItemData {
+                                    semantic_decl,
+                                    file_id,
+                                })
+                                .ok()?,
+                            ),
+                        };
+
+                        result.push(CallHierarchyIncomingCall {
+                            from: item,
+                            from_ranges: vec![range],
+                        });
+                    }
+                    LuaStat::LocalFuncStat(local_func_stat) => {
+                        let func_name = local_func_stat.get_local_name()?;
+                        let name_lsp_range = document.to_lsp_range(func_name.get_range())?;
+                        let name = func_name.get_name_token()?.get_text().to_string();
+                        let semantic_decl = LuaSemanticDeclId::LuaDecl(LuaDeclId::new(
+                            file_id,
+                            func_name.get_position(),
+                        ));
+
+                        let item = CallHierarchyItem {
+                            name,
+                            kind: SymbolKind::FUNCTION,
+                            tags: None,
+                            detail: None,
+                            uri: uri.clone(),
+                            range: name_lsp_range,
+                            selection_range: name_lsp_range,
+                            data: Some(
+                                serde_json::to_value(CallHierarchyItemData {
+                                    semantic_decl,
+                                    file_id,
+                                })
+                                .ok()?,
+                            ),
+                        };
+
+                        result.push(CallHierarchyIncomingCall {
+                            from: item,
+                            from_ranges: vec![range],
+                        });
+                    }
+                    _ => continue,
+                }
+
+                break;
+            }
+            _ => {
+                return None;
+            }
+        }
+    }
+
+    Some(())
+}

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

@@ -0,0 +1,92 @@
+mod build_call_hierarchy;
+
+use build_call_hierarchy::{
+    build_call_hierarchy_item, build_incoming_hierarchy, CallHierarchyItemData,
+};
+use emmylua_code_analysis::SemanticDeclLevel;
+use emmylua_parser::{LuaAstNode, LuaTokenKind};
+use lsp_types::{
+    CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem,
+    CallHierarchyOutgoingCall, CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams,
+    ClientCapabilities, ServerCapabilities,
+};
+use rowan::TokenAtOffset;
+use tokio_util::sync::CancellationToken;
+
+use crate::context::ServerContextSnapshot;
+
+use super::RegisterCapabilities;
+
+pub async fn on_prepare_call_hierarchy_handler(
+    context: ServerContextSnapshot,
+    params: CallHierarchyPrepareParams,
+    _: CancellationToken,
+) -> Option<Vec<CallHierarchyItem>> {
+    let uri = params.text_document_position_params.text_document.uri;
+    let analysis = context.analysis.read().await;
+    let file_id = analysis.get_file_id(&uri)?;
+    let position = params.text_document_position_params.position;
+    let semantic_model = analysis.compilation.get_semantic_model(file_id)?;
+    let root = semantic_model.get_root();
+    let position_offset = {
+        let document = semantic_model.get_document();
+        document.get_offset(position.line as usize, position.character as usize)?
+    };
+
+    if position_offset > root.syntax().text_range().end() {
+        return None;
+    }
+
+    let token = match root.syntax().token_at_offset(position_offset) {
+        TokenAtOffset::Single(token) => token,
+        TokenAtOffset::Between(left, right) => {
+            if left.kind() == LuaTokenKind::TkName.into() {
+                left
+            } else {
+                right
+            }
+        }
+        TokenAtOffset::None => {
+            return None;
+        }
+    };
+
+    let semantic_decl =
+        semantic_model.find_decl(token.clone().into(), SemanticDeclLevel::default())?;
+
+    Some(vec![build_call_hierarchy_item(
+        &semantic_model,
+        semantic_decl,
+    )?])
+}
+
+pub async fn on_incoming_calls_handler(
+    context: ServerContextSnapshot,
+    params: CallHierarchyIncomingCallsParams,
+    _: CancellationToken,
+) -> Option<Vec<CallHierarchyIncomingCall>> {
+    let item = params.item;
+    let data = item.data.as_ref()?;
+    let data = serde_json::from_value::<CallHierarchyItemData>(data.clone()).ok()?;
+    let analysis = context.analysis.read().await;
+    let semantic_model = analysis.compilation.get_semantic_model(data.file_id)?;
+    let semantic_decl_id = data.semantic_decl;
+
+    build_incoming_hierarchy(&semantic_model, &analysis.compilation, semantic_decl_id)
+}
+
+pub async fn on_outgoing_calls_handler(
+    _: ServerContextSnapshot,
+    _: CallHierarchyOutgoingCallsParams,
+    _: CancellationToken,
+) -> Option<Vec<CallHierarchyOutgoingCall>> {
+    None
+}
+
+pub struct CallHierarchyCapabilities;
+
+impl RegisterCapabilities for CallHierarchyCapabilities {
+    fn register_capabilities(server_capabilities: &mut ServerCapabilities, _: &ClientCapabilities) {
+        server_capabilities.call_hierarchy_provider = Some(true.into());
+    }
+}

crates/emmylua_ls/src/handlers/mod.rs

@@ -1,3 +1,4 @@
+mod call_hierarchy;
 mod code_actions;
 mod code_lens;
 mod command;
@@ -116,6 +117,10 @@ pub fn server_capabilities(client_capabilities: &ClientCapabilities) -> ServerCa
         &mut server_capabilities,
         client_capabilities,
     );
+    register::<call_hierarchy::CallHierarchyCapabilities>(
+        &mut server_capabilities,
+        client_capabilities,
+    );
 
     server_capabilities
 }