fix(generic): keep callable overload inference shape-aware

Author: lewis6991

crates/emmylua_code_analysis/src/compilation/test/callable_return_infer_test.rs

@@ -200,4 +200,98 @@ mod test {
         // unresolved and carried through a named callback value.
         assert_eq!(ws.expr_ty("classify_string_unresolved"), ws.ty("string"));
     }
+
+    #[test]
+    fn test_apply_return_infer_leaves_result_unknown_when_no_callable_member_matches_arg_shape() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@generic A, R
+            ---@param f fun(x: A): R
+            ---@param x A
+            ---@return R
+            local function apply(f, x)
+                return f(x)
+            end
+
+            ---@alias FnInt fun(x: integer): integer
+            ---@alias FnString fun(x: string): string
+
+            ---@type FnInt | FnString
+            local run
+
+            ---@type boolean
+            local b
+
+            result = apply(run, b)
+            "#,
+        );
+
+        let result_ty = ws.expr_ty("result");
+        assert_eq!(result_ty, ws.ty("unknown"));
+    }
+
+    #[test]
+    fn test_apply_return_infer_keeps_only_arity_compatible_fallbacks() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@generic A, B, R
+            ---@param f fun(x: A, y: B): R
+            ---@param x A
+            ---@param y B
+            ---@return R
+            local function apply2(f, x, y)
+                return f(x, y)
+            end
+
+            ---@overload fun(x: integer): integer
+            ---@param x integer
+            ---@param y string
+            ---@return string
+            local function run(x, y) end
+
+            local source ---@type table
+
+            result = apply2(run, 1, source.missing)
+            "#,
+        );
+
+        let result_ty = ws.expr_ty("result");
+        assert_eq!(ws.humanize_type(result_ty), "string");
+    }
+
+    #[test]
+    fn test_union_call_ignores_non_matching_generic_callable_member() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@type (fun<T: string>(x: T): T) | fun(x: integer): integer
+            local run
+
+            result = run(1)
+            "#,
+        );
+
+        let result_ty = ws.expr_ty("result");
+        assert_eq!(ws.humanize_type(result_ty), "integer");
+    }
+
+    #[test]
+    fn test_union_call_ignores_non_matching_generic_alias_member() {
+        let mut ws = VirtualWorkspace::new();
+        ws.def(
+            r#"
+            ---@alias GenericStr<T: string> fun(x: T): T
+
+            ---@type GenericStr | fun(x: integer): integer
+            local run
+
+            result = run(1)
+            "#,
+        );
+
+        let result_ty = ws.expr_ty("result");
+        assert_eq!(ws.humanize_type(result_ty), "integer");
+    }
 }

crates/emmylua_code_analysis/src/semantic/generic/instantiate_type/instantiate_func_generic.rs

@@ -27,7 +27,7 @@ use crate::{
 };
 use crate::{
     LuaMemberOwner, LuaSemanticDeclId, SemanticDeclLevel, infer_node_semantic_decl,
-    tpl_pattern_match_args,
+    tpl_pattern_match_args_skip_unknown,
 };
 
 use super::{TypeSubstitutor, collect_callable_overload_groups};
@@ -259,15 +259,22 @@ pub fn infer_callable_return_from_remaining_args(
     let call_arg_types =
         match infer_expr_list_types(context.db, context.cache, arg_exprs, None, infer_expr) {
             Ok(types) => types.into_iter().map(|(ty, _)| ty).collect::<Vec<_>>(),
-            Err(_) => {
-                return infer_callable_return_from_arg_types(context, callable_type, None, true);
-            }
+            Err(_) => arg_exprs
+                .iter()
+                .map(|arg_expr| {
+                    infer_expr(context.db, context.cache, arg_expr.clone())
+                        .unwrap_or(LuaType::Unknown)
+                })
+                .collect::<Vec<_>>(),
         };
     if call_arg_types.is_empty() {
         return Ok(None);
     }
 
-    infer_callable_return_from_arg_types(context, callable_type, Some(&call_arg_types), true)
+    // Preserve any known remaining-arg shape, including arity, even when some later arguments
+    // collapse to `unknown`. This avoids unioning returns from overloads that are impossible
+    // for the current call.
+    infer_callable_return_from_arg_types(context, callable_type, Some(&call_arg_types), false)
 }
 
 fn instantiate_callable_from_arg_types(
@@ -302,7 +309,12 @@ fn instantiate_callable_from_arg_types(
         substitutor: &mut callable_substitutor,
         call_expr: context.call_expr.clone(),
     };
-    if tpl_pattern_match_args(&mut callable_context, &callable_param_types, call_arg_types).is_err()
+    if tpl_pattern_match_args_skip_unknown(
+        &mut callable_context,
+        &callable_param_types,
+        call_arg_types,
+    )
+    .is_err()
     {
         return None;
     }

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

@@ -15,6 +15,7 @@ pub use instantiate_type::*;
 use rowan::NodeOrToken;
 pub use tpl_context::TplContext;
 pub use tpl_pattern::tpl_pattern_match_args;
+pub use tpl_pattern::tpl_pattern_match_args_skip_unknown;
 pub use type_substitutor::TypeSubstitutor;
 
 use crate::DbIndex;

crates/emmylua_code_analysis/src/semantic/generic/tpl_pattern/mod.rs

@@ -32,6 +32,23 @@ pub fn tpl_pattern_match_args(
     context: &mut TplContext,
     func_param_types: &[LuaType],
     call_arg_types: &[LuaType],
+) -> TplPatternMatchResult {
+    tpl_pattern_match_args_inner(context, func_param_types, call_arg_types, false)
+}
+
+pub fn tpl_pattern_match_args_skip_unknown(
+    context: &mut TplContext,
+    func_param_types: &[LuaType],
+    call_arg_types: &[LuaType],
+) -> TplPatternMatchResult {
+    tpl_pattern_match_args_inner(context, func_param_types, call_arg_types, true)
+}
+
+fn tpl_pattern_match_args_inner(
+    context: &mut TplContext,
+    func_param_types: &[LuaType],
+    call_arg_types: &[LuaType],
+    skip_unknown_tpl: bool,
 ) -> TplPatternMatchResult {
     for i in 0..func_param_types.len() {
         if i >= call_arg_types.len() {
@@ -54,6 +71,9 @@ pub fn tpl_pattern_match_args(
                 )?;
                 break;
             }
+            _ if skip_unknown_tpl
+                && func_param_type.contain_tpl()
+                && (call_arg_type.is_any() || call_arg_type.is_unknown()) => {}
             _ => {
                 tpl_pattern_match(context, func_param_type, call_arg_type)?;
             }

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

@@ -1,12 +1,14 @@
 use std::sync::Arc;
 
 use emmylua_parser::{LuaAstNode, LuaCallExpr, LuaExpr, LuaSyntaxKind};
+use hashbrown::HashSet;
 use rowan::TextRange;
 
 use super::{
     super::{InferGuard, LuaInferCache, instantiate_type_generic, resolve_signature},
     InferFailReason, InferResult,
 };
+use crate::semantic::overload_resolve::callable_accepts_args;
 use crate::{
     CacheEntry, DbIndex, InFiled, LuaFunctionType, LuaGenericType, LuaInstanceType,
     LuaIntersectionType, LuaOperatorMetaMethod, LuaOperatorOwner, LuaSignature, LuaSignatureId,
@@ -102,12 +104,16 @@ pub fn infer_call_expr_func(
         ),
         LuaType::Union(union) => {
             // 此时我们将其视为泛型实例化联合体
-            if union
-                .into_vec()
+            let union_types = union.into_vec();
+            if union_types
                 .iter()
                 .all(|t| matches!(t, LuaType::DocFunction(_)))
             {
-                infer_generic_doc_function_union(db, cache, union, call_expr.clone(), args_count)
+                let mut overloads = Vec::new();
+                for typ in union_types {
+                    overloads.extend(collect_callable_overloads(db, &typ)?);
+                }
+                resolve_filtered_overloads(db, cache, overloads, call_expr.clone(), args_count)
             } else {
                 infer_union(db, cache, union, call_expr.clone(), args_count)
             }
@@ -194,19 +200,67 @@ fn infer_doc_function(
     Ok(func.clone().into())
 }
 
-fn infer_generic_doc_function_union(
+fn filter_callable_overloads_by_call_args(
     db: &DbIndex,
     cache: &mut LuaInferCache,
-    union: &LuaUnionType,
+    overloads: Vec<Arc<LuaFunctionType>>,
+    call_expr: &LuaCallExpr,
+    args_count: Option<usize>,
+) -> Result<Vec<Arc<LuaFunctionType>>, InferFailReason> {
+    let args = call_expr.get_args_list().ok_or(InferFailReason::None)?;
+    let expr_types = super::infer_expr_list_types(
+        db,
+        cache,
+        &args.get_args().collect::<Vec<_>>(),
+        args_count,
+        |db, cache, expr| Ok(infer_expr(db, cache, expr).unwrap_or(LuaType::Unknown)),
+    )?
+    .into_iter()
+    .map(|(ty, _)| ty)
+    .collect::<Vec<_>>();
+    let is_colon_call = call_expr.is_colon_call();
+
+    Ok(overloads
+        .into_iter()
+        .filter(|func| {
+            let mut callable_tpls = HashSet::new();
+            func.visit_type(&mut |ty| match ty {
+                LuaType::TplRef(generic_tpl) | LuaType::ConstTplRef(generic_tpl) => {
+                    callable_tpls.insert(generic_tpl.get_tpl_id());
+                }
+                LuaType::StrTplRef(str_tpl) => {
+                    callable_tpls.insert(str_tpl.get_tpl_id());
+                }
+                _ => {}
+            });
+
+            if callable_tpls.is_empty() {
+                return true;
+            }
+
+            let mut substitutor = TypeSubstitutor::new();
+            substitutor.add_need_infer_tpls(callable_tpls);
+            let match_func = match instantiate_doc_function(db, func, &substitutor) {
+                LuaType::DocFunction(doc_func) => doc_func,
+                _ => func.clone(),
+            };
+
+            callable_accepts_args(db, &match_func, &expr_types, is_colon_call, args_count)
+        })
+        .collect())
+}
+
+fn resolve_filtered_overloads(
+    db: &DbIndex,
+    cache: &mut LuaInferCache,
+    overloads: Vec<Arc<LuaFunctionType>>,
     call_expr: LuaCallExpr,
     args_count: Option<usize>,
 ) -> InferCallFuncResult {
-    let mut overloads = Vec::new();
-    for typ in union.into_vec() {
-        overloads.extend(collect_callable_overloads(db, &typ)?);
-    }
-
-    resolve_signature(db, cache, overloads, call_expr.clone(), false, args_count)
+    let contains_tpl = overloads.iter().any(|func| func.contain_tpl());
+    let overloads =
+        filter_callable_overloads_by_call_args(db, cache, overloads, &call_expr, args_count)?;
+    resolve_signature(db, cache, overloads, call_expr, contains_tpl, args_count)
 }
 
 fn infer_signature_doc_function(
@@ -482,8 +536,7 @@ fn infer_union(
     if overloads.is_empty() {
         return Err(InferFailReason::None);
     }
-    let is_generic = overloads.iter().any(|func| func.contain_tpl());
-    resolve_signature(db, cache, overloads, call_expr, is_generic, args_count)
+    resolve_filtered_overloads(db, cache, overloads, call_expr, args_count)
 }
 
 fn collect_callable_overloads(