[ty] Surface matched overload diagnostic directly

Author: dhruvmanila

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

@@ -48,13 +48,13 @@ The following calls are also invalid, due to incorrect argument types:
 ```py
 class Base: ...
 
-# error: [no-matching-overload] "No overload of class `type` matches arguments"
+# error: [invalid-argument-type] "Argument to class `type` is incorrect: Expected `str`, found `Literal[b"Foo"]`"
 type(b"Foo", (), {})
 
-# error: [no-matching-overload] "No overload of class `type` matches arguments"
+# error: [invalid-argument-type] "Argument to class `type` is incorrect: Expected `tuple[type, ...]`, found `<class 'Base'>`"
 type("Foo", Base, {})
 
-# error: [no-matching-overload] "No overload of class `type` matches arguments"
+# error: [invalid-argument-type] "Argument to class `type` is incorrect: Expected `tuple[type, ...]`, found `tuple[Literal[1], Literal[2]]`"
 type("Foo", (1, 2), {})
 
 # TODO: this should be an error
@@ -90,12 +90,18 @@ str(errors="replace")
 ### Invalid calls
 
 ```py
-str(1, 2)  # error: [no-matching-overload]
-str(o=1)  # error: [no-matching-overload]
+# error: [invalid-argument-type] "Argument to class `str` is incorrect: Expected `bytes | bytearray`, found `Literal[1]`"
+# error: [invalid-argument-type] "Argument to class `str` is incorrect: Expected `str`, found `Literal[2]`"
+str(1, 2)
+
+# error: [no-matching-overload]
+str(o=1)
 
 # First argument is not a bytes-like object:
-str("Müsli", "utf-8")  # error: [no-matching-overload]
+# error: [invalid-argument-type] "Argument to class `str` is incorrect: Expected `bytes | bytearray`, found `Literal["Müsli"]`"
+str("Müsli", "utf-8")
 
 # Second argument is not a valid encoding:
-str(b"M\xc3\xbcsli", b"utf-8")  # error: [no-matching-overload]
+# error: [invalid-argument-type] "Argument to class `str` is incorrect: Expected `str`, found `Literal[b"utf-8"]`"
+str(b"M\xc3\xbcsli", b"utf-8")
 ```

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

@@ -235,7 +235,7 @@ method_wrapper(C(), None)
 method_wrapper(None, C)
 
 # Passing `None` without an `owner` argument is an
-# error: [no-matching-overload] "No overload of method wrapper `__get__` of function `f` matches arguments"
+# error: [invalid-argument-type] "Argument to method wrapper `__get__` of function `f` is incorrect: Expected `~None`, found `None`"
 method_wrapper(None)
 
 # Passing something that is not assignable to `type` as the `owner` argument is an

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

@@ -85,8 +85,7 @@ from overloaded import f
 
 reveal_type(f())  # revealed: None
 
-# TODO: This should be `invalid-argument-type` instead
-# error: [no-matching-overload]
+# error: [invalid-argument-type] "Argument to function `f` is incorrect: Expected `int`, found `Literal["a"]`"
 reveal_type(f("a"))  # revealed: Unknown
 ```
 

crates/ty_python_semantic/resources/mdtest/descriptor_protocol.md

@@ -607,7 +607,7 @@ wrapper_descriptor()
 wrapper_descriptor(f)
 
 # Calling it without the `owner` argument if `instance` is not `None` is an
-# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
+# error: [invalid-argument-type] "Argument to wrapper descriptor `FunctionType.__get__` is incorrect: Expected `~None`, found `None`"
 wrapper_descriptor(f, None)
 
 # But calling it with an instance is fine (in this case, the `owner` argument is optional):

crates/ty_python_semantic/resources/mdtest/narrow/type.md

@@ -78,7 +78,7 @@ No narrowing should occur if `type` is used to dynamically create a class:
 def _(x: str | int):
     # The following diagnostic is valid, since the three-argument form of `type`
     # can only be called with `str` as the first argument.
-    # error: [no-matching-overload] "No overload of class `type` matches arguments"
+    # error: [invalid-argument-type] "Argument to class `type` is incorrect: Expected `str`, found `str | int`"
     if type(x, (), {}) is str:
         reveal_type(x)  # revealed: str | int
     else:

crates/ty_python_semantic/resources/mdtest/snapshots/union_call.md_-_Calling_a_union_of_f…_-_Try_to_cover_all_pos…_-_Cover_non-keyword_re…_(707b284610419a54).snap

@@ -109,21 +109,6 @@ info: rule `missing-argument` is enabled by default
 
 ```
 
-```
-error[no-matching-overload]: No overload of method wrapper `__get__` of function `f` matches arguments
-  --> src/mdtest_snippet.py:48:9
-   |
-46 |     # error: [no-matching-overload]
-47 |     # error: [call-non-callable] "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
-48 |     x = f(3)
-   |         ^^^^
-   |
-info: Union variant `<method-wrapper `__get__` of `f`>` is incompatible with this call site
-info: Attempted to call union type `(def f1() -> int) | (def f2(name: str) -> int) | (def f3(a: int, b: int) -> int) | (def f4(x: T) -> int) | Literal[5] | Unknown | (<method-wrapper `__get__` of `f`>) | PossiblyNotCallable`
-info: rule `no-matching-overload` is enabled by default
-
-```
-
 ```
 error[invalid-argument-type]: Argument to function `f2` is incorrect
   --> src/mdtest_snippet.py:48:11

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

@@ -1013,6 +1013,7 @@ impl<'db> From<Binding<'db>> for Bindings<'db> {
             dunder_call_is_possibly_unbound: false,
             bound_type: None,
             return_type: None,
+            matched_overload_index: None,
             overloads: smallvec![from],
         };
         Bindings {
@@ -1053,12 +1054,20 @@ pub(crate) struct CallableBinding<'db> {
 
     /// The return type of this callable.
     ///
-    /// This is only `Some` if it's an overloaded callable, "argument type expansion" was
-    /// performed, and one of the expansion evaluated successfully for all of the argument lists.
+    /// This is [`Some`] only when all of the following conditions are met:
+    /// - This is an overloaded callable
+    /// - Argument type expansion was performed
+    /// - One of the expansion evaluated successfully for all of the argument lists
+    ///
     /// This type is then the union of all the return types of the matched overloads for the
     /// expanded argument lists.
     return_type: Option<Type<'db>>,
 
+    /// The index of the overload that matched for this callable.
+    ///
+    /// This is [`None`] if the callable is not overloaded, or if no overload matched.
+    matched_overload_index: Option<usize>,
+
     /// The bindings of each overload of this callable. Will be empty if the type is not callable.
     ///
     /// By using `SmallVec`, we avoid an extra heap allocation for the common case of a
@@ -1081,6 +1090,7 @@ impl<'db> CallableBinding<'db> {
             dunder_call_is_possibly_unbound: false,
             bound_type: None,
             return_type: None,
+            matched_overload_index: None,
             overloads,
         }
     }
@@ -1092,6 +1102,7 @@ impl<'db> CallableBinding<'db> {
             dunder_call_is_possibly_unbound: false,
             bound_type: None,
             return_type: None,
+            matched_overload_index: None,
             overloads: smallvec![],
         }
     }
@@ -1142,10 +1153,9 @@ impl<'db> CallableBinding<'db> {
                 return;
             }
             MatchingOverloadIndex::Single(index) => {
-                // If only one candidate overload remains, it is the winning match.
-                // TODO: Evaluate it as a regular (non-overloaded) call. This means that any
-                // diagnostics reported in this check should be reported directly instead of
-                // reporting it as `no-matching-overload`.
+                // If only one candidate overload remains, it is the winning match. Evaluate it as
+                // a regular (non-overloaded) call.
+                self.matched_overload_index = Some(index);
                 self.overloads[index].check_types(
                     db,
                     argument_types.as_ref(),
@@ -1175,8 +1185,9 @@ impl<'db> CallableBinding<'db> {
             MatchingOverloadIndex::None => {
                 // If all overloads result in errors, proceed to step 3.
             }
-            MatchingOverloadIndex::Single(_) => {
+            MatchingOverloadIndex::Single(index) => {
                 // If only one overload evaluates without error, it is the winning match.
+                self.matched_overload_index = Some(index);
                 return;
             }
             MatchingOverloadIndex::Multiple(_) => {
@@ -1356,6 +1367,7 @@ impl<'db> CallableBinding<'db> {
         if let Some(return_type) = self.return_type {
             return return_type;
         }
+        // TODO: Should this now use `self.matched_overload_index`?
         if let Some((_, first_overload)) = self.matching_overloads().next() {
             return first_overload.return_type();
         }
@@ -1418,6 +1430,21 @@ impl<'db> CallableBinding<'db> {
                 // https://github.com/henribru/google-api-python-client-stubs/blob/master/googleapiclient-stubs/discovery.pyi
                 const MAXIMUM_OVERLOADS: usize = 50;
 
+                // If there is a single matching overload, the diagnostics should be reported
+                // directly for that overload.
+                if let Some(matched_overload_index) = self.matched_overload_index {
+                    let callable_description =
+                        CallableDescription::new(context.db(), self.signature_type);
+                    self.overloads[matched_overload_index].report_diagnostics(
+                        context,
+                        node,
+                        self.signature_type,
+                        callable_description.as_ref(),
+                        union_diag,
+                    );
+                    return;
+                }
+
                 let Some(builder) = context.report_lint(&NO_MATCHING_OVERLOAD, node) else {
                     return;
                 };