made error messages more consistent and improved test names to not include implementation details

Author: KevinRK29

mypy/checkexpr.py

@@ -2399,8 +2399,7 @@ def check_call_arguments(
                     )
                     self.msg.fail(
                         f'Argument {shift_position} to "{func_name}" has incompatible type '
-                        f"{actual_str}; expected {expected_str} "
-                        f'(did you forget argument "{param_name}"?)',
+                        f"{actual_str}; expected {expected_str}",
                         context,
                         code=codes.CALL_ARG,
                     )
@@ -2492,13 +2491,15 @@ def detect_shifted_positional_args(
         if not missing_positional:
             return None
 
+        # Only attempt shift detection when exactly one argument is missing.
+        # When multiple arguments are missing, we should fall back to the original behavior.
+        if len(missing_positional) != 1:
+            return None
+
         has_star_args = any(k == nodes.ARG_STAR for k in callee.arg_kinds)
         has_star_kwargs = any(k == nodes.ARG_STAR2 for k in callee.arg_kinds)
         has_defaults = any(k == nodes.ARG_OPT for k in callee.arg_kinds)
-        single_missing = len(missing_positional) == 1
-        high_confidence = (
-            single_missing and not has_star_args and not has_star_kwargs and not has_defaults
-        )
+        high_confidence = not has_star_args and not has_star_kwargs and not has_defaults
 
         positional_actual_types = [
             actual_types[i] for i, k in enumerate(actual_kinds) if k == nodes.ARG_POS

test-data/unit/check-functions.test

@@ -3751,23 +3751,31 @@ kwargs: dict[str, object]
 foo(**kwargs)  # E: Argument 1 to "foo" has incompatible type "**dict[str, object]"; expected "P"
 [builtins fixtures/dict.pyi]
 
-[case testMissingPositionalArgumentShiftedTypes]
+[case testMissingPositionalArgumentTypeMismatch]
 def f(x: int, y: str, z: bytes, aa: int) -> None: ...
 
 f(1, b'x', 1)
 [builtins fixtures/primitives.pyi]
 [out]
-main:3: error: Argument 2 to "f" has incompatible type "bytes"; expected "str" (did you forget argument "y"?)
+main:3: error: Argument 2 to "f" has incompatible type "bytes"; expected "str"
 
-[case testMissingPositionalArgumentShiftedTypesFirstArg]
+[case testMissingPositionalArgumentTypeMismatchFirst]
 def f(x: int, y: str, z: bytes) -> None: ...
 
 f("hello", b'x')
 [builtins fixtures/primitives.pyi]
 [out]
-main:3: error: Argument 1 to "f" has incompatible type "str"; expected "int" (did you forget argument "x"?)
+main:3: error: Argument 1 to "f" has incompatible type "str"; expected "int"
+
+[case testMissingPositionalArgumentManyArgs]
+def f(a: int, b: str, c: float, d: list[int], e: tuple[str, ...]) -> None: ...
+
+f(1, 1.5, [1, 2, 3], ("a", "b"))
+[builtins fixtures/list.pyi]
+[out]
+main:3: error: Argument 2 to "f" has incompatible type "float"; expected "str"
 
-[case testMissingPositionalArgumentNoShift]
+[case testMissingPositionalArgumentNoPattern]
 def f(x: int, y: str, z: bytes) -> None: ...
 
 f("wrong", 123)
@@ -3777,15 +3785,17 @@ main:3: error: Missing positional argument "z" in call to "f"
 main:3: error: Argument 1 to "f" has incompatible type "str"; expected "int"
 main:3: error: Argument 2 to "f" has incompatible type "int"; expected "str"
 
-[case testMissingPositionalArgumentShiftedTypesManyArgs]
-def f(a: int, b: str, c: float, d: list[int], e: tuple[str, ...]) -> None: ...
+[case testMissingMultiplePositionalArguments]
+def f(a: int, b: str, c: float, d: list[int]) -> None: ...
 
-f(1, 1.5, [1, 2, 3], ("a", "b"))
+f(1.5, [1, 2, 3])
 [builtins fixtures/list.pyi]
 [out]
-main:3: error: Argument 2 to "f" has incompatible type "float"; expected "str" (did you forget argument "b"?)
+main:3: error: Missing positional arguments "c", "d" in call to "f"
+main:3: error: Argument 1 to "f" has incompatible type "float"; expected "int"
+main:3: error: Argument 2 to "f" has incompatible type "list[int]"; expected "str"
 
-[case testMissingPositionalArgumentShiftedWithDefaults]
+[case testMissingPositionalArgumentWithDefaults]
 def f(x: int, y: str, z: bytes = b'default') -> None: ...
 
 f("hello")
@@ -3794,7 +3804,7 @@ f("hello")
 main:3: error: Missing positional argument "y" in call to "f"
 main:3: error: Argument 1 to "f" has incompatible type "str"; expected "int"
 
-[case testMissingPositionalArgumentShiftedWithStarArgs]
+[case testMissingPositionalArgumentWithStarArgs]
 def f(x: int, y: str, z: bytes, *args: int) -> None: ...
 
 f("hello", b'x')