[red-knot] Support multiple overloads when binding parameters at call sites

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

@@ -6,7 +6,7 @@
 class NotBool:
     __bool__ = None
 
-# TODO: We should emit an `invalid-argument` error here for `2` because `bool` only takes one argument.
+# error: [too-many-positional-arguments] "Too many positional arguments to class `bool`: expected 1, got 2"
 bool(1, 2)
 
 # TODO: We should emit an `unsupported-bool-conversion` error here because the argument doesn't implement `__bool__` correctly.
@@ -29,9 +29,12 @@ But a three-argument call to type creates a dynamic instance of the `type` class
 reveal_type(type("Foo", (), {}))  # revealed: type
 ```
 
-Other numbers of arguments are invalid (TODO -- these should emit a diagnostic)
+Other numbers of arguments are invalid
 
 ```py
+# error: [no-matching-overload] "No overload of class `type` matches arguments"
 type("Foo", ())
+
+# error: [no-matching-overload] "No overload of class `type` matches arguments"
 type("Foo", (), {}, weird_other_arg=42)
 ```

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

@@ -235,23 +235,23 @@ method_wrapper(C(), None)
 method_wrapper(None, C)
 
 # Passing `None` without an `owner` argument is an
-# error: [missing-argument] "No argument provided for required parameter `owner`"
+# error: [no-matching-overload] "No overload of method wrapper `__get__` of function `f` matches arguments"
 method_wrapper(None)
 
 # Passing something that is not assignable to `type` as the `owner` argument is an
-# error: [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 2 (`owner`) of method wrapper `__get__` of function `f`; expected type `type`"
+# error: [no-matching-overload] "No overload of method wrapper `__get__` of function `f` matches arguments"
 method_wrapper(None, 1)
 
 # Passing `None` as the `owner` argument when `instance` is `None` is an
-# error: [invalid-argument-type] "Object of type `None` cannot be assigned to parameter 2 (`owner`) of method wrapper `__get__` of function `f`; expected type `type`"
+# error: [no-matching-overload] "No overload of method wrapper `__get__` of function `f` matches arguments"
 method_wrapper(None, None)
 
 # Calling `__get__` without any arguments is an
-# error: [missing-argument] "No argument provided for required parameter `instance`"
+# error: [no-matching-overload] "No overload of method wrapper `__get__` of function `f` matches arguments"
 method_wrapper()
 
 # Calling `__get__` with too many positional arguments is an
-# error: [too-many-positional-arguments] "Too many positional arguments to method wrapper `__get__` of function `f`: expected 2, got 3"
+# error: [no-matching-overload] "No overload of method wrapper `__get__` of function `f` matches arguments"
 method_wrapper(C(), C, "one too many")
 ```
 

crates/red_knot_python_semantic/resources/mdtest/descriptor_protocol.md

@@ -710,30 +710,30 @@ Finally, we test some error cases for the call to the wrapper descriptor:
 
 ```py
 # Calling the wrapper descriptor without any arguments is an
-# error: [missing-argument] "No arguments provided for required parameters `self`, `instance`"
+# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
 wrapper_descriptor()
 
 # Calling it without the `instance` argument is an also an
-# error: [missing-argument] "No argument provided for required parameter `instance`"
+# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
 wrapper_descriptor(f)
 
 # Calling it without the `owner` argument if `instance` is not `None` is an
-# error: [missing-argument] "No argument provided for required parameter `owner`"
+# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
 wrapper_descriptor(f, None)
 
 # But calling it with an instance is fine (in this case, the `owner` argument is optional):
 wrapper_descriptor(f, C())
 
 # Calling it with something that is not a `FunctionType` as the first argument is an
-# error: [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 1 (`self`) of wrapper descriptor `FunctionType.__get__`; expected type `FunctionType`"
+# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
 wrapper_descriptor(1, None, type(f))
 
 # Calling it with something that is not a `type` as the `owner` argument is an
-# error: [invalid-argument-type] "Object of type `Literal[f]` cannot be assigned to parameter 3 (`owner`) of wrapper descriptor `FunctionType.__get__`; expected type `type`"
+# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
 wrapper_descriptor(f, None, f)
 
 # Calling it with too many positional arguments is an
-# error: [too-many-positional-arguments] "Too many positional arguments to wrapper descriptor `FunctionType.__get__`: expected 3, got 4"
+# error: [no-matching-overload] "No overload of wrapper descriptor `FunctionType.__get__` matches arguments"
 wrapper_descriptor(f, None, type(f), "one too many")
 ```
 

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

@@ -0,0 +1,14 @@
+# No matching overload diagnostics
+
+<!-- snapshot-diagnostics -->
+
+## Calls to overloaded functions
+
+TODO: Note that we do not yet support the `@overload` decorator to define overloaded functions in
+real Python code. We are instead testing a special-cased function where we create an overloaded
+signature internally. Update this to an `@overload` function in the Python snippet itself once we
+can.
+
+```py
+type("Foo", ())  # error: [no-matching-overload]
+```

crates/red_knot_python_semantic/resources/mdtest/narrow/bool-call.md

@@ -22,11 +22,13 @@ def _(flag: bool):
 
     # invalid invocation, too many positional args
     reveal_type(x)  # revealed: Literal[1] | None
-    if bool(x is not None, 5):  # TODO diagnostic
+    # error: [too-many-positional-arguments] "Too many positional arguments to class `bool`: expected 1, got 2"
+    if bool(x is not None, 5):
         reveal_type(x)  # revealed: Literal[1] | None
 
     # invalid invocation, too many kwargs
     reveal_type(x)  # revealed: Literal[1] | None
-    if bool(x is not None, y=5):  # TODO diagnostic
+    # error: [unknown-argument] "Argument `y` does not match any known parameter of class `bool`"
+    if bool(x is not None, y=5):
         reveal_type(x)  # revealed: Literal[1] | None
 ```

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

@@ -88,7 +88,7 @@ def _(x: str | int):
 
 ```py
 def _(x: str | int):
-    # TODO: we could issue a diagnostic here
+    # error: [no-matching-overload] "No overload of class `type` matches arguments"
     if type(object=x) is str:
         reveal_type(x)  # revealed: str | int
 ```

crates/red_knot_python_semantic/resources/mdtest/snapshots/no_matching_overload.md_-_No_matching_overload_diagnostics_-_Calls_to_overloaded_functions.snap

@@ -0,0 +1,28 @@
+---
+source: crates/red_knot_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: no_matching_overload.md - No matching overload diagnostics - Calls to overloaded functions
+mdtest path: crates/red_knot_python_semantic/resources/mdtest/diagnostics/no_matching_overload.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+1 | type("Foo", ())  # error: [no-matching-overload]
+```
+
+# Diagnostics
+
+```
+error: lint:no-matching-overload
+ --> /src/mdtest_snippet.py:1:1
+  |
+1 | type("Foo", ())  # error: [no-matching-overload]
+  | ^^^^^^^^^^^^^^^ No overload of class `type` matches arguments
+  |
+
+```