fix: prefer main signature for tied overload matches

fix #1111

Author: xuhuanzy

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

@@ -932,6 +932,33 @@ mod tests {
         assert_eq!(ws.expr_ty("payload"), ws.ty("string"));
     }
 
+    #[test]
+    fn test_generic_main_signature_preferred_for_callback_arg_overload() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@generic T
+            ---@param fov (fun(): T?)
+            ---@return T?
+            ---@overload fun(fov: T): T
+            function fn_or_val(fov)
+            end
+
+            ---@type fun(): string?
+            local fn
+
+            local foo = fn_or_val(fn)
+            result = foo
+            value_result = fn_or_val("bar")
+            "#,
+        );
+
+        let foo = ws.expr_ty("result");
+        assert_eq!(ws.humanize_type(foo), "string?");
+        let value = ws.expr_ty("value_result");
+        assert_eq!(ws.humanize_type(value), "string");
+    }
+
     #[test]
     fn test_union_call_ignores_unresolved_alias_member() {
         let mut ws = VirtualWorkspace::new();

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

@@ -91,8 +91,9 @@ fn collect_callable_overload_groups_inner(
             let Some(signature) = db.get_signature_index().get(sig_id) else {
                 return Ok(());
             };
-            let mut overloads = signature.overloads.to_vec();
-            overloads.push(signature.to_doc_func_type());
+            // 主签名描述了函数实现本身, 当它和 overload 同时可匹配时应作为同等匹配下的优先候选.
+            let mut overloads = vec![signature.to_doc_func_type()];
+            overloads.extend(signature.overloads.iter().cloned());
             groups.push(overloads);
         }
         LuaType::Instance(instance) => {

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

@@ -1,3 +1,4 @@
+use std::cmp::Ordering;
 use std::sync::Arc;
 
 use crate::{
@@ -112,14 +113,6 @@ pub fn resolve_signature_by_args(
                 *opt_func = None;
                 continue;
             }
-
-            if !has_declined_no_flow_arg
-                && match_result > ParamMatchResult::Any
-                && arg_index + 1 == expr_len
-                && param_index + 1 == func.get_params().len()
-            {
-                return Ok(func.clone());
-            }
         }
 
         if current_match_result == ParamMatchResult::Not {
@@ -149,6 +142,18 @@ pub fn resolve_signature_by_args(
         _ => {}
     }
 
+    if !has_declined_no_flow_arg
+        && let Some(func) = choose_more_specific_callable(
+            db,
+            &rest_need_resolve_funcs,
+            expr_types,
+            is_colon_call,
+            declined_no_flow_args,
+        )
+    {
+        return Ok(func);
+    }
+
     let start_param_index = expr_len;
     let mut max_param_len = 0;
     for func in rest_need_resolve_funcs.iter().flatten() {
@@ -236,6 +241,110 @@ pub fn resolve_signature_by_args(
     }
 }
 
+fn choose_more_specific_callable(
+    db: &DbIndex,
+    funcs: &[Option<Arc<LuaFunctionType>>],
+    expr_types: &[LuaType],
+    is_colon_call: bool,
+    declined_no_flow_args: &[bool],
+) -> Option<Arc<LuaFunctionType>> {
+    if expr_types.is_empty()
+        || expr_types.iter().enumerate().all(|(i, expr_type)| {
+            declined_no_flow_args.get(i).copied().unwrap_or(false)
+                || expr_type.is_any()
+                || expr_type.is_unknown()
+        })
+    {
+        return None;
+    }
+
+    let mut best: Option<Arc<LuaFunctionType>> = None;
+    let mut has_strict_better = false;
+    for func in funcs.iter().flatten() {
+        let Some(best_func) = best.as_ref() else {
+            best = Some(func.clone());
+            continue;
+        };
+
+        match compare_callable_specificity(
+            db,
+            func,
+            best_func,
+            expr_types,
+            is_colon_call,
+            declined_no_flow_args,
+        ) {
+            Some(Ordering::Greater) => {
+                best = Some(func.clone());
+                has_strict_better = true;
+            }
+            Some(Ordering::Less) => {
+                has_strict_better = true;
+            }
+            Some(Ordering::Equal) => {}
+            None => return None,
+        }
+    }
+
+    if has_strict_better { best } else { None }
+}
+
+fn compare_callable_specificity(
+    db: &DbIndex,
+    a: &LuaFunctionType,
+    b: &LuaFunctionType,
+    expr_types: &[LuaType],
+    is_colon_call: bool,
+    declined_no_flow_args: &[bool],
+) -> Option<Ordering> {
+    let mut result = Ordering::Equal;
+    for (arg_index, expr_type) in expr_types.iter().enumerate() {
+        if declined_no_flow_args
+            .get(arg_index)
+            .copied()
+            .unwrap_or(false)
+            || expr_type.is_any()
+            || expr_type.is_unknown()
+        {
+            continue;
+        }
+
+        let param_index = get_call_param_index(a, arg_index, is_colon_call)?;
+        let a_param = get_func_param_type(a, param_index)?;
+        let b_param = get_func_param_type(b, param_index)?;
+        let param_order = compare_param_specificity(db, &a_param, &b_param);
+        match (result, param_order) {
+            (Ordering::Equal, order) => result = order,
+            (Ordering::Greater, Ordering::Less) | (Ordering::Less, Ordering::Greater) => {
+                return None;
+            }
+            _ => {}
+        }
+    }
+
+    Some(result)
+}
+
+fn compare_param_specificity(db: &DbIndex, a: &LuaType, b: &LuaType) -> Ordering {
+    if a == b {
+        return Ordering::Equal;
+    }
+
+    match (a.is_any() || a.is_unknown(), b.is_any() || b.is_unknown()) {
+        (true, false) => return Ordering::Less,
+        (false, true) => return Ordering::Greater,
+        _ => {}
+    }
+
+    let a_sub_b = check_type_compact(db, b, a).is_ok();
+    let b_sub_a = check_type_compact(db, a, b).is_ok();
+    match (a_sub_b, b_sub_a) {
+        (true, false) => Ordering::Greater,
+        (false, true) => Ordering::Less,
+        _ => Ordering::Equal,
+    }
+}
+
 pub(crate) fn is_func_last_param_variadic(func: &LuaFunctionType) -> bool {
     if let Some(last_param) = func.get_params().last() {
         last_param.0 == "..."