ty_python_semantic: improve failed overloaded function call

The diagnostic now includes a pointer to the implementation definition
along with each possible overload.

This doesn't include information about *why* each overload failed. But
given the emphasis on concise output (since there can be *many*
unmatched overloads), it's not totally clear how to include that
additional information.

Fixes #274

Author: BurntSushi

crates/ty_python_semantic/resources/mdtest/diagnostics/no_matching_overload.md

@@ -16,3 +16,128 @@ def f(x: int | str) -> int | str:
 
 f(b"foo")  # error: [no-matching-overload]
 ```
+
+## Call to function with many unmatched overloads
+
+Note that it would be fine to use `pow` here as an example of a routine with many overloads, but at
+time of writing (2025-05-14), ty doesn't support some of the type signatures of those overloads.
+Which in turn makes snapshotting a bit annoying, since the output can depend on how ty is compiled
+(because of how `Todo` types are dealt with when `debug_assertions` is enabled versus disabled).
+
+```py
+from typing import overload
+
+class Foo: ...
+
+@overload
+def foo(a: int, b: int, c: int): ...
+@overload
+def foo(a: str, b: int, c: int): ...
+@overload
+def foo(a: int, b: str, c: int): ...
+@overload
+def foo(a: int, b: int, c: str): ...
+@overload
+def foo(a: str, b: str, c: int): ...
+@overload
+def foo(a: int, b: str, c: str): ...
+@overload
+def foo(a: str, b: str, c: str): ...
+@overload
+def foo(a: int, b: int, c: int): ...
+@overload
+def foo(a: float, b: int, c: int): ...
+@overload
+def foo(a: int, b: float, c: int): ...
+@overload
+def foo(a: int, b: int, c: float): ...
+@overload
+def foo(a: float, b: float, c: int): ...
+@overload
+def foo(a: int, b: float, c: float): ...
+@overload
+def foo(a: float, b: float, c: float): ...
+@overload
+def foo(a: str, b: str, c: str): ...
+@overload
+def foo(a: float, b: str, c: str): ...
+@overload
+def foo(a: str, b: float, c: str): ...
+@overload
+def foo(a: str, b: str, c: float): ...
+@overload
+def foo(a: float, b: float, c: str): ...
+@overload
+def foo(a: str, b: float, c: float): ...
+@overload
+def foo(a: float, b: float, c: float): ...
+def foo(a, b, c): ...
+
+foo(Foo(), Foo())  # error: [no-matching-overload]
+```
+
+## Calls to overloaded functions with lots of parameters
+
+```py
+from typing import overload
+
+@overload
+def f(
+    lion: int,
+    turtle: int,
+    tortoise: int,
+    goat: int,
+    capybara: int,
+    chicken: int,
+    ostrich: int,
+    gorilla: int,
+    giraffe: int,
+    condor: int,
+    kangaroo: int,
+    anaconda: int,
+    tarantula: int,
+    millipede: int,
+    leopard: int,
+    hyena: int,
+) -> int: ...
+@overload
+def f(
+    lion: str,
+    turtle: str,
+    tortoise: str,
+    goat: str,
+    capybara: str,
+    chicken: str,
+    ostrich: str,
+    gorilla: str,
+    giraffe: str,
+    condor: str,
+    kangaroo: str,
+    anaconda: str,
+    tarantula: str,
+    millipede: str,
+    leopard: str,
+    hyena: str,
+) -> str: ...
+def f(
+    lion: int | str,
+    turtle: int | str,
+    tortoise: int | str,
+    goat: int | str,
+    capybara: int | str,
+    chicken: int | str,
+    ostrict: int | str,
+    gorilla: int | str,
+    giraffe: int | str,
+    condor: int | str,
+    kangaroo: int | str,
+    anaconda: int | str,
+    tarantula: int | str,
+    millipede: int | str,
+    leopard: int | str,
+    hyena: int | str,
+) -> int | str:
+    return 0
+
+f(b"foo")  # error: [no-matching-overload]
+```

crates/ty_python_semantic/resources/mdtest/snapshots/no_matching_overload…_-_No_matching_overload…_-_Call_to_function_wit…_(dd80c593d9136f35).snap

@@ -0,0 +1,120 @@
+---
+source: crates/ty_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: no_matching_overload.md - No matching overload diagnostics - Call to function with many unmatched overloads
+mdtest path: crates/ty_python_semantic/resources/mdtest/diagnostics/no_matching_overload.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+ 1 | from typing import overload
+ 2 | 
+ 3 | class Foo: ...
+ 4 | 
+ 5 | @overload
+ 6 | def foo(a: int, b: int, c: int): ...
+ 7 | @overload
+ 8 | def foo(a: str, b: int, c: int): ...
+ 9 | @overload
+10 | def foo(a: int, b: str, c: int): ...
+11 | @overload
+12 | def foo(a: int, b: int, c: str): ...
+13 | @overload
+14 | def foo(a: str, b: str, c: int): ...
+15 | @overload
+16 | def foo(a: int, b: str, c: str): ...
+17 | @overload
+18 | def foo(a: str, b: str, c: str): ...
+19 | @overload
+20 | def foo(a: int, b: int, c: int): ...
+21 | @overload
+22 | def foo(a: float, b: int, c: int): ...
+23 | @overload
+24 | def foo(a: int, b: float, c: int): ...
+25 | @overload
+26 | def foo(a: int, b: int, c: float): ...
+27 | @overload
+28 | def foo(a: float, b: float, c: int): ...
+29 | @overload
+30 | def foo(a: int, b: float, c: float): ...
+31 | @overload
+32 | def foo(a: float, b: float, c: float): ...
+33 | @overload
+34 | def foo(a: str, b: str, c: str): ...
+35 | @overload
+36 | def foo(a: float, b: str, c: str): ...
+37 | @overload
+38 | def foo(a: str, b: float, c: str): ...
+39 | @overload
+40 | def foo(a: str, b: str, c: float): ...
+41 | @overload
+42 | def foo(a: float, b: float, c: str): ...
+43 | @overload
+44 | def foo(a: str, b: float, c: float): ...
+45 | @overload
+46 | def foo(a: float, b: float, c: float): ...
+47 | def foo(a, b, c): ...
+48 | 
+49 | foo(Foo(), Foo())  # error: [no-matching-overload]
+```
+
+# Diagnostics
+
+```
+error[no-matching-overload]: No overload of function `foo` matches arguments
+  --> src/mdtest_snippet.py:49:1
+   |
+47 | def foo(a, b, c): ...
+48 |
+49 | foo(Foo(), Foo())  # error: [no-matching-overload]
+   | ^^^^^^^^^^^^^^^^^
+   |
+info: First overload defined here
+ --> src/mdtest_snippet.py:6:8
+  |
+5 | @overload
+6 | def foo(a: int, b: int, c: int): ...
+  |        ^^^^^^^^^^^^^^^^^^^^^^^^
+7 | @overload
+8 | def foo(a: str, b: int, c: int): ...
+  |
+info: Possible overloads for function `foo`:
+info:   (a: int, b: int, c: int) -> Unknown
+info:   (a: str, b: int, c: int) -> Unknown
+info:   (a: int, b: str, c: int) -> Unknown
+info:   (a: int, b: int, c: str) -> Unknown
+info:   (a: str, b: str, c: int) -> Unknown
+info:   (a: int, b: str, c: str) -> Unknown
+info:   (a: str, b: str, c: str) -> Unknown
+info:   (a: int, b: int, c: int) -> Unknown
+info:   (a: int | float, b: int, c: int) -> Unknown
+info:   (a: int, b: int | float, c: int) -> Unknown
+info:   (a: int, b: int, c: int | float) -> Unknown
+info:   (a: int | float, b: int | float, c: int) -> Unknown
+info:   (a: int, b: int | float, c: int | float) -> Unknown
+info:   (a: int | float, b: int | float, c: int | float) -> Unknown
+info:   (a: str, b: str, c: str) -> Unknown
+info:   (a: int | float, b: str, c: str) -> Unknown
+info:   (a: str, b: int | float, c: str) -> Unknown
+info:   (a: str, b: str, c: int | float) -> Unknown
+info:   (a: int | float, b: int | float, c: str) -> Unknown
+info:   (a: str, b: int | float, c: int | float) -> Unknown
+info:   (a: int | float, b: int | float, c: int | float) -> Unknown
+info: Overload implementation defined here
+  --> src/mdtest_snippet.py:47:8
+   |
+45 | @overload
+46 | def foo(a: float, b: float, c: float): ...
+47 | def foo(a, b, c): ...
+   |        ^^^^^^^^^
+48 |
+49 | foo(Foo(), Foo())  # error: [no-matching-overload]
+   |
+info: rule `no-matching-overload` is enabled by default
+
+```

crates/ty_python_semantic/resources/mdtest/snapshots/no_matching_overload…_-_No_matching_overload…_-_Calls_to_overloaded_…_(3553d085684e16a0).snap

@@ -16,27 +16,46 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/diagnostics/no_matching_
  2 | 
  3 | @overload
  4 | def f(x: int) -> int: ...
- 5 | 
- 6 | @overload
- 7 | def f(x: str) -> str: ...
- 8 | 
- 9 | def f(x: int | str) -> int | str:
-10 |     return x
-11 | 
-12 | f(b"foo")  # error: [no-matching-overload]
+ 5 | @overload
+ 6 | def f(x: str) -> str: ...
+ 7 | def f(x: int | str) -> int | str:
+ 8 |     return x
+ 9 | 
+10 | f(b"foo")  # error: [no-matching-overload]
 ```
 
 # Diagnostics
 
 ```
 error[no-matching-overload]: No overload of function `f` matches arguments
-  --> src/mdtest_snippet.py:12:1
+  --> src/mdtest_snippet.py:10:1
    |
-10 |     return x
-11 |
-12 | f(b"foo")  # error: [no-matching-overload]
+ 8 |     return x
+ 9 |
+10 | f(b"foo")  # error: [no-matching-overload]
    | ^^^^^^^^^
    |
+info: First overload defined here
+ --> src/mdtest_snippet.py:4:6
+  |
+3 | @overload
+4 | def f(x: int) -> int: ...
+  |      ^^^^^^^^
+5 | @overload
+6 | def f(x: str) -> str: ...
+  |
+info: Possible overloads for function `f`:
+info:   (x: int) -> int
+info:   (x: str) -> str
+info: Overload implementation defined here
+ --> src/mdtest_snippet.py:7:6
+  |
+5 | @overload
+6 | def f(x: str) -> str: ...
+7 | def f(x: int | str) -> int | str:
+  |      ^^^^^^^^^^^^^^
+8 |     return x
+  |
 info: rule `no-matching-overload` is enabled by default
 
 ```