fix(hover): call function

Author: xuhuanzy

crates/emmylua_code_analysis/src/semantic/infer/infer_call/mod.rs

@@ -30,6 +30,7 @@ mod infer_setmetatable;
 
 pub type InferCallFuncResult = Result<Arc<LuaFunctionType>, InferFailReason>;
 
+// TODO: 如果没有完全匹配的签名也会返回一个不精确的类型, 考虑返回`None`
 pub fn infer_call_expr_func(
     db: &DbIndex,
     cache: &mut LuaInferCache,

crates/emmylua_code_analysis/src/semantic/mod.rs

@@ -183,6 +183,16 @@ impl<'a> SemanticModel<'a> {
         .ok()
     }
 
+    pub fn callable_accepts_args(
+        &self,
+        func: &LuaFunctionType,
+        expr_types: &[LuaType],
+        is_colon_call: bool,
+        arg_count: Option<usize>,
+    ) -> bool {
+        callable_accepts_args(self.db, func, expr_types, is_colon_call, arg_count)
+    }
+
     /// 推断表达式列表类型, 位于最后的表达式会触发多值推断
     pub fn infer_expr_list_types(
         &self,

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

@@ -10,11 +10,13 @@ use lsp_types::{Hover, HoverContents, MarkedString, MarkupContent};
 use rowan::TextRange;
 
 use crate::handlers::common::{find_decl_origin_owners, find_member_origin_owners};
-use crate::handlers::hover::function::{build_function_hover, is_function};
+use crate::handlers::hover::function::{build_function_hover, has_function_candidate, is_function};
 use crate::handlers::hover::humanize_type_decl::build_type_decl_hover;
 use crate::handlers::hover::humanize_types::hover_humanize_type;
 
-use super::{hover_builder::HoverBuilder, humanize_types::hover_const_type};
+use super::{
+    HoverDeclContext, HoverDeclInfo, hover_builder::HoverBuilder, humanize_types::hover_const_type,
+};
 
 pub fn build_semantic_info_hover(
     semantic_model: &SemanticModel,
@@ -120,24 +122,25 @@ fn build_decl_hover(
 ) -> Option<()> {
     let decl = db.get_decl_index().get_decl(&decl_id)?;
 
-    let mut semantic_decls =
+    let semantic_decls =
         find_decl_origin_owners(builder.semantic_model, decl_id).get_types(builder.semantic_model);
 
     // 处理类型签名
     if is_function(&typ) {
-        adjust_semantic_decls(
-            builder,
-            &mut semantic_decls,
-            &LuaSemanticDeclId::LuaDecl(decl_id),
-            &typ,
+        let origin_decls = into_hover_decl_infos(semantic_decls);
+        let hover_decl_context = HoverDeclContext::new(
+            HoverDeclInfo::new(LuaSemanticDeclId::LuaDecl(decl_id), typ.clone()),
+            origin_decls,
         );
 
         // 处理函数类型
-        build_function_hover(builder, db, &semantic_decls);
+        build_function_hover(builder, db, &hover_decl_context);
 
-        if let Some((LuaSemanticDeclId::Member(member_id), _)) = semantic_decls
+        if let Some(decl_info) = hover_decl_context
+            .origin_decls()
             .iter()
-            .find(|(decl, _)| matches!(decl, LuaSemanticDeclId::Member(_)))
+            .find(|decl_info| matches!(decl_info.id(), LuaSemanticDeclId::Member(_)))
+            && let LuaSemanticDeclId::Member(member_id) = decl_info.id()
         {
             let member = db.get_member_index().get_member(member_id);
             builder.set_location_path(member);
@@ -225,16 +228,15 @@ fn build_member_hover(
         _ => return None,
     };
 
+    let origin_decls = into_hover_decl_infos(semantic_decls);
+    let hover_decl_context = HoverDeclContext::new(
+        HoverDeclInfo::new(LuaSemanticDeclId::Member(member_id), typ.clone()),
+        origin_decls,
+    );
+
     // 当为表字段时, 如果能够追溯到该成员的定义为 function, 那么我们也需要显示方法的签名而不是当前字段的真实类型
-    if is_function(&typ) || (!semantic_decls.is_empty() && is_function(&semantic_decls.first()?.1))
-    {
-        adjust_semantic_decls(
-            builder,
-            &mut semantic_decls,
-            &LuaSemanticDeclId::Member(member_id),
-            &typ,
-        );
-        build_function_hover(builder, db, &semantic_decls);
+    if has_function_candidate(&hover_decl_context) {
+        build_function_hover(builder, db, &hover_decl_context);
 
         builder.set_location_path(Some(member));
 
@@ -266,7 +268,12 @@ fn build_member_hover(
         let member_decl = LuaSemanticDeclId::Member(member.get_id());
         semantic_decl_set.insert(&member_decl);
         if !is_completion {
-            semantic_decl_set.extend(semantic_decls.iter().map(|(decl, _)| decl));
+            semantic_decl_set.extend(
+                hover_decl_context
+                    .origin_decls()
+                    .iter()
+                    .map(|decl_info| decl_info.id()),
+            );
         }
         for semantic_decl in semantic_decl_set {
             builder.add_description(semantic_decl);
@@ -276,6 +283,13 @@ fn build_member_hover(
     Some(())
 }
 
+fn into_hover_decl_infos(semantic_decls: Vec<(LuaSemanticDeclId, LuaType)>) -> Vec<HoverDeclInfo> {
+    semantic_decls
+        .into_iter()
+        .map(|(semantic_decl_id, typ)| HoverDeclInfo::new(semantic_decl_id, typ))
+        .collect()
+}
+
 pub fn add_signature_param_description(
     db: &DbIndex,
     marked_strings: &mut Vec<MarkedString>,
@@ -371,38 +385,3 @@ pub fn get_hover_type(builder: &HoverBuilder, semantic_model: &SemanticModel) ->
 
     None
 }
-
-fn adjust_semantic_decls(
-    _builder: &mut HoverBuilder,
-    semantic_decls: &mut Vec<(LuaSemanticDeclId, LuaType)>,
-    current_semantic_decl_id: &LuaSemanticDeclId,
-    current_type: &LuaType,
-) -> Option<()> {
-    if let Some(pos) = semantic_decls
-        .iter()
-        .position(|(_, typ)| current_type == typ)
-    {
-        if pos != 0 {
-            let item = semantic_decls.remove(pos);
-            semantic_decls.insert(0, item);
-        }
-    } else {
-        // semantic_decls 是追溯最初定义的结果, 不包含当前内容
-        let current_len = semantic_decls.len();
-        if current_len == 0 {
-            // 没有最初定义, 直接添加原始内容
-            semantic_decls.push((current_semantic_decl_id.clone(), current_type.clone()));
-        }
-    }
-
-    // 将第一个是 Signature 的放至前面, 因为我们会使用第一个作为主要签名
-    if let Some(pos) = semantic_decls
-        .iter()
-        .position(|(_, typ)| typ.is_signature())
-    {
-        let item = semantic_decls.remove(pos);
-        semantic_decls.insert(0, item);
-    }
-
-    Some(())
-}

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

@@ -0,0 +1,85 @@
+use emmylua_code_analysis::{LuaSemanticDeclId, LuaType};
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct HoverDeclInfo {
+    id: LuaSemanticDeclId,
+    typ: LuaType,
+}
+
+impl HoverDeclInfo {
+    pub(crate) fn new(id: LuaSemanticDeclId, typ: LuaType) -> Self {
+        Self { id, typ }
+    }
+
+    pub(crate) fn id(&self) -> &LuaSemanticDeclId {
+        &self.id
+    }
+
+    pub(crate) fn typ(&self) -> &LuaType {
+        &self.typ
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct HoverDeclContext {
+    current_decl: HoverDeclInfo,
+    origin_decls: Vec<HoverDeclInfo>,
+}
+
+impl HoverDeclContext {
+    pub(crate) fn new(current_decl: HoverDeclInfo, origin_decls: Vec<HoverDeclInfo>) -> Self {
+        Self {
+            current_decl,
+            origin_decls,
+        }
+    }
+
+    pub(crate) fn current_decl(&self) -> &HoverDeclInfo {
+        &self.current_decl
+    }
+
+    pub(crate) fn origin_decls(&self) -> &[HoverDeclInfo] {
+        &self.origin_decls
+    }
+
+    fn primary_decl(&self) -> &HoverDeclInfo {
+        self.origin_decls
+            .iter()
+            .find(|decl| decl.typ().is_signature())
+            .or_else(|| {
+                self.origin_decls
+                    .iter()
+                    .find(|decl| decl.typ() == self.current_decl.typ())
+            })
+            .or_else(|| self.origin_decls.first())
+            .unwrap_or(&self.current_decl)
+    }
+
+    pub(crate) fn ordered_decl_refs(&self) -> Vec<&HoverDeclInfo> {
+        let mut decls = if self.origin_decls.is_empty() {
+            vec![&self.current_decl]
+        } else {
+            self.origin_decls.iter().collect::<Vec<_>>()
+        };
+
+        if let Some(pos) = decls
+            .iter()
+            .position(|decl| decl.typ() == self.current_decl.typ())
+        {
+            if pos != 0 {
+                let item = decls.remove(pos);
+                decls.insert(0, item);
+            }
+        }
+
+        let primary_decl = self.primary_decl();
+        if let Some(pos) = decls.iter().position(|decl| *decl == primary_decl) {
+            if pos != 0 {
+                let item = decls.remove(pos);
+                decls.insert(0, item);
+            }
+        }
+
+        decls
+    }
+}