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.

Author: BurntSushi

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

@@ -37,6 +37,33 @@ error[no-matching-overload]: No overload of function `f` matches arguments
 12 | f(b"foo")  # error: [no-matching-overload]
    | ^^^^^^^^^
    |
+info: Unmatched overload defined here
+ --> src/mdtest_snippet.py:4:5
+  |
+3 | @overload
+4 | def f(x: int) -> int: ...
+  |     ^
+5 |
+6 | @overload
+  |
+info: Unmatched overload defined here
+ --> src/mdtest_snippet.py:7:5
+  |
+6 | @overload
+7 | def f(x: str) -> str: ...
+  |     ^
+8 |
+9 | def f(x: int | str) -> int | str:
+  |
+info: Overload implementation defined here
+  --> src/mdtest_snippet.py:9:5
+   |
+ 7 | def f(x: str) -> str: ...
+ 8 |
+ 9 | def f(x: int | str) -> int | str:
+   |     ^
+10 |     return x
+   |
 info: rule `no-matching-overload` is enabled by default
 
 ```

crates/ty_python_semantic/src/types.rs

@@ -6913,7 +6913,7 @@ impl<'db> FunctionType<'db> {
     ///
     /// An example of a good use case is to improve
     /// a diagnostic.
-    fn return_type_span(&self, db: &'db dyn Db) -> Option<(Span, Span)> {
+    fn return_type_span(self, db: &'db dyn Db) -> Option<(Span, Span)> {
         let function_scope = self.body_scope(db);
         let span = Span::from(function_scope.file(db));
         let node = function_scope.node(db);
@@ -6948,7 +6948,7 @@ impl<'db> FunctionType<'db> {
     /// An example of a good use case is to improve
     /// a diagnostic.
     fn parameter_span(
-        &self,
+        self,
         db: &'db dyn Db,
         parameter_index: Option<usize>,
     ) -> Option<(Span, Span)> {

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

@@ -1113,6 +1113,35 @@ impl<'db> CallableBinding<'db> {
                         String::new()
                     }
                 ));
+                if let Some(overloaded_types) = self
+                    .signature_type
+                    .into_function_literal()
+                    .and_then(|funty| funty.to_overloaded(context.db()))
+                {
+                    for overload_type in &overloaded_types.overloads {
+                        if let Some((name_span, _)) =
+                            overload_type.parameter_span(context.db(), None)
+                        {
+                            let mut sub = SubDiagnostic::new(
+                                Severity::Info,
+                                "Unmatched overload defined here",
+                            );
+                            sub.annotate(Annotation::primary(name_span));
+                            diag.sub(sub);
+                        }
+                    }
+                    if let Some((name_span, _)) = overloaded_types
+                        .implementation
+                        .and_then(|funty| funty.parameter_span(context.db(), None))
+                    {
+                        let mut sub = SubDiagnostic::new(
+                            Severity::Info,
+                            "Overload implementation defined here",
+                        );
+                        sub.annotate(Annotation::primary(name_span));
+                        diag.sub(sub);
+                    }
+                }
                 if let Some(union_diag) = union_diag {
                     union_diag.add_union_context(context.db(), &mut diag);
                 }