update resolve signature

fix #633

Author: xuhuanzy

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

@@ -195,4 +195,35 @@ mod test {
         "#
         ));
     }
+
+    #[test]
+    fn test_issue_633() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def_file(
+            "test.lua",
+            r#"
+            ---@param mode number
+            ---@param a number
+            ---@param b number
+            ---@param c number
+            ---@param d number?
+            ---@return string
+            ---@overload fun(mode:number, a:number, b:number):number
+            function test(mode, a, b, c, d)
+            end
+
+            ---@return number, number
+            function getNumbers()
+                return 1, 2
+            end
+        "#,
+        );
+
+        assert!(ws.check_code_for_namespace(
+            DiagnosticCode::MissingParameter,
+            r#"
+            test(1, getNumbers())
+        "#
+        ));
+    }
 }

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

@@ -1,14 +1,17 @@
-use std::sync::Arc;
+use std::{ops::Deref, sync::Arc};
 
-use emmylua_parser::LuaCallExpr;
+use emmylua_parser::{LuaCallExpr, LuaExpr};
 
-use crate::db_index::{DbIndex, LuaFunctionType, LuaType};
+use crate::{
+    VariadicType,
+    db_index::{DbIndex, LuaFunctionType, LuaType},
+    infer_expr,
+};
 
 use super::{
     LuaInferCache,
     generic::instantiate_func_generic,
     infer::{InferCallFuncResult, InferFailReason},
-    infer_expr,
     type_check::check_type_compact,
 };
 
@@ -21,10 +24,12 @@ pub fn resolve_signature(
     arg_count: Option<usize>,
 ) -> InferCallFuncResult {
     let args = call_expr.get_args_list().ok_or(InferFailReason::None)?;
-    let mut expr_types = Vec::new();
-    for arg in args.get_args() {
-        expr_types.push(infer_expr(db, cache, arg)?);
-    }
+    let expr_types = infer_expr_list_types(
+        db,
+        cache,
+        args.get_args().collect::<Vec<_>>().as_slice(),
+        arg_count,
+    );
     if is_generic {
         resolve_signature_by_generic(db, cache, overloads, call_expr, expr_types, arg_count)
     } else {
@@ -139,3 +144,46 @@ fn resolve_signature_by_args(
         .or_else(|| overloads.last().cloned())
         .ok_or(InferFailReason::None)
 }
+
+fn infer_expr_list_types(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    exprs: &[LuaExpr],
+    var_count: Option<usize>,
+) -> Vec<LuaType> {
+    let mut value_types = Vec::new();
+    for (idx, expr) in exprs.iter().enumerate() {
+        let expr_type = infer_expr(db, cache, expr.clone()).unwrap_or(LuaType::Unknown);
+        match expr_type {
+            LuaType::Variadic(variadic) => {
+                if let Some(var_count) = var_count {
+                    if idx < var_count {
+                        for i in idx..var_count {
+                            if let Some(typ) = variadic.get_type(i - idx) {
+                                value_types.push(typ.clone());
+                            } else {
+                                break;
+                            }
+                        }
+                    }
+                } else {
+                    match variadic.deref() {
+                        VariadicType::Base(base) => {
+                            value_types.push(base.clone());
+                        }
+                        VariadicType::Multi(vecs) => {
+                            for typ in vecs {
+                                value_types.push(typ.clone());
+                            }
+                        }
+                    }
+                }
+
+                break;
+            }
+            _ => value_types.push(expr_type.clone()),
+        }
+    }
+
+    value_types
+}