[ty] Surface matched overload diagnostics 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
 ```
 
@@ -400,6 +399,43 @@ def _(x: SomeEnum):
     reveal_type(f(x))  # revealed: A
 ```
 
+### No matching overloads
+
+> If argument expansion has been applied to all arguments and one or more of the expanded argument
+> lists cannot be evaluated successfully, generate an error and stop.
+
+`overloaded.pyi`:
+
+```pyi
+from typing import overload
+
+class A: ...
+class B: ...
+class C: ...
+class D: ...
+
+@overload
+def f(x: A) -> A: ...
+@overload
+def f(x: B) -> B: ...
+```
+
+```py
+from overloaded import A, B, C, D, f
+
+def _(ab: A | B, ac: A | C, cd: C | D):
+    reveal_type(f(ab))  # revealed: A | B
+
+    # The `[A | C]` argument list is expanded to `[A], [C]` where the first list matches the first
+    # overload while the second list doesn't match any of the overloads, so we generate an
+    # error: [no-matching-overload] "No overload of function `f` matches arguments"
+    reveal_type(f(ac))  # revealed: Unknown
+
+    # None of the expanded argument lists (`[C], [D]`) match any of the overloads, so we generate an
+    # error: [no-matching-overload] "No overload of function `f` matches arguments"
+    reveal_type(f(cd))  # revealed: Unknown
+```
+
 ## Filtering overloads with variadic arguments and parameters
 
 TODO

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/diagnostics/union_call.md

@@ -103,7 +103,6 @@ def _(n: int):
     # error: [missing-argument]
     # error: [invalid-argument-type] "Argument to function `f4` is incorrect: Argument type `Literal[3]` does not satisfy upper bound of type variable `T`"
     # error: [call-non-callable] "Object of type `Literal[5]` is not callable"
-    # error: [no-matching-overload]
     # error: [call-non-callable] "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
     x = f(3)
 ```

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

@@ -57,20 +57,19 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/diagnostics/union_call.m
 43 |     # error: [missing-argument]
 44 |     # error: [invalid-argument-type] "Argument to function `f4` is incorrect: Argument type `Literal[3]` does not satisfy upper bound of type variable `T`"
 45 |     # error: [call-non-callable] "Object of type `Literal[5]` is not callable"
-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)
+46 |     # error: [call-non-callable] "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
+47 |     x = f(3)
 ```
 
 # Diagnostics
 
 ```
 error[call-non-callable]: Object of type `Literal[5]` is not callable
-  --> src/mdtest_snippet.py:48:9
+  --> src/mdtest_snippet.py:47: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)
+45 |     # error: [call-non-callable] "Object of type `Literal[5]` is not callable"
+46 |     # error: [call-non-callable] "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
+47 |     x = f(3)
    |         ^^^^
    |
 info: Union variant `Literal[5]` is incompatible with this call site
@@ -81,11 +80,11 @@ info: rule `call-non-callable` is enabled by default
 
 ```
 error[call-non-callable]: Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)
-  --> src/mdtest_snippet.py:48:9
+  --> src/mdtest_snippet.py:47: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)
+45 |     # error: [call-non-callable] "Object of type `Literal[5]` is not callable"
+46 |     # error: [call-non-callable] "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
+47 |     x = f(3)
    |         ^^^^
    |
 info: Union variant `PossiblyNotCallable` is incompatible with this call site
@@ -96,11 +95,11 @@ info: rule `call-non-callable` is enabled by default
 
 ```
 error[missing-argument]: No argument provided for required parameter `b` of function `f3`
-  --> src/mdtest_snippet.py:48:9
+  --> src/mdtest_snippet.py:47: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)
+45 |     # error: [call-non-callable] "Object of type `Literal[5]` is not callable"
+46 |     # error: [call-non-callable] "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
+47 |     x = f(3)
    |         ^^^^
    |
 info: Union variant `def f3(a: int, b: int) -> int` is incompatible with this call site
@@ -109,28 +108,13 @@ 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
+  --> src/mdtest_snippet.py:47:11
    |
-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)
+45 |     # error: [call-non-callable] "Object of type `Literal[5]` is not callable"
+46 |     # error: [call-non-callable] "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
+47 |     x = f(3)
    |           ^ Expected `str`, found `Literal[3]`
    |
 info: Function defined here
@@ -150,11 +134,11 @@ info: rule `invalid-argument-type` is enabled by default
 
 ```
 error[invalid-argument-type]: Argument to function `f4` is incorrect
-  --> src/mdtest_snippet.py:48:11
+  --> src/mdtest_snippet.py:47:11
    |
-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)
+45 |     # error: [call-non-callable] "Object of type `Literal[5]` is not callable"
+46 |     # error: [call-non-callable] "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
+47 |     x = f(3)
    |           ^ Argument type `Literal[3]` does not satisfy upper bound of type variable `T`
    |
 info: Type variable defined here
@@ -174,11 +158,11 @@ info: rule `invalid-argument-type` is enabled by default
 
 ```
 error[too-many-positional-arguments]: Too many positional arguments to function `f1`: expected 0, got 1
-  --> src/mdtest_snippet.py:48:11
+  --> src/mdtest_snippet.py:47:11
    |
-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)
+45 |     # error: [call-non-callable] "Object of type `Literal[5]` is not callable"
+46 |     # error: [call-non-callable] "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
+47 |     x = f(3)
    |           ^
    |
 info: Union variant `def f1() -> int` is incompatible with this call site

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

@@ -1032,6 +1032,7 @@ impl<'db> From<Binding<'db>> for Bindings<'db> {
             dunder_call_is_possibly_unbound: false,
             bound_type: None,
             overload_call_return_type: None,
+            matched_overload_index: None,
             overloads: smallvec![from],
         };
         Bindings {
@@ -1086,6 +1087,13 @@ pub(crate) struct CallableBinding<'db> {
     /// [`Unknown`]: crate::types::DynamicType::Unknown
     overload_call_return_type: Option<OverloadCallReturnType<'db>>,
 
+    /// The index of the overload that matched for this overloaded callable.
+    ///
+    /// This is [`Some`] only if step 1 and 4 of the [overload call evaluation algorithm][1].
+    ///
+    /// [1]: https://typing.python.org/en/latest/spec/overload.html#overload-call-evaluation
+    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
@@ -1108,6 +1116,7 @@ impl<'db> CallableBinding<'db> {
             dunder_call_is_possibly_unbound: false,
             bound_type: None,
             overload_call_return_type: None,
+            matched_overload_index: None,
             overloads,
         }
     }
@@ -1119,6 +1128,7 @@ impl<'db> CallableBinding<'db> {
             dunder_call_is_possibly_unbound: false,
             bound_type: None,
             overload_call_return_type: None,
+            matched_overload_index: None,
             overloads: smallvec![],
         }
     }
@@ -1169,10 +1179,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(),
@@ -1595,6 +1604,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;
                 };