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,9 @@
 use std::collections::HashMap;
+use std::sync::Arc;
 
 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 +15,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 +28,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 +461,154 @@ 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)?;
+
+            set_meta_call_part(
+                semantic_model,
+                result,
+                call_operator_ids,
+                call_expr,
+                semantic_info.typ,
+            )?;
+        }
+        _ => {}
+    }
+    Some(())
+}
+
+fn set_meta_call_part(
+    semantic_model: &SemanticModel,
+    result: &mut Vec<InlayHint>,
+    operator_ids: &Vec<LuaOperatorId>,
+    call_expr: LuaCallExpr,
+    target_type: LuaType,
+) -> Option<()> {
+    let (operator_id, call_func) =
+        find_match_meta_call_operator_id(semantic_model, operator_ids, call_expr.clone())?;
+
+    let operator = semantic_model
+        .get_db()
+        .get_operator_index()
+        .get_operator(&operator_id)?;
+
+    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)
+    };
+
+    let document = semantic_model.get_document();
+    let parent = call_expr.syntax().parent()?;
+
+    // 如果是 `Class(...)` 且调用返回值是 Class 类型, 则显示 `new` 提示
+    let hint_new = {
+        LuaStat::can_cast(parent.kind().into())
+            && !matches!(call_expr.get_prefix_expr()?, LuaExpr::CallExpr(_))
+            && semantic_model
+                .type_check(call_func.get_ret(), &target_type)
+                .is_ok()
+    };
+
+    let (value, hint_range, padding_right) = if hint_new {
+        ("new".to_string(), call_expr.get_range(), Some(true))
+    } else {
+        (
+            "⚡".to_string(),
+            call_expr.get_prefix_expr()?.get_range(),
+            None,
+        )
+    };
+
+    let hint_position = {
+        let lsp_range = document.to_lsp_range(hint_range)?;
+        if hint_new {
+            lsp_range.start
+        } else {
+            lsp_range.end
+        }
+    };
+
+    let part = InlayHintLabelPart {
+        value,
+        location: Some(location),
+        ..Default::default()
+    };
+
+    let hint = InlayHint {
+        kind: Some(InlayHintKind::TYPE),
+        label: InlayHintLabel::LabelParts(vec![part]),
+        position: hint_position,
+        text_edits: None,
+        tooltip: None,
+        padding_left: None,
+        padding_right,
+        data: None,
+    };
+
+    result.push(hint);
+    Some(())
+}
+
+fn find_match_meta_call_operator_id(
+    semantic_model: &SemanticModel,
+    operator_ids: &Vec<LuaOperatorId>,
+    call_expr: LuaCallExpr,
+) -> Option<(LuaOperatorId, Arc<LuaFunctionType>)> {
+    let call_func = semantic_model.infer_call_expr_func(call_expr.clone(), None)?;
+    if operator_ids.len() == 1 {
+        return Some((operator_ids.first().cloned()?, call_func));
+    }
+    for operator_id in operator_ids {
+        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 {
+            return Some((operator_id.clone(), operator_func));
+        }
+    }
+    operator_ids.first().cloned().map(|id| (id, call_func))
+}

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);
+    }
 }