goto_def_definition 可以跳转到实例的定义

Author: xuhuanzy

crates/emmylua_ls/src/handlers/definition/goto_def_definition.rs

@@ -1,12 +1,21 @@
 use std::str::FromStr;
 
-use emmylua_code_analysis::{LuaSemanticDeclId, LuaType, LuaTypeDeclId, SemanticModel};
-use emmylua_parser::{LuaAstNode, LuaAstToken, LuaCallExpr, LuaExpr, LuaStringToken};
+use emmylua_code_analysis::{
+    LuaDeclId, LuaMemberId, LuaMemberInfo, LuaMemberKey, LuaSemanticDeclId, LuaType, LuaTypeDeclId,
+    SemanticDeclLevel, SemanticModel,
+};
+use emmylua_parser::{
+    LuaAstNode, LuaAstToken, LuaCallExpr, LuaExpr, LuaIndexExpr, LuaStringToken, LuaSyntaxToken,
+    LuaTableExpr,
+};
 use lsp_types::{GotoDefinitionResponse, Location, Position, Range, Uri};
 
+use crate::handlers::hover::find_member_origin_owner;
+
 pub fn goto_def_definition(
     semantic_model: &SemanticModel,
     property_owner: LuaSemanticDeclId,
+    trigger_token: &LuaSyntaxToken,
 ) -> Option<GotoDefinitionResponse> {
     if let Some(property) = semantic_model
         .get_db()
@@ -31,20 +40,48 @@ pub fn goto_def_definition(
             return Some(GotoDefinitionResponse::Scalar(location));
         }
         LuaSemanticDeclId::Member(member_id) => {
-            let member = semantic_model
+            if let Some(property_owner) = find_member_origin_owner(semantic_model, member_id) {
+                return goto_def_definition(semantic_model, property_owner, trigger_token);
+            }
+
+            let member_key = semantic_model
                 .get_db()
                 .get_member_index()
-                .get_member(&member_id)?;
-            let document = semantic_model.get_document_by_file_id(member_id.file_id)?;
-            let location = document.to_lsp_location(member.get_range())?;
-            return Some(GotoDefinitionResponse::Scalar(location));
+                .get_member(&member_id)?
+                .get_key();
+
+            let mut locations: Vec<Location> = Vec::new();
+
+            // 添加原始成员的位置
+            if let Some(location) = get_member_location(semantic_model, &member_id) {
+                locations.push(location);
+            }
+
+            // 查找实体的定义, 例如在 ---@field 时声明, obj = {} 时实际定义
+            if let Some(table_field_info) =
+                find_table_member_definition(semantic_model, trigger_token, member_key)
+            {
+                if let Some(LuaSemanticDeclId::Member(table_member_id)) =
+                    table_field_info.property_owner_id
+                {
+                    if let Some(location) = get_member_location(semantic_model, &table_member_id) {
+                        if !locations.contains(&location) {
+                            locations.push(location);
+                        }
+                    }
+                }
+            }
+
+            if !locations.is_empty() {
+                return Some(GotoDefinitionResponse::Array(locations));
+            }
         }
         LuaSemanticDeclId::TypeDecl(type_decl_id) => {
             let type_decl = semantic_model
                 .get_db()
                 .get_type_index()
                 .get_type_decl(&type_decl_id)?;
-            let mut locations = Vec::new();
+            let mut locations: Vec<Location> = Vec::new();
             for lua_location in type_decl.get_locations() {
                 let document = semantic_model.get_document_by_file_id(lua_location.file_id)?;
                 let location = document.to_lsp_location(lua_location.range)?;
@@ -55,7 +92,6 @@ pub fn goto_def_definition(
         }
         _ => {}
     }
-
     None
 }
 
@@ -142,3 +178,58 @@ pub fn goto_str_tpl_ref_definition(
 
     None
 }
+
+fn find_table_member_definition(
+    semantic_model: &SemanticModel,
+    trigger_token: &LuaSyntaxToken,
+    member_key: &LuaMemberKey,
+) -> Option<LuaMemberInfo> {
+    let index_expr = trigger_token.parent().and_then(LuaIndexExpr::cast)?;
+    let prefix_expr = index_expr.get_prefix_expr()?;
+
+    let decl = semantic_model.find_decl(
+        prefix_expr.syntax().clone().into(),
+        SemanticDeclLevel::default(),
+    );
+
+    if let Some(LuaSemanticDeclId::LuaDecl(decl_id)) = decl {
+        return find_member_in_table_decl(semantic_model, &decl_id, member_key);
+    }
+
+    None
+}
+
+fn find_member_in_table_decl(
+    semantic_model: &SemanticModel,
+    decl_id: &LuaDeclId,
+    member_key: &LuaMemberKey,
+) -> Option<LuaMemberInfo> {
+    let root = semantic_model
+        .get_db()
+        .get_vfs()
+        .get_syntax_tree(&decl_id.file_id)?
+        .get_red_root();
+
+    let node = semantic_model
+        .get_db()
+        .get_decl_index()
+        .get_decl(decl_id)?
+        .get_value_syntax_id()?
+        .to_node_from_root(&root)?;
+
+    let table_expr = LuaTableExpr::cast(node)?;
+    let typ = semantic_model
+        .infer_expr(LuaExpr::TableExpr(table_expr))
+        .ok()?;
+
+    let member_infos = semantic_model.get_member_infos(&typ)?;
+    member_infos.iter().find(|m| m.key == *member_key).cloned()
+}
+
+fn get_member_location(
+    semantic_model: &SemanticModel,
+    member_id: &LuaMemberId,
+) -> Option<Location> {
+    let document = semantic_model.get_document_by_file_id(member_id.file_id)?;
+    document.to_lsp_location(member_id.get_syntax_id().get_range())
+}

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

@@ -67,7 +67,7 @@ pub fn definition(
     if let Some(semantic_decl) =
         semantic_model.find_decl(token.clone().into(), SemanticDeclLevel::default())
     {
-        return goto_def_definition(&semantic_model, semantic_decl);
+        return goto_def_definition(&semantic_model, semantic_decl, &token);
     } else if let Some(string_token) = LuaStringToken::cast(token.clone()) {
         if let Some(module_response) = goto_module_file(&semantic_model, string_token.clone()) {
             return Some(module_response);

crates/emmylua_ls/src/handlers/hover/build_hover.rs

@@ -1,19 +1,19 @@
 use emmylua_code_analysis::{
     DbIndex, LuaDeclId, LuaDocument, LuaMember, LuaMemberId, LuaMemberKey, LuaSemanticDeclId,
-    LuaSignatureId, LuaType, LuaTypeDeclId, RenderLevel, SemanticInfo, SemanticModel,
+    LuaSignatureId, LuaType, LuaTypeDeclId, RenderLevel, SemanticDeclLevel, SemanticInfo,
+    SemanticModel,
+};
+use emmylua_parser::{
+    LuaAssignStat, LuaAstNode, LuaExpr, LuaSyntaxKind, LuaSyntaxToken, LuaTableExpr, LuaTableField,
 };
-use emmylua_parser::{LuaAssignStat, LuaAstNode, LuaExpr, LuaSyntaxToken};
 use lsp_types::{Hover, HoverContents, MarkedString, MarkupContent};
+use std::collections::HashSet;
 
 use emmylua_code_analysis::humanize_type;
 
-use crate::handlers::hover::{
-    find_function_member_origin_owner, function_humanize::is_function,
-    hover_humanize::hover_humanize_type,
-};
+use crate::handlers::hover::{function_humanize::is_function, hover_humanize::hover_humanize_type};
 
 use super::{
-    function_humanize::find_function_decl_origin_owner,
     hover_builder::HoverBuilder,
     hover_humanize::{hover_const_type, hover_function_type},
 };
@@ -119,8 +119,7 @@ fn build_decl_hover(
 
     // 处理类型签名
     if is_function(&typ) {
-        let origin_decl_id =
-            find_function_decl_origin_owner(builder.semantic_model, decl_id.clone());
+        let origin_decl_id = find_decl_origin_owner(builder.semantic_model, decl_id.clone());
         match origin_decl_id {
             Some(LuaSemanticDeclId::Member(member_id)) => {
                 origin_member = Some(db.get_member_index().get_member(&member_id).unwrap());
@@ -209,7 +208,7 @@ fn build_member_hover(
     let mut origin_function_member = None;
     let mut origin_decl = None;
     if is_function(&typ) {
-        let origin_decl_id = find_function_member_origin_owner(&builder.semantic_model, member_id);
+        let origin_decl_id = find_member_origin_owner(&builder.semantic_model, member_id);
         match origin_decl_id {
             Some(LuaSemanticDeclId::Member(member_id)) => {
                 origin_function_member = Some(db.get_member_index().get_member(&member_id)?);
@@ -383,3 +382,128 @@ pub fn get_hover_type(builder: &HoverBuilder, semantic_model: &SemanticModel) ->
 
     None
 }
+
+pub fn find_decl_origin_owner(
+    semantic_model: &SemanticModel,
+    decl_id: LuaDeclId,
+) -> Option<LuaSemanticDeclId> {
+    let root = semantic_model
+        .get_db()
+        .get_vfs()
+        .get_syntax_tree(&decl_id.file_id)?
+        .get_red_root();
+    let node = semantic_model
+        .get_db()
+        .get_decl_index()
+        .get_decl(&decl_id)?
+        .get_value_syntax_id()?
+        .to_node_from_root(&root)?;
+    let semantic_decl = semantic_model.find_decl(node.into(), SemanticDeclLevel::default());
+    match semantic_decl {
+        Some(LuaSemanticDeclId::Member(member_id)) => {
+            find_member_origin_owner(semantic_model, member_id).or(semantic_decl)
+        }
+        Some(LuaSemanticDeclId::LuaDecl(_)) => semantic_decl,
+        _ => None,
+    }
+}
+
+pub fn find_member_origin_owner(
+    semantic_model: &SemanticModel,
+    member_id: LuaMemberId,
+) -> Option<LuaSemanticDeclId> {
+    const MAX_ITERATIONS: usize = 50;
+    let mut visited_members = HashSet::new();
+
+    let mut current_owner = resolve_member_owner(semantic_model, &member_id);
+    let mut final_owner = current_owner.clone();
+    let mut iteration_count = 0;
+
+    while let Some(LuaSemanticDeclId::Member(current_member_id)) = &current_owner {
+        if visited_members.contains(current_member_id) || iteration_count >= MAX_ITERATIONS {
+            break;
+        }
+
+        visited_members.insert(current_member_id.clone());
+        iteration_count += 1;
+
+        match resolve_member_owner(semantic_model, current_member_id) {
+            Some(next_owner) => {
+                final_owner = Some(next_owner.clone());
+                current_owner = Some(next_owner);
+            }
+            None => break,
+        }
+    }
+
+    final_owner
+}
+
+fn resolve_member_owner(
+    semantic_model: &SemanticModel,
+    member_id: &LuaMemberId,
+) -> Option<LuaSemanticDeclId> {
+    let root = semantic_model
+        .get_db()
+        .get_vfs()
+        .get_syntax_tree(&member_id.file_id)?
+        .get_red_root();
+    let current_node = member_id.get_syntax_id().to_node_from_root(&root)?;
+    match member_id.get_syntax_id().get_kind() {
+        LuaSyntaxKind::TableFieldAssign => {
+            if LuaTableField::can_cast(current_node.kind().into()) {
+                let table_field = LuaTableField::cast(current_node.clone())?;
+                // 如果表是类, 那么通过类型推断获取 owner
+                if let Some(owner_id) =
+                    resolve_table_field_through_type_inference(semantic_model, &table_field)
+                {
+                    return Some(owner_id);
+                }
+                // 非类, 那么通过右值推断
+                let value_expr = table_field.get_value_expr()?;
+                let value_node = value_expr.get_syntax_id().to_node_from_root(&root)?;
+                semantic_model.find_decl(value_node.into(), SemanticDeclLevel::default())
+            } else {
+                None
+            }
+        }
+        LuaSyntaxKind::IndexExpr => {
+            let assign_node = current_node.parent()?;
+            let assign_stat = LuaAssignStat::cast(assign_node)?;
+            let (vars, exprs) = assign_stat.get_var_and_expr_list();
+
+            for (var, expr) in vars.iter().zip(exprs.iter()) {
+                if var.syntax().text_range() == current_node.text_range() {
+                    let expr_node = expr.get_syntax_id().to_node_from_root(&root)?;
+                    return semantic_model
+                        .find_decl(expr_node.into(), SemanticDeclLevel::default());
+                }
+            }
+            None
+        }
+        _ => None,
+    }
+}
+
+fn resolve_table_field_through_type_inference(
+    semantic_model: &SemanticModel,
+    table_field: &LuaTableField,
+) -> Option<LuaSemanticDeclId> {
+    let parent = table_field.syntax().parent()?;
+    let table_expr = LuaTableExpr::cast(parent)?;
+    let table_type = semantic_model.infer_table_should_be(table_expr)?;
+
+    if !matches!(table_type, LuaType::Ref(_) | LuaType::Def(_)) {
+        return None;
+    }
+
+    let field_key = table_field.get_field_key()?;
+    let key = semantic_model.get_member_key(&field_key)?;
+    let member_infos = semantic_model.get_member_infos(&table_type)?;
+
+    member_infos
+        .iter()
+        .find(|m| m.key == key)?
+        .property_owner_id
+        .clone()
+}