add meta __call hint

Author: xuhuanzy

crates/emmylua_code_analysis/resources/schema.json

@@ -76,6 +76,7 @@
         "enable": true,
         "indexHint": true,
         "localHint": true,
+        "metaCallHint": true,
         "overrideHint": true,
         "paramHint": true
       },
@@ -741,6 +742,11 @@
           "default": true,
           "type": "boolean"
         },
+        "metaCallHint": {
+          "description": "Whether to enable meta __call operator hints.",
+          "default": true,
+          "type": "boolean"
+        },
         "overrideHint": {
           "description": "Whether to enable override hints.",
           "default": true,

crates/emmylua_code_analysis/src/config/configs/inlayhint.rs

@@ -20,6 +20,9 @@ pub struct EmmyrcInlayHint {
     /// Whether to enable override hints.
     #[serde(default = "default_true")]
     pub override_hint: bool,
+    /// Whether to enable meta __call operator hints.
+    #[serde(default = "default_true")]
+    pub meta_call_hint: bool,
 }
 
 impl Default for EmmyrcInlayHint {
@@ -30,6 +33,7 @@ impl Default for EmmyrcInlayHint {
             index_hint: default_true(),
             local_hint: default_true(),
             override_hint: default_true(),
+            meta_call_hint: default_true(),
         }
     }
 }

crates/emmylua_code_analysis/src/db_index/operators/lua_operator.rs

@@ -164,6 +164,10 @@ impl LuaOperator {
             position: self.range.start(),
         }
     }
+
+    pub fn get_range(&self) -> TextRange {
+        self.range
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

crates/emmylua_code_analysis/src/semantic/mod.rs

@@ -22,6 +22,7 @@ use emmylua_parser::{
 use infer::{infer_bind_value_type, 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::find_index_operations;
 pub use member::get_member_map;
 pub use member::LuaMemberInfo;
 use member::{find_member_origin_owner, find_members};

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

@@ -96,7 +96,7 @@ fn get_signature_functions(signature: &LuaSignature) -> Vec<Arc<LuaFunctionType>
 }
 
 /// 比较函数类型是否匹配, 会处理泛型情况
-fn compare_function_types(
+pub fn compare_function_types(
     semantic_model: &SemanticModel,
     call_function: &LuaFunctionType,
     func: &Arc<LuaFunctionType>,

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

@@ -10,6 +10,7 @@ use emmylua_parser::{
 pub use goto_def_definition::goto_def_definition;
 use goto_def_definition::goto_str_tpl_ref_definition;
 pub use goto_doc_see::goto_doc_see;
+pub use goto_function::compare_function_types;
 pub use goto_module_file::goto_module_file;
 use lsp_types::{
     ClientCapabilities, GotoDefinitionParams, GotoDefinitionResponse, OneOf, Position,

crates/emmylua_ls/src/handlers/inlay_hint/build_inlay_hint.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 
 use emmylua_code_analysis::{
-    FileId, InferGuard, LuaFunctionType, LuaMemberId, LuaMemberKey, LuaSemanticDeclId, LuaType,
-    SemanticModel,
+    FileId, InferGuard, LuaFunctionType, LuaMemberId, LuaMemberKey, LuaOperatorId,
+    LuaOperatorMetaMethod, LuaSemanticDeclId, LuaType, SemanticModel,
 };
 use emmylua_parser::{
     LuaAst, LuaAstNode, LuaCallExpr, LuaExpr, LuaFuncStat, LuaIndexExpr, LuaLocalFuncStat,
@@ -14,6 +14,7 @@ use rowan::NodeOrToken;
 
 use rowan::TokenAtOffset;
 
+use crate::handlers::definition::compare_function_types;
 use crate::handlers::inlay_hint::build_function_hint::{build_closure_hint, build_label_parts};
 
 pub fn build_inlay_hints(semantic_model: &SemanticModel) -> Option<Vec<InlayHint>> {
@@ -26,7 +27,8 @@ pub fn build_inlay_hints(semantic_model: &SemanticModel) -> Option<Vec<InlayHint
             }
             LuaAst::LuaCallExpr(call_expr) => {
                 build_call_expr_param_hint(semantic_model, &mut result, call_expr.clone());
-                build_call_expr_await_hint(semantic_model, &mut result, call_expr);
+                build_call_expr_await_hint(semantic_model, &mut result, call_expr.clone());
+                build_call_expr_meta_call_hint(semantic_model, &mut result, call_expr);
             }
             LuaAst::LuaLocalName(local_name) => {
                 build_local_name_hint(semantic_model, &mut result, local_name);
@@ -458,3 +460,115 @@ fn get_override_lsp_location(
     let lsp_range = document.to_lsp_location(range)?;
     Some(lsp_range)
 }
+
+fn build_call_expr_meta_call_hint(
+    semantic_model: &SemanticModel,
+    result: &mut Vec<InlayHint>,
+    call_expr: LuaCallExpr,
+) -> Option<()> {
+    if !semantic_model.get_emmyrc().hint.meta_call_hint {
+        return Some(());
+    }
+
+    let prefix_expr = call_expr.get_prefix_expr()?;
+    let semantic_info =
+        semantic_model.get_semantic_info(NodeOrToken::Node(prefix_expr.syntax().clone()))?;
+
+    match &semantic_info.typ {
+        LuaType::Ref(id) | LuaType::Def(id) => {
+            let decl = semantic_model.get_db().get_type_index().get_type_decl(id)?;
+            if !decl.is_class() {
+                return Some(());
+            }
+
+            let call_operator_ids = semantic_model
+                .get_db()
+                .get_operator_index()
+                .get_operators(&id.clone().into(), LuaOperatorMetaMethod::Call)?;
+            let call_operator_parts =
+                get_meta_call_part(semantic_model, call_operator_ids, call_expr)?;
+            if call_operator_parts.is_empty() {
+                return Some(());
+            }
+
+            let hint_position = {
+                let range = prefix_expr.get_range();
+                let document = semantic_model.get_document();
+                let lsp_range = document.to_lsp_range(range)?;
+                lsp_range.end
+            };
+
+            let hint = InlayHint {
+                kind: Some(InlayHintKind::TYPE),
+                label: InlayHintLabel::LabelParts(call_operator_parts),
+                position: hint_position,
+                text_edits: None,
+                tooltip: None,
+                padding_left: None,
+                padding_right: Some(true),
+                data: None,
+            };
+            result.push(hint);
+        }
+        _ => {}
+    }
+    Some(())
+}
+
+fn get_meta_call_part(
+    semantic_model: &SemanticModel,
+    operator_ids: &Vec<LuaOperatorId>,
+    call_expr: LuaCallExpr,
+) -> Option<Vec<InlayHintLabelPart>> {
+    let call_func = semantic_model.infer_call_expr_func(call_expr.clone(), None)?;
+
+    let mut parts = Vec::new();
+    for (idx, operator_id) in operator_ids.iter().enumerate() {
+        let operator = semantic_model
+            .get_db()
+            .get_operator_index()
+            .get_operator(operator_id)?;
+        let operator_func = {
+            let operator_type = operator.get_operator_func(semantic_model.get_db());
+            match operator_type {
+                LuaType::DocFunction(func) => func,
+                LuaType::Signature(signature_id) => {
+                    let signature = semantic_model
+                        .get_db()
+                        .get_signature_index()
+                        .get(&signature_id)?;
+                    signature.to_doc_func_type()
+                }
+                _ => return None,
+            }
+        };
+        let is_match =
+            compare_function_types(semantic_model, &call_func, &operator_func, &call_expr)
+                .unwrap_or(false);
+
+        // 不匹配且不是第一个, 跳过
+        if !is_match && idx != 0 {
+            continue;
+        }
+        // 清空
+        parts.clear();
+
+        let location = {
+            let range = operator.get_range();
+            let document = semantic_model.get_document_by_file_id(operator.get_file_id())?;
+            let lsp_range = document.to_lsp_range(range)?;
+            Location::new(document.get_uri(), lsp_range)
+        };
+
+        parts.push(InlayHintLabelPart {
+            value: ": call".to_string(),
+            location: Some(location),
+            ..Default::default()
+        });
+
+        if is_match {
+            return Some(parts);
+        }
+    }
+    Some(parts)
+}

crates/emmylua_ls/src/handlers/test/inlay_hint_test.rs

@@ -91,4 +91,21 @@ mod tests {
             .unwrap();
         assert!(result.is_empty());
     }
+
+    #[test]
+    fn test_meta_call_hint() {
+        let mut ws = ProviderVirtualWorkspace::new();
+        let result = ws
+            .check_inlay_hint(
+                r#"
+                ---@class Hint1
+                ---@overload fun(a: string): Hint1
+                local Hint1
+
+                local a = Hint1("a")
+            "#,
+            )
+            .unwrap();
+        assert!(result.len() == 4);
+    }
 }