[ty] Fix Step 5 overload ambiguity for multi-argument calls

Author: charliermarsh

crates/ty_python_semantic/resources/mdtest/call/overloads.md

@@ -880,7 +880,7 @@ from typing_extensions import reveal_type
 def _(a: int | None):
     reveal_type(
         # error: [no-matching-overload]
-        # revealed: Unknown
+        # revealed: Any
         f(
             A(),
             a1=a,
@@ -1231,8 +1231,8 @@ def _(list_int: list[int], list_any: list[Any]):
     # All materializations of `list[Any]` are assignable to `list[int]` and `list[Any]`, but the
     # return type of first and second overloads are not equivalent, so the overload matching
     # is ambiguous.
-    reveal_type(f(list_any))  # revealed: Unknown
-    reveal_type(f(*(list_any,)))  # revealed: Unknown
+    reveal_type(f(list_any))  # revealed: Any
+    reveal_type(f(*(list_any,)))  # revealed: Any
 ```
 
 ### Single tuple argument
@@ -1277,8 +1277,8 @@ def _(int_str: tuple[int, str], int_any: tuple[int, Any], any_any: tuple[Any, An
 
     # All materializations of `tuple[Any, Any]` are assignable to the parameters of all the
     # overloads, but the return types aren't equivalent, so the overload matching is ambiguous
-    reveal_type(f(any_any))  # revealed: Unknown
-    reveal_type(f(*(any_any,)))  # revealed: Unknown
+    reveal_type(f(any_any))  # revealed: Any
+    reveal_type(f(*(any_any,)))  # revealed: Any
 ```
 
 ### `Unknown` passed into an overloaded function annotated with protocols
@@ -1309,15 +1309,15 @@ def f(a: Foo, b: list[str], c: list[LiteralString], e):
     reveal_type(a.join(b))  # revealed: str
     reveal_type(a.join(c))  # revealed: LiteralString
 
-    # since both overloads match and they have return types that are not equivalent,
+    # Since both overloads match and they have return types that are not equivalent,
     # step (5) of the overload evaluation algorithm says we must evaluate the result of the
-    # call as `Unknown`.
+    # call as `Any`.
     #
     # Note: although the spec does not state as such (since intersections in general are not
     # specified currently), `(str | LiteralString) & Unknown` might also be a reasonable type
     # here (the union of all overload returns, intersected with `Unknown`) -- here that would
     # simplify to `str & Unknown`.
-    reveal_type(a.join(e))  # revealed: Unknown
+    reveal_type(a.join(e))  # revealed: Any
 ```
 
 ### Multiple arguments
@@ -1367,8 +1367,8 @@ def _(list_int: list[int], list_any: list[Any], int_str: tuple[int, str], int_an
     # All materializations of first argument is assignable to the second overload and for the second
     # argument, they're assignable to the third overload, so no overloads are filtered out; the
     # return types of the remaining overloads are not equivalent, so overload matching is ambiguous
-    reveal_type(f(list_int, any_any))  # revealed: Unknown
-    reveal_type(f(*(list_int, any_any)))  # revealed: Unknown
+    reveal_type(f(list_int, any_any))  # revealed: Any
+    reveal_type(f(*(list_int, any_any)))  # revealed: Any
 ```
 
 ### `LiteralString` and `str`
@@ -1400,8 +1400,8 @@ def _(literal: LiteralString, string: str, any: Any):
 
     # `Any` matches both overloads, but the return types are not equivalent.
     # Pyright and mypy both reveal `str` here, contrary to the spec.
-    reveal_type(f(any))  # revealed: Unknown
-    reveal_type(f(*(any,)))  # revealed: Unknown
+    reveal_type(f(any))  # revealed: Any
+    reveal_type(f(*(any,)))  # revealed: Any
 ```
 
 ### Generics
@@ -1436,11 +1436,11 @@ def _(list_int: list[int], list_str: list[str], list_any: list[Any], any: Any):
     reveal_type(f(list_str))  # revealed: str
     reveal_type(f(*(list_str,)))  # revealed: str
 
-    reveal_type(f(list_any))  # revealed: Unknown
-    reveal_type(f(*(list_any,)))  # revealed: Unknown
+    reveal_type(f(list_any))  # revealed: Any
+    reveal_type(f(*(list_any,)))  # revealed: Any
 
-    reveal_type(f(any))  # revealed: Unknown
-    reveal_type(f(*(any,)))  # revealed: Unknown
+    reveal_type(f(any))  # revealed: Any
+    reveal_type(f(*(any,)))  # revealed: Any
 ```
 
 ### Generics (multiple arguments)
@@ -1513,7 +1513,45 @@ def _(a_int: A[int], a_str: A[str], a_any: A[Any]):
 def _(b_int: B[int], b_str: B[str], b_any: B[Any]):
     reveal_type(b_int.method())  # revealed: int
     reveal_type(b_str.method())  # revealed: str
-    reveal_type(b_any.method())  # revealed: Unknown
+    reveal_type(b_any.method())  # revealed: Any
+```
+
+### Ambiguous `Any` overloads (multiple arguments)
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+`overloaded.pyi`:
+
+```pyi
+from typing import Any, overload
+
+class A[T]:
+    def get(self) -> T: ...
+
+@overload
+def op(l: A[None], r: A[None]) -> A[None]: ...
+@overload
+def op(l: A[None], r: A[Any]) -> A[None]: ...
+@overload
+def op(l: A[Any], r: A[None]) -> A[None]: ...
+@overload
+def op(l: A[Any], r: A[Any]) -> A[Any]: ...
+```
+
+```py
+from typing import Any, assert_type
+
+from overloaded import A, op
+
+def _(x: A[None], y: A[Any]) -> None:
+    assert_type(op(x, x), A[None])
+    assert_type(op(x, y), A[None])
+    assert_type(op(y, x), A[None])
+    assert_type(op(y, y), Any)
+    reveal_type(op(y, y))  # revealed: Any
 ```
 
 ### Variadic argument
@@ -1557,11 +1595,11 @@ def _(arg: list[Any]):
     # Matches both overload and the return types are equivalent
     reveal_type(f1(*arg))  # revealed: A
     # Matches both overload but the return types aren't equivalent
-    reveal_type(f2(*arg))  # revealed: Unknown
+    reveal_type(f2(*arg))  # revealed: Any
     # Filters out the final overload and the return types are equivalent
     reveal_type(f3(*arg))  # revealed: A
     # Filters out the final overload but the return types aren't equivalent
-    reveal_type(f4(*arg))  # revealed: Unknown
+    reveal_type(f4(*arg))  # revealed: Any
 ```
 
 ### Varidic argument with generics
@@ -1620,15 +1658,15 @@ def _(args1: list[int], args2: list[Any]):
 reveal_type(f2())  # revealed: tuple[Any, ...]
 reveal_type(f2(1, 2))  # revealed: tuple[Literal[1], Literal[2]]
 # TODO: Should be `tuple[Literal[1], Literal[2]]`
-reveal_type(f2(x1=1, x2=2))  # revealed: Unknown
+reveal_type(f2(x1=1, x2=2))  # revealed: Any
 # TODO: Should be `tuple[Literal[2], Literal[1]]`
-reveal_type(f2(x2=1, x1=2))  # revealed: Unknown
+reveal_type(f2(x2=1, x1=2))  # revealed: Any
 reveal_type(f2(1, 2, z=3))  # revealed: tuple[Any, ...]
 
 reveal_type(f3(1, 2))  # revealed: tuple[Literal[1], Literal[2]]
 reveal_type(f3(1, 2, 3))  # revealed: tuple[Any, ...]
 # TODO: Should be `tuple[Literal[1], Literal[2]]`
-reveal_type(f3(x1=1, x2=2))  # revealed: Unknown
+reveal_type(f3(x1=1, x2=2))  # revealed: Any
 reveal_type(f3(z=1))  # revealed: dict[str, Any]
 
 # error: [no-matching-overload]
@@ -1785,8 +1823,8 @@ from typing import Any
 from overloaded import A, B, C, f
 
 def _(arg: tuple[A | B, Any]):
-    reveal_type(f(arg))  # revealed: A | Unknown
-    reveal_type(f(*(arg,)))  # revealed: A | Unknown
+    reveal_type(f(arg))  # revealed: A | Any
+    reveal_type(f(*(arg,)))  # revealed: A | Any
 ```
 
 #### Both argument lists ambiguous
@@ -1819,8 +1857,8 @@ from typing import Any
 from overloaded import A, B, C, f
 
 def _(arg: tuple[A | B, Any]):
-    reveal_type(f(arg))  # revealed: Unknown
-    reveal_type(f(*(arg,)))  # revealed: Unknown
+    reveal_type(f(arg))  # revealed: Any
+    reveal_type(f(*(arg,)))  # revealed: Any
 ```
 
 ### Unknown argument with TypeVar overload
@@ -1850,10 +1888,10 @@ from nonexistent_module import something_unknown  # error: [unresolved-import]
 
 reveal_type(something_unknown)  # revealed: Unknown
 
-# The result should be `Unknown`, not `Literal[b""]`.
-reveal_type(f(something_unknown))  # revealed: Unknown
-reveal_type(f((something_unknown, something_unknown, something_unknown)))  # revealed: Unknown
-reveal_type(f((something_unknown, None, something_unknown)))  # revealed: Unknown
+# The result should be `Any`, not `Literal[b""]`.
+reveal_type(f(something_unknown))  # revealed: Any
+reveal_type(f((something_unknown, something_unknown, something_unknown)))  # revealed: Any
+reveal_type(f((something_unknown, None, something_unknown)))  # revealed: Any
 
 # Concrete arguments should still resolve correctly.
 def _(s: str):

crates/ty_python_semantic/resources/mdtest/snapshots/overloads.md_-_Overloads_-_Argument_type_expans…_-_Optimization___Limit_…_(cd61048adbc17331).snap

@@ -38,7 +38,7 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/call/overloads.md
  4 | def _(a: int | None):
  5 |     reveal_type(
  6 |         # error: [no-matching-overload]
- 7 |         # revealed: Unknown
+ 7 |         # revealed: Any
  8 |         f(
  9 |             A(),
 10 |             a1=a,
@@ -82,7 +82,7 @@ error[no-matching-overload]: No overload of function `f` matches arguments
   --> src/mdtest_snippet.py:8:9
    |
  6 |           # error: [no-matching-overload]
- 7 |           # revealed: Unknown
+ 7 |           # revealed: Any
  8 | /         f(
  9 | |             A(),
 10 | |             a1=a,

crates/ty_python_semantic/resources/mdtest/typed_dict.md

@@ -1361,7 +1361,7 @@ def _(
     reveal_type(person[str_key])  # revealed: Unknown
 
     # No error here:
-    reveal_type(person[unknown_key])  # revealed: Unknown
+    reveal_type(person[unknown_key])  # revealed: Any
 
     reveal_type(being["name"])  # revealed: str
 

crates/ty_python_semantic/src/types/call/bind.rs

@@ -44,7 +44,7 @@ use crate::types::signatures::{Parameter, ParameterForm, ParameterKind, Paramete
 use crate::types::tuple::{TupleLength, TupleSpec, TupleType};
 use crate::types::{
     BoundMethodType, BoundTypeVarIdentity, BoundTypeVarInstance, CallableSignature, CallableType,
-    CallableTypeKind, ClassLiteral, DATACLASS_FLAGS, DataclassFlags, DataclassParams,
+    CallableTypeKind, ClassLiteral, DATACLASS_FLAGS, DataclassFlags, DataclassParams, DynamicType,
     FieldInstance, GenericAlias, InternedConstraintSet, IntersectionType, KnownBoundMethodType,
     KnownClass, KnownInstanceType, LiteralValueTypeKind, MemberLookupPolicy, NominalInstanceType,
     PropertyInstanceType, SpecialFormType, TypeAliasType, TypeContext, TypeVarBoundOrConstraints,
@@ -2557,44 +2557,33 @@ impl<'db> CallableBinding<'db> {
         // unmatched for the given argument types.
         let mut filter_remaining_overloads = false;
 
-        for (upto, current_index) in matching_overload_indexes.iter().enumerate() {
-            if filter_remaining_overloads {
-                self.overloads[*current_index].mark_as_unmatched_overload();
-                continue;
-            }
-
+        // Build a tuple of participating parameter types for a single overload.
+        //
+        // A given participating parameter can receive multiple argument sources (for example,
+        // through variadics), so we union those types for that parameter index.
+        let participating_parameter_tuple_for_overload = |overload: &Binding<'db>| {
             let mut union_parameter_types = std::iter::repeat_with(|| UnionBuilder::new(db))
                 .take(max_parameter_count)
                 .collect::<Vec<_>>();
 
-            // The number of parameters that have been skipped because they don't participate in
-            // the filtering process. This is used to make sure the types are added to the
-            // corresponding parameter index in `union_parameter_types`.
-            let mut skipped_parameters = 0;
-
             for argument_index in 0..arguments.len() {
-                for overload_index in &matching_overload_indexes[..=upto] {
-                    let overload = &self.overloads[*overload_index];
-                    for parameter_index in &overload.argument_matches[argument_index].parameters {
-                        if !participating_parameter_indexes.contains(parameter_index) {
-                            skipped_parameters += 1;
-                            continue;
-                        }
-                        // TODO: For an unannotated `self` / `cls` parameter, the type should be
-                        // `typing.Self` / `type[typing.Self]`
-                        let mut parameter_type =
-                            overload.signature.parameters()[*parameter_index].annotated_type();
-                        if let Some(specialization) = overload.specialization {
-                            parameter_type =
-                                parameter_type.apply_specialization(db, specialization);
-                        }
-                        union_parameter_types[parameter_index.saturating_sub(skipped_parameters)]
-                            .add_in_place(parameter_type);
+                for parameter_index in &overload.argument_matches[argument_index].parameters {
+                    if !participating_parameter_indexes.contains(parameter_index) {
+                        continue;
                     }
+
+                    // TODO: For an unannotated `self` / `cls` parameter, the type should be
+                    // `typing.Self` / `type[typing.Self]`
+                    let mut parameter_type =
+                        overload.signature.parameters()[*parameter_index].annotated_type();
+                    if let Some(specialization) = overload.specialization {
+                        parameter_type = parameter_type.apply_specialization(db, specialization);
+                    }
+                    union_parameter_types[*parameter_index].add_in_place(parameter_type);
                 }
             }
 
-            let parameter_types = Type::heterogeneous_tuple(
+            Type::heterogeneous_tuple(
                 db,
                 union_parameter_types.into_iter().filter_map(|builder| {
                     if builder.is_empty() {
@@ -2603,9 +2592,30 @@ impl<'db> CallableBinding<'db> {
                         Some(builder.build())
                     }
                 }),
+            )
+        };
+
+        for (upto, current_index) in matching_overload_indexes.iter().enumerate() {
+            if filter_remaining_overloads {
+                self.overloads[*current_index].mark_as_unmatched_overload();
+                continue;
+            }
+
+            // Use a union of per-overload parameter tuples rather than a tuple of per-parameter
+            // unions, so we preserve cross-argument correlations from each overload.
+            let parameter_types = UnionType::from_elements(
+                db,
+                matching_overload_indexes[..=upto]
+                    .iter()
+                    .map(|overload_index| {
+                        participating_parameter_tuple_for_overload(&self.overloads[*overload_index])
+                    }),
             );
 
-            if top_materialized_argument_type.is_assignable_to(db, parameter_types) {
+            if top_materialized_argument_type
+                .when_assignable_to(db, parameter_types, InferableTypeVars::None)
+                .is_always_satisfied(db)
+            {
                 filter_remaining_overloads = true;
             }
         }
@@ -2763,7 +2773,7 @@ impl<'db> CallableBinding<'db> {
             return match overload_call_return_type {
                 OverloadCallReturnType::ArgumentTypeExpansion(return_type) => return_type,
                 OverloadCallReturnType::ArgumentTypeExpansionLimitReached(_)
-                | OverloadCallReturnType::Ambiguous => Type::unknown(),
+                | OverloadCallReturnType::Ambiguous => Type::Dynamic(DynamicType::Any),
             };
         }
         if let Some((_, first_overload)) = self.matching_overloads().next() {