diagnostic: fix call param is function

Author: xuhuanzy

crates/emmylua_code_analysis/src/diagnostic/checker/check_param_count.rs

@@ -38,15 +38,16 @@ fn check_closure_expr(
     semantic_model: &SemanticModel,
     closure_expr: &LuaClosureExpr,
 ) -> Option<()> {
-    let source_typ =
-        semantic_model.infer_left_value_type_from_right_value(closure_expr.clone().into())?;
-    let right_value = context
+    let current_signature = context
         .db
         .get_signature_index()
         .get(&LuaSignatureId::from_closure(
             semantic_model.get_file_id(),
             &closure_expr,
         ))?;
+
+    let source_typ = semantic_model.infer_bind_value_type(closure_expr.clone().into())?;
+
     let source_params_len = match &source_typ {
         LuaType::DocFunction(func_type) => {
             let params = func_type.get_params();
@@ -61,7 +62,7 @@ fn check_closure_expr(
     }?;
 
     // 只检查右值参数多于左值参数的情况, 右值参数少于左值参数的情况是能够接受的
-    if source_params_len > right_value.params.len() {
+    if source_params_len > current_signature.params.len() {
         return Some(());
     }
     let params = closure_expr
@@ -76,7 +77,7 @@ fn check_closure_expr(
             t!(
                 "expected %{num} parameters but found %{found_num}",
                 num = source_params_len,
-                found_num = right_value.params.len(),
+                found_num = current_signature.params.len(),
             )
             .to_string(),
             None,

crates/emmylua_code_analysis/src/diagnostic/checker/check_return_count.rs

@@ -32,7 +32,7 @@ fn get_function_return_info(
     closure_expr: &LuaClosureExpr,
 ) -> Option<(bool, LuaType)> {
     let typ = semantic_model
-        .infer_left_value_type_from_right_value(closure_expr.clone().into())
+        .infer_bind_value_type(closure_expr.clone().into())
         .unwrap_or(LuaType::Unknown);
 
     match typ {

crates/emmylua_code_analysis/src/diagnostic/test/redundant_parameter_test.rs

@@ -105,4 +105,24 @@ mod test {
         "#
         ));
     }
+
+    #[test]
+    fn test_function_param() {
+        let mut ws = VirtualWorkspace::new();
+        assert!(!ws.check_code_for(
+            DiagnosticCode::RedundantParameter,
+            r#"
+                ---@class D30
+                local M = {}
+
+                ---@param callback fun()
+                local function with_local(callback)
+                end
+
+                function M:add_local_event()
+                    with_local(function(local_player) end)
+                end
+        "#
+        ));
+    }
 }

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

@@ -10,8 +10,8 @@ mod test;
 use std::ops::Deref;
 
 use emmylua_parser::{
-    LuaAst, LuaAstNode, LuaClosureExpr, LuaExpr, LuaLiteralExpr, LuaLiteralToken, LuaTableExpr,
-    LuaVarExpr,
+    LuaAst, LuaAstNode, LuaCallExpr, LuaClosureExpr, LuaExpr, LuaLiteralExpr, LuaLiteralToken,
+    LuaTableExpr, LuaVarExpr,
 };
 use infer_binary::infer_binary_expr;
 use infer_call::infer_call_expr;
@@ -213,15 +213,14 @@ pub fn infer_multi_value_adjusted_expression_types(
     value_types
 }
 
-/// 从右值推断左值已绑定的类型
-pub fn infer_left_value_type_from_right_value(
+/// 推断值已经绑定的类型(不是推断值的类型). 例如从右值推断左值类型, 从调用参数推断函数参数类型参数类型
+pub fn infer_bind_value_type(
     db: &DbIndex,
     cache: &mut LuaInferCache,
     expr: LuaExpr,
 ) -> Option<LuaType> {
-    let ast = expr.syntax().parent().map(LuaAst::cast).flatten()?;
-
-    let typ = match ast {
+    let parent_node = expr.syntax().parent().map(LuaAst::cast).flatten()?;
+    let typ = match parent_node {
         LuaAst::LuaAssignStat(assign) => {
             let (vars, exprs) = assign.get_var_and_expr_list();
             let mut typ = None;
@@ -264,6 +263,42 @@ pub fn infer_left_value_type_from_right_value(
                 Err(_) => Some(LuaType::Unknown),
             }
         }
+        LuaAst::LuaCallArgList(call_arg_list) => {
+            let call_expr = call_arg_list.get_parent::<LuaCallExpr>()?;
+            // 获取调用位置
+            let mut param_pos = 0;
+            for (idx, arg) in call_arg_list.get_args().enumerate() {
+                if arg == expr {
+                    param_pos = idx;
+                    break;
+                }
+            }
+            let is_colon_call = call_expr.is_colon_call();
+
+            let expr_type = infer_expr(db, cache, call_expr.get_prefix_expr()?).ok()?;
+            match expr_type {
+                LuaType::Signature(signature_id) => {
+                    let signature = db.get_signature_index().get(&signature_id)?;
+                    match (signature.is_colon_define, is_colon_call) {
+                        (true, false) => {
+                            param_pos += 1;
+                        }
+                        (false, true) => {
+                            if param_pos == 0 {
+                                return None;
+                            }
+                            param_pos -= 1;
+                        }
+                        _ => {}
+                    }
+                    let param_info = signature.get_param_info_by_id(param_pos)?;
+                    return Some(param_info.type_ref.clone());
+                }
+                _ => {}
+            }
+
+            return None;
+        }
         _ => None,
     };
 

crates/emmylua_code_analysis/src/semantic/mod.rs

@@ -17,7 +17,7 @@ use emmylua_parser::{
     LuaCallExpr, LuaChunk, LuaExpr, LuaIndexKey, LuaParseError, LuaSyntaxNode, LuaSyntaxToken,
     LuaTableExpr,
 };
-use infer::{infer_left_value_type_from_right_value, infer_multi_value_adjusted_expression_types};
+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::get_member_map;
@@ -163,9 +163,9 @@ impl<'a> SemanticModel<'a> {
         )
     }
 
-    /// 从右值推断左值已绑定的类型
-    pub fn infer_left_value_type_from_right_value(&self, expr: LuaExpr) -> Option<LuaType> {
-        infer_left_value_type_from_right_value(self.db, &mut self.infer_cache.borrow_mut(), expr)
+    /// 推断值已经绑定的类型(不是推断值的类型). 例如从右值推断左值类型, 从调用参数推断函数参数类型
+    pub fn infer_bind_value_type(&self, expr: LuaExpr) -> Option<LuaType> {
+        infer_bind_value_type(self.db, &mut self.infer_cache.borrow_mut(), expr)
     }
 
     pub fn get_semantic_info(