Initial tests

Author: dhruvmanila

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

@@ -399,3 +399,142 @@ def _(x: SomeEnum):
     # TODO: This should be `A | B | C` once enums are supported and are expanded
     reveal_type(f(x))  # revealed: A
 ```
+
+## Filtering overloads with variadic arguments and parameters
+
+TODO
+
+## Filtering based on `Any` / `Unknown`
+
+This is the step 5 of the overload call evluation algorithm which specifies that:
+
+> For all arguments, determine whether all possible materializations of the argument’s type are
+> assignable to the corresponding parameter type for each of the remaining overloads. If so,
+> eliminate all of the subsequent remaining overloads.
+
+This is only performed if the previous step resulted in more than one matching overload.
+
+### Single list argument
+
+`overloaded.pyi`:
+
+```pyi
+from typing import Any, overload
+
+@overload
+def f(x: list[int]) -> int: ...
+@overload
+def f(x: list[Any]) -> int: ...
+@overload
+def f(x: Any) -> str: ...
+```
+
+For the above definition, anything other than `list` should match the last overload:
+
+```py
+from typing import Any
+
+from overloaded import f
+
+# Anything other than `list` should match the last overload
+reveal_type(f(1))  # revealed: str
+
+def _(list_int: list[int], list_any: list[Any]):
+    reveal_type(f(list_int))  # revealed: int
+    reveal_type(f(list_any))  # revealed: int
+```
+
+### Single list argument (ambiguous)
+
+The overload definition is the same as above, but the return type of the second overload is changed
+to `str` to make the overload matching ambiguous if the argument is a `list[Any]`.
+
+`overloaded.pyi`:
+
+```pyi
+from typing import Any, overload
+
+@overload
+def f(x: list[int]) -> int: ...
+@overload
+def f(x: list[Any]) -> str: ...
+@overload
+def f(x: Any) -> str: ...
+```
+
+```py
+from typing import Any
+
+from overloaded import f
+
+# Anything other than `list` should match the last overload
+reveal_type(f(1))  # revealed: str
+
+def _(list_int: list[int], list_any: list[Any]):
+    # All materializations of `list[int]` are assignable to `list[int]`, so it matches the first
+    # overload.
+    reveal_type(f(list_int))  # revealed: int
+
+    # 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: Any
+```
+
+### Single tuple argument
+
+`overloaded.pyi`:
+
+```pyi
+from typing import Any, overload
+
+@overload
+def f(x: tuple[int, str]) -> int: ...
+@overload
+def f(x: tuple[int, Any]) -> int: ...
+@overload
+def f(x: Any) -> str: ...
+```
+
+```py
+from typing import Any
+
+from overloaded import f
+
+reveal_type(f("a"))  # revealed: str
+reveal_type(f((1, "b")))  # revealed: int
+reveal_type(f((1, 2)))  # revealed: int
+
+def _(int_str: tuple[int, str], int_any: tuple[int, Any], any_any: tuple[Any, Any]):
+    reveal_type(f(int_str))  # revealed: int
+    reveal_type(f(int_any))  # revealed: int
+
+    # 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: Any
+```
+
+### Multiple arguments
+
+`overloaded.pyi`:
+
+```pyi
+from typing import Any, overload
+
+class A: ...
+class B: ...
+class C: ...
+class D: ...
+
+```
+
+### Multiple arguments (ambiguous)
+
+TODO:
+
+- Starred arguments
+- Generics
+- Multiple arguments where one of them is `Any` or `Unknown`
+- Combined with argument type expansion
+- Overloaded method (`self`)
+- Overloaded class method (`cls`)