fix(code-analysis): keep overload returns wide on unknown args

Author: lewis6991

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

@@ -261,6 +261,36 @@ mod test {
         assert_eq!(ws.humanize_type(result_ty), "string");
     }
 
+    #[test]
+    fn test_apply_return_infer_keeps_same_arity_overload_returns_when_tail_is_unknown() {
+        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, y: number): number
+            ---@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!(result_ty, ws.ty("number|string"));
+    }
+
     #[test]
     fn test_union_call_ignores_non_matching_generic_callable_member() {
         let mut ws = VirtualWorkspace::new();

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

@@ -216,8 +216,19 @@ fn infer_callable_return_from_arg_types(
         } else {
             &preferred_overloads
         };
+        let unresolved_arg_match = overloads_to_resolve.len() > 1
+            && call_arg_types
+                .iter()
+                .any(|arg_type| arg_type.is_any() || arg_type.is_unknown());
 
-        member_returns.push(
+        member_returns.push(if unresolved_arg_match {
+            LuaType::from_vec(
+                overloads_to_resolve
+                    .iter()
+                    .map(|callable| callable.get_ret().clone())
+                    .collect(),
+            )
+        } else {
             resolve_signature_by_args(
                 context.db,
                 overloads_to_resolve,
@@ -226,8 +237,8 @@ fn infer_callable_return_from_arg_types(
                 None,
             )
             .map(|callable| callable.get_ret().clone())
-            .unwrap_or_else(|_| fallback_return_from_overloads(context.db, overloads)),
-        );
+            .unwrap_or_else(|_| fallback_return_from_overloads(context.db, overloads))
+        });
     }
     if member_returns.is_empty() {
         return Ok(if fallback_on_no_match {