refactored code

KevinRK29 · KevinRK29 · commit c59e4f9796bb · 2026-02-06T03:47:36.000-05:00
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -33,7 +33,7 @@
 from mypy.maptype import map_instance_to_supertype
 from mypy.meet import is_overlapping_types, narrow_declared_type
 from mypy.message_registry import ErrorMessage
-from mypy.messages import MessageBuilder, format_type, format_type_distinctly
+from mypy.messages import MessageBuilder, callable_name, format_type
 from mypy.nodes import (
     ARG_NAMED,
     ARG_POS,
@@ -1798,17 +1798,29 @@ def check_callable_call(
 
         arg_types = self.infer_arg_types_in_context(callee, args, arg_kinds, formal_to_actual)
 
-        self.check_call_arguments(
-            callee,
-            arg_types,
-            arg_kinds,
-            arg_names,
-            args,
-            formal_to_actual,
-            context,
-            callable_name,
-            object_type,
-        )
+        if not self._detect_missing_positional_arg(
+            callee, arg_types, arg_kinds, args, context
+        ):
+            self.check_argument_count(
+                callee,
+                arg_types,
+                arg_kinds,
+                arg_names,
+                formal_to_actual,
+                context,
+                object_type,
+                callable_name,
+            )
+
+            self.check_argument_types(
+                arg_types,
+                arg_kinds,
+                args,
+                callee,
+                formal_to_actual,
+                context,
+                object_type=object_type,
+            )
 
         if (
             callee.is_type_obj()
@@ -2337,232 +2349,51 @@ def apply_inferred_arguments(
         # arguments.
         return self.apply_generic_arguments(callee_type, inferred_args, context)
 
-    def check_call_arguments(
+    def _detect_missing_positional_arg(
         self,
         callee: CallableType,
         arg_types: list[Type],
         arg_kinds: list[ArgKind],
-        arg_names: Sequence[str | None] | None,
         args: list[Expression],
-        formal_to_actual: list[list[int]],
         context: Context,
-        callable_name: str | None,
-        object_type: Type | None,
-    ) -> None:
-        """Check argument count and types, consolidating errors for missing positional args."""
-        with self.msg.filter_errors():
-            _, missing_positional = self.check_argument_count(
-                callee,
-                arg_types,
-                arg_kinds,
-                arg_names,
-                formal_to_actual,
-                context,
-                object_type,
-                callable_name,
-            )
-
-        if missing_positional:
-            func_name = callable_name or callee.name or "function"
-            if "." in func_name:
-                func_name = func_name.split(".")[-1]
-
-            shift_info = None
-            num_positional_args = sum(1 for k in arg_kinds if k == nodes.ARG_POS)
-            if num_positional_args >= 2:
-                shift_info = self.detect_shifted_positional_args(
-                    callee, arg_types, arg_kinds, missing_positional
-                )
-
-            with self.msg.filter_errors() as type_error_watcher:
-                self.check_argument_types(
-                    arg_types,
-                    arg_kinds,
-                    args,
-                    callee,
-                    formal_to_actual,
-                    context,
-                    object_type=object_type,
-                )
-            has_type_errors = type_error_watcher.has_new_errors()
-
-            if shift_info is not None:
-                shift_position, param_name, expected_type, high_confidence = shift_info
-                if high_confidence and param_name:
-                    positional_arg_types = [
-                        arg_types[i] for i, k in enumerate(arg_kinds) if k == nodes.ARG_POS
-                    ]
-                    actual_type = positional_arg_types[shift_position - 1]
-                    actual_str, expected_str = format_type_distinctly(
-                        actual_type, expected_type, options=self.chk.options
-                    )
-                    self.msg.fail(
-                        f'Argument {shift_position} to "{func_name}" has incompatible type '
-                        f"{actual_str}; expected {expected_str}",
-                        context,
-                        code=codes.CALL_ARG,
-                    )
-                else:
-                    self.check_argument_count(
-                        callee,
-                        arg_types,
-                        arg_kinds,
-                        arg_names,
-                        formal_to_actual,
-                        context,
-                        object_type,
-                        callable_name,
-                    )
-                    self.check_argument_types(
-                        arg_types,
-                        arg_kinds,
-                        args,
-                        callee,
-                        formal_to_actual,
-                        context,
-                        object_type=object_type,
-                    )
-            elif has_type_errors:
-                self.check_argument_count(
-                    callee,
-                    arg_types,
-                    arg_kinds,
-                    arg_names,
-                    formal_to_actual,
-                    context,
-                    object_type,
-                    callable_name,
-                )
-                self.check_argument_types(
-                    arg_types,
-                    arg_kinds,
-                    args,
-                    callee,
-                    formal_to_actual,
-                    context,
-                    object_type=object_type,
-                )
-            else:
-                self.check_argument_count(
-                    callee,
-                    arg_types,
-                    arg_kinds,
-                    arg_names,
-                    formal_to_actual,
-                    context,
-                    object_type,
-                    callable_name,
-                )
-        else:
-            self.check_argument_count(
-                callee,
-                arg_types,
-                arg_kinds,
-                arg_names,
-                formal_to_actual,
-                context,
-                object_type,
-                callable_name,
-            )
-            self.check_argument_types(
-                arg_types,
-                arg_kinds,
-                args,
-                callee,
-                formal_to_actual,
-                context,
-                object_type=object_type,
-            )
-
-    def detect_shifted_positional_args(
-        self,
-        callee: CallableType,
-        actual_types: list[Type],
-        actual_kinds: list[ArgKind],
-        missing_positional: list[int],
-    ) -> tuple[int, str | None, Type, bool] | None:
-        """Detect if positional arguments are shifted due to a missing argument.
+    ) -> bool:
+        """Try to identify a single missing positional argument using type alignment.
 
-        Returns (1-indexed position, param name, expected type, high_confidence) if a
-        shift pattern is found, None otherwise. High confidence is set when the function
-        has fixed parameters (no defaults, *args, or **kwargs).
+        If the caller and callee are just positional arguments and exactly one arg is missing,
+        we scan left to right to find which argument skipped. If there is an error, report it 
+        and return True, or return False to fall back to normal checking.
         """
-        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)
-        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
-        ]
-        if len(positional_actual_types) < 2:
-            return None
+        if not all(k == ARG_POS for k in callee.arg_kinds):
+            return False
+        if not all(k == ARG_POS for k in arg_kinds):
+            return False
+        if len(arg_kinds) != len(callee.arg_kinds) - 1:
+            return False
 
-        positional_formal_types: list[Type] = []
-        positional_formal_names: list[str | None] = []
-        for i, kind in enumerate(callee.arg_kinds):
-            if kind.is_positional():
-                positional_formal_types.append(callee.arg_types[i])
-                positional_formal_names.append(callee.arg_names[i])
-
-        # Find first position where arg doesn't match but would match next position
-        shift_position = None
-        for i, actual_type in enumerate(positional_actual_types):
-            if i >= len(positional_formal_types):
-                break
-            if is_subtype(actual_type, positional_formal_types[i], options=self.chk.options):
-                continue
-            next_idx = i + 1
-            if next_idx >= len(positional_formal_types):
-                break
-            if is_subtype(
-                actual_type, positional_formal_types[next_idx], options=self.chk.options
-            ):
-                shift_position = i
+        skip_idx: int | None = None
+        j = 0
+        for i in range(len(callee.arg_types)):
+            if j >= len(arg_types):
+                skip_idx = i
                 break
+            if is_subtype(arg_types[j], callee.arg_types[i], options=self.chk.options):
+                j += 1
+            elif skip_idx is None:
+                skip_idx = i
             else:
-                break
-
-        if shift_position is None:
-            return None
+                return False
 
-        # Validate that all args would match if we inserted one at shift_position
-        if not self._validate_shift_insertion(
-            positional_actual_types, positional_formal_types, shift_position
-        ):
-            return None
+        if skip_idx is None or j != len(arg_types):
+            return False
 
-        return (
-            shift_position + 1,
-            positional_formal_names[shift_position],
-            positional_formal_types[shift_position],
-            high_confidence,
-        )
+        param_name = callee.arg_names[skip_idx]
+        callee_name = callable_name(callee)
+        if param_name is None or callee_name is None:
+            return False
 
-    def _validate_shift_insertion(
-        self, actual_types: list[Type], formal_types: list[Type], insert_position: int
-    ) -> bool:
-        """Check if inserting an argument at insert_position would fix type errors."""
-        for i, actual_type in enumerate(actual_types):
-            if i < insert_position:
-                if i >= len(formal_types):
-                    return False
-                expected = formal_types[i]
-            else:
-                shifted_idx = i + 1
-                if shifted_idx >= len(formal_types):
-                    return False
-                expected = formal_types[shifted_idx]
-            if not is_subtype(actual_type, expected, options=self.chk.options):
-                return False
+        msg = f'Missing positional argument "{param_name}" in call to {callee_name}'
+        ctx = args[skip_idx] if skip_idx < len(args) else context
+        self.msg.fail(msg, ctx, code=codes.CALL_ARG)
         return True
 
     def check_argument_count(
@@ -2575,15 +2406,13 @@ def check_argument_count(
         context: Context | None,
         object_type: Type | None = None,
         callable_name: str | None = None,
-    ) -> tuple[bool, list[int]]:
+    ) -> bool:
         """Check that there is a value for all required arguments to a function.
 
         Also check that there are no duplicate values for arguments. Report found errors
         using 'messages' if it's not None. If 'messages' is given, 'context' must also be given.
 
-        Return a tuple of:
-        - False if there were any errors, True otherwise
-        - List of formal argument indices that are missing positional arguments
+        Return False if there were any errors. Otherwise return True
         """
         if context is None:
             # Avoid "is None" checks
@@ -2601,15 +2430,12 @@ def check_argument_count(
             callee, actual_types, actual_kinds, actual_names, all_actuals, context
         )
 
-        missing_positional: list[int] = []
-
         # Check for too many or few values for formals.
         for i, kind in enumerate(callee.arg_kinds):
             mapped_args = formal_to_actual[i]
             if kind.is_required() and not mapped_args and not is_unexpected_arg_error:
                 # No actual for a mandatory formal
                 if kind.is_positional():
-                    missing_positional.append(i)
                     self.msg.too_few_arguments(callee, context, actual_names)
                     if object_type and callable_name and "." in callable_name:
                         self.missing_classvar_callable_note(object_type, callable_name, context)
@@ -2648,7 +2474,7 @@ def check_argument_count(
                     if actual_kinds[mapped_args[0]] == nodes.ARG_STAR2 and paramspec_entries > 1:
                         self.msg.fail("ParamSpec.kwargs should only be passed once", context)
                         ok = False
-        return ok, missing_positional
+        return ok
 
     def check_for_extra_actual_arguments(
         self,
@@ -3108,7 +2934,7 @@ def has_shape(typ: Type) -> bool:
                     matches.append(typ)
                 elif self.check_argument_count(
                     typ, arg_types, arg_kinds, arg_names, formal_to_actual, None
-                )[0]:
+                ):
                     if args_have_var_arg and typ.is_var_arg:
                         star_matches.append(typ)
                     elif args_have_kw_arg and typ.is_kw_arg:
@@ -3481,7 +3307,7 @@ def erased_signature_similarity(
         with self.msg.filter_errors():
             if not self.check_argument_count(
                 callee, arg_types, arg_kinds, arg_names, formal_to_actual, None
-            )[0]:
+            ):
                 # Too few or many arguments -> no match.
                 return False
 
diff --git a/test-data/unit/check-columns.test b/test-data/unit/check-columns.test
@@ -409,6 +409,14 @@ main:2:10:2:17: error: Incompatible types in assignment (expression has type "st
 main:6:3:7:1: error: Argument 1 to "f" has incompatible type "int"; expected "str"
 main:8:1:8:4: error: Value of type "int" is not indexable
 
+[case testColumnsMissingPositionalArgShiftDetected]
+def f(x: int, y: str, z: bytes, aa: int) -> None: ...
+f(1, b'x', 1) # E:6: Missing positional argument "y" in call to "f"
+def g(x: int, y: str, z: bytes) -> None: ...
+g("hello", b'x') # E:3: Missing positional argument "x" in call to "g"
+g(1, "hello") # E:1: Missing positional argument "z" in call to "g"
+[builtins fixtures/primitives.pyi]
+
 [case testEndColumnsWithTooManyTypeVars]
 # flags: --pretty
 import typing
diff --git a/test-data/unit/check-functions.test b/test-data/unit/check-functions.test
