Fix test

Author: CppCXY

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

@@ -91,7 +91,7 @@ mod test {
     fn test_issue_360() {
         let mut ws = VirtualWorkspace::new();
 
-        assert!(ws.check_code_for(
+        assert!(!ws.check_code_for(
             DiagnosticCode::RedundantParameter,
             r#"
                 ---@alias buz number

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

@@ -181,6 +181,11 @@ pub fn resolve_signature_by_args(
                 best_match_result = func.clone();
             }
 
+            if match_result == ParamMatchResult::NotMatch {
+                need_resolve_funcs[i] = None;
+                continue;
+            }
+
             if match_result > ParamMatchResult::AnyMatch {
                 if param_index + 1 == func.get_params().len() {
                     return Ok(func.clone());
@@ -193,6 +198,98 @@ pub fn resolve_signature_by_args(
         }
     }
 
+    let mut rest_need_resolve_funcs = need_resolve_funcs
+        .iter()
+        .filter_map(|it| it.clone())
+        .map(|it| Some(it))
+        .collect::<Vec<_>>();
+
+    match rest_need_resolve_funcs.len() {
+        0 => return Ok(best_match_result),
+        1 => return Ok(rest_need_resolve_funcs[0].clone().unwrap()),
+        _ => {}
+    }
+
+    let start_param_index = exp_len;
+    let mut max_param_len = 0;
+    for opt_func in &rest_need_resolve_funcs {
+        if let Some(func) = opt_func {
+            let param_len = func.get_params().len();
+            if param_len > max_param_len {
+                max_param_len = param_len;
+            }
+        }
+    }
+
+    let rest_len = rest_need_resolve_funcs.len();
+    for param_index in start_param_index..max_param_len {
+        let mut current_match_result = ParamMatchResult::NotMatch;
+        for i in 0..rest_len {
+            let opt_func = &rest_need_resolve_funcs[i];
+            if opt_func.is_none() {
+                continue;
+            }
+            let func = opt_func.as_ref().unwrap();
+            let param_len = func.get_params().len();
+            let colon_define = func.is_colon_define();
+            let mut param_index = param_index;
+            match (colon_define, is_colon_call) {
+                (true, false) => {
+                    if param_index == 0 {
+                        continue;
+                    }
+                    param_index -= 1;
+                }
+                (false, true) => {
+                    param_index += 1;
+                }
+                _ => {}
+            }
+            let param_type = if param_index < param_len {
+                let param_info = func.get_params().get(param_index);
+                param_info
+                    .map(|it| it.1.clone().unwrap_or(LuaType::Any))
+                    .unwrap_or(LuaType::Any)
+            } else if let Some(last_param_info) = func.get_params().last() {
+                if last_param_info.0 == "..." {
+                    last_param_info.1.clone().unwrap_or(LuaType::Any)
+                } else {
+                    return Ok(func.clone());
+                }
+            } else {
+                return Ok(func.clone());
+            };
+
+            let match_result = if param_type.is_any() {
+                ParamMatchResult::AnyMatch
+            } else if param_type.is_nullable() {
+                ParamMatchResult::TypeMatch
+            } else {
+                ParamMatchResult::NotMatch
+            };
+
+            if match_result > current_match_result {
+                current_match_result = match_result;
+                best_match_result = func.clone();
+            }
+
+            if match_result == ParamMatchResult::NotMatch {
+                rest_need_resolve_funcs[i] = None;
+                continue;
+            }
+
+            if match_result >= ParamMatchResult::AnyMatch {
+                if param_index + 1 == func.get_params().len() {
+                    return Ok(func.clone());
+                }
+            }
+        }
+
+        if current_match_result == ParamMatchResult::NotMatch {
+            break;
+        }
+    }
+
     Ok(best_match_result)
 }