merge kwargs without suggestions into one error line

Author: KevinRK29

mypy/messages.py

@@ -1117,48 +1117,78 @@ def no_variant_matches_arguments(
                             unexpected_kwargs.append((arg_name, arg_types[i]))
 
         if unexpected_kwargs:
+            all_kwargs_confident = True
+            kwargs_with_suggestions: list[tuple[str, list[str]]] = []
+            kwargs_without_suggestions: list[str] = []
+
+            # Find suggestions for each unexpected kwarg, prioritizing type-matching args
             for kwarg_name, kwarg_type in unexpected_kwargs:
                 matching_type_args: list[str] = []
                 not_matching_type_args: list[str] = []
-                matching_variant: CallableType | None = None
+                has_matching_variant = False
 
                 for item in overload.items:
-                    has_type_match = False
+                    item_has_type_match = False
                     for i, formal_type in enumerate(item.arg_types):
                         formal_name = item.arg_names[i]
                         if formal_name is not None and item.arg_kinds[i] != ARG_STAR:
                             if is_subtype(kwarg_type, formal_type):
                                 if formal_name not in matching_type_args:
                                     matching_type_args.append(formal_name)
-                                has_type_match = True
-                            else:
-                                if formal_name not in not_matching_type_args:
-                                    not_matching_type_args.append(formal_name)
-                    if has_type_match and matching_variant is None:
-                        matching_variant = item
+                                item_has_type_match = True
+                            elif formal_name not in not_matching_type_args:
+                                not_matching_type_args.append(formal_name)
+                    if item_has_type_match:
+                        has_matching_variant = True
 
                 matches = best_matches(kwarg_name, matching_type_args, n=3)
                 if not matches:
                     matches = best_matches(kwarg_name, not_matching_type_args, n=3)
 
-                msg = f'Unexpected keyword argument "{kwarg_name}"' + for_func
-
                 if matches:
-                    msg += f"; did you mean {pretty_seq(matches, 'or')}?"
-                self.fail(msg, context, code=code)
+                    kwargs_with_suggestions.append((kwarg_name, matches))
+                else:
+                    kwargs_without_suggestions.append(kwarg_name)
 
-                if matching_variant is None:
-                    self.note(
-                        f"Possible overload variant{plural_s(len(overload.items))}:",
+                if not has_matching_variant:
+                    all_kwargs_confident = False
+
+            for kwarg_name, matches in kwargs_with_suggestions:
+                self.fail(
+                    f'Unexpected keyword argument "{kwarg_name}"'
+                    f"{for_func}; did you mean {pretty_seq(matches, 'or')}?",
+                    context,
+                    code=code,
+                )
+
+            if kwargs_without_suggestions:
+                if len(kwargs_without_suggestions) == 1:
+                    self.fail(
+                        f'Unexpected keyword argument "{kwargs_without_suggestions[0]}"{for_func}',
+                        context,
+                        code=code,
+                    )
+                else:
+                    quoted_names = ", ".join(f'"{n}"' for n in kwargs_without_suggestions)
+                    self.fail(
+                        f"Unexpected keyword arguments {quoted_names}{for_func}",
                         context,
                         code=code,
                     )
-                    for item in overload.items:
-                        self.note(
-                            pretty_callable(item, self.options), context, offset=4, code=code
-                        )
 
-            return
+            if not all_kwargs_confident:
+                self.note(
+                    f"Possible overload variant{plural_s(len(overload.items))}:",
+                    context,
+                    code=code,
+                )
+                for item in overload.items:
+                    self.note(
+                        pretty_callable(item, self.options), context, offset=4, code=code
+                    )
+
+            if all_kwargs_confident and len(unexpected_kwargs) == len(arg_types):
+                return
 
         arg_types_str = ", ".join(format_type(arg, self.options) for arg in arg_types)
         num_args = len(arg_types)

test-data/unit/check-expressions.test

@@ -2571,19 +2571,23 @@ def f(foobar: int) -> None: ...
 @overload
 def f(foobar: str) -> None: ...
 
-def f(foobar: Union[int, str]) -> None:
-    pass
+def f(foobar: Union[int, str]) -> None: pass
 
 f(fobar=1) # E: Unexpected keyword argument "fobar" for overloaded function "f"; did you mean "foobar"?
 f(random=[1,2,3]) # E: Unexpected keyword argument "random" for overloaded function "f" \
                   # N: Possible overload variants: \
                   # N:     def f(foobar: int) -> None \
-                  # N:     def f(foobar: str) -> None
+                  # N:     def f(foobar: str) -> None \
+                  # E: No overload variant of "f" matches argument type "list[int]"
 
 f(fobar=1, baz=2) # E: Unexpected keyword argument "fobar" for overloaded function "f"; did you mean "foobar"? \
                   # E: Unexpected keyword argument "baz" for overloaded function "f"
 
-f(foobar=1, invalid=2) # E: Unexpected keyword argument "invalid" for overloaded function "f"
+f(foobar=1, a=2, b=3, c=4, d=5, e=6) # E: Unexpected keyword arguments "a", "b", "c", "d", "e" for overloaded function "f" \
+                                     # E: No overload variant of "f" matches argument types "int", "int", "int", "int", "int", "int" \
+                                     # N: Possible overload variants: \
+                                     # N:     def f(foobar: int) -> None \
+                                     # N:     def f(foobar: str) -> None
 
 @overload
 def g(x: int, y: int) -> int: ...
@@ -2594,5 +2598,26 @@ def g(x: str, y: str) -> str: ...
 def g(x: Union[int, str], y: Union[int, str]) -> Union[int, str]:
     return x
 
-g([1, 2], z=3) # E: Unexpected keyword argument "z" for overloaded function "g"
+f(fobar=1, other=[1,2,3]) # E: Unexpected keyword argument "fobar" for overloaded function "f"; did you mean "foobar"? \
+                          # E: Unexpected keyword argument "other" for overloaded function "f" \
+                          # N: Possible overload variants: \
+                          # N:     def f(foobar: int) -> None \
+                          # N:     def f(foobar: str) -> None \
+                          # E: No overload variant of "f" matches argument types "int", "list[int]"
+
+g([1, 2], 3) # E: No overload variant of "g" matches argument types "list[int]", "int" \
+             # N: Possible overload variants: \
+             # N:     def g(x: int, y: int) -> int \
+             # N:     def g(x: str, y: str) -> str
+
+g([1, 2], z=3) # E: Unexpected keyword argument "z" for overloaded function "g" \
+               # E: No overload variant of "g" matches argument types "list[int]", "int" \
+               # N: Possible overload variants: \
+               # N:     def g(x: int, y: int) -> int \
+               # N:     def g(x: str, y: str) -> str
+
+g(x="hello", y=1) # E: No overload variant of "g" matches argument types "str", "int" \
+                  # N: Possible overload variants: \
+                  # N:     def g(x: int, y: int) -> int \
+                  # N:     def g(x: str, y: str) -> str
 [builtins fixtures/list.pyi]