check function argument names for subtypes

Author: KotlinIsland

.mypy/baseline.json

@@ -1977,7 +1977,7 @@
         "code": "explicit-override",
         "column": 4,
         "message": "Method \"visit_class_def\" is not using @override but is overriding a method in class \"mypy.visitor.NodeVisitor\"",
-        "offset": 432,
+        "offset": 435,
         "src": "def visit_class_def(self, defn: ClassDef) -> None:",
         "target": "mypy.checker.TypeChecker.visit_class_def"
       },
@@ -2353,7 +2353,7 @@
         "code": "explicit-override",
         "column": 4,
         "message": "Method \"visit_uninhabited_type\" is not using @override but is overriding a method in class \"mypy.type_visitor.BoolTypeQuery\"",
-        "offset": 197,
+        "offset": 192,
         "src": "def visit_uninhabited_type(self, t: UninhabitedType) -> bool:",
         "target": "mypy.checker.InvalidInferredTypes.visit_uninhabited_type"
       },
@@ -10771,7 +10771,7 @@
         "code": "no-any-expr",
         "column": 67,
         "message": "Expression type contains \"Any\" (has type \"list[Any]\")",
-        "offset": 285,
+        "offset": 289,
         "src": "\"--package-root\", metavar=\"ROOT\", action=\"append\", default=[], help=argparse.SUPPRESS",
         "target": "mypy.main.process_options"
       },
@@ -11429,7 +11429,7 @@
         "code": "explicit-override",
         "column": 4,
         "message": "Method \"visit_unbound_type\" is not using @override but is overriding a method in class \"mypy.type_visitor.TypeVisitor\"",
-        "offset": 642,
+        "offset": 638,
         "src": "def visit_unbound_type(self, t: UnboundType) -> ProperType:",
         "target": "mypy.meet.TypeMeetVisitor.visit_unbound_type"
       },
@@ -14119,7 +14119,7 @@
         "code": "no-any-expr",
         "column": 18,
         "message": "Expression has type \"Any\"",
-        "offset": 122,
+        "offset": 125,
         "src": "MACHDEP = sysconfig.get_config_var(\"MACHDEP\")",
         "target": "mypy.options.Options.__init__"
       },
@@ -24737,7 +24737,7 @@
         "code": "no-any-explicit",
         "column": 4,
         "message": "Explicit \"Any\" is not allowed",
-        "offset": 749,
+        "offset": 747,
         "src": "def report(*args: Any) -> None:",
         "target": "mypy.subtypes.unify_generic_callable"
       },

CHANGELOG.md

@@ -6,6 +6,7 @@
 - Narrow type on initial assignment (#547)
 - Annotations in function bodies are not analyzed as evaluated (#564)
 - Invalid `cast`s show an error (#573)
+- Argument names are validated for subtypes (#562)
 ### Enhancements
 - Show 'narrowed from' in `reveal_type` (#550)
 - `--color-output` is enabled by default (#531)

docs/source/based_features.rst

@@ -296,3 +296,15 @@ Basedmypy handles type annotations in function bodies as unevaluated:
 
     def f():
         a: list[int]  # no error, this annotation isn't evaluated
+
+Checked Argument Names
+----------------------
+
+.. code-block::python
+
+    class A:
+        def f(self, a: int): ...
+
+    class B(A):
+        @override
+        def f(self, b: int): ...  # error: Signature of "f" incompatible with supertype "A"

mypy/checker.py

@@ -2351,7 +2351,10 @@ def check_override(
         # Use boolean variable to clarify code.
         fail = False
         op_method_wider_note = False
-        if not is_subtype(override, original, ignore_pos_arg_names=True):
+
+        if not is_subtype(
+            override, original, ignore_pos_arg_names=self.options.work_not_properly_function_names
+        ):
             fail = True
         elif isinstance(override, Overloaded) and self.is_forward_op_method(name):
             # Operator method overrides cannot extend the domain, as
@@ -2837,7 +2840,7 @@ class C(B, A[int]): ...  # this is unsafe because...
             call = find_member("__call__", first_type, first_type, is_operator=True)
         if call and isinstance(second_type, FunctionLike):
             second_sig = self.bind_and_map_method(second, second_type, ctx, base2)
-            ok = is_subtype(call, second_sig, ignore_pos_arg_names=True)
+            ok = is_subtype(call, second_sig)
         elif isinstance(first_type, FunctionLike) and isinstance(second_type, FunctionLike):
             if first_type.is_type_obj() and second_type.is_type_obj():
                 # For class objects only check the subtype relationship of the classes,
@@ -2850,7 +2853,7 @@ class C(B, A[int]): ...  # this is unsafe because...
                 # First bind/map method types when necessary.
                 first_sig = self.bind_and_map_method(first, first_type, ctx, base1)
                 second_sig = self.bind_and_map_method(second, second_type, ctx, base2)
-                ok = is_subtype(first_sig, second_sig, ignore_pos_arg_names=True)
+                ok = is_subtype(first_sig, second_sig)
         elif first_type and second_type:
             if isinstance(first.node, Var):
                 first_type = expand_self_type(first.node, first_type, fill_typevars(ctx))
@@ -7754,12 +7757,7 @@ def is_more_general_arg_prefix(t: FunctionLike, s: FunctionLike) -> bool:
 
 def is_same_arg_prefix(t: CallableType, s: CallableType) -> bool:
     return is_callable_compatible(
-        t,
-        s,
-        is_compat=is_same_type,
-        ignore_return=True,
-        check_args_covariantly=True,
-        ignore_pos_arg_names=True,
+        t, s, is_compat=is_same_type, ignore_return=True, check_args_covariantly=True
     )
 
 

mypy/main.py

@@ -1139,6 +1139,10 @@ def add_invertible_flag(
     )
     # This undocumented feature exports limited line-level dependency information.
     internals_group.add_argument("--export-ref-info", action="store_true", help=argparse.SUPPRESS)
+    # This undocumented feature makes callable subtypes with incorrect names count as valid (needed to check mypy itself)
+    internals_group.add_argument(
+        "--work-not-properly-function-names", action="store_true", help=argparse.SUPPRESS
+    )
 
     report_group = parser.add_argument_group(
         title="Report generation", description="Generate a report in the specified format."

mypy/meet.py

@@ -467,11 +467,7 @@ def _type_object_overlap(left: Type, right: Type) -> bool:
 
     if isinstance(left, CallableType) and isinstance(right, CallableType):
         return is_callable_compatible(
-            left,
-            right,
-            is_compat=_is_overlapping_types,
-            ignore_pos_arg_names=True,
-            allow_partial_overlap=True,
+            left, right, is_compat=_is_overlapping_types, allow_partial_overlap=True
         )
     elif isinstance(left, CallableType):
         left = left.fallback

mypy/messages.py

@@ -3026,7 +3026,7 @@ def get_conflict_protocol_types(
         subtype = mypy.typeops.get_protocol_member(left, member, class_obj)
         if not subtype:
             continue
-        is_compat = is_subtype(subtype, supertype, ignore_pos_arg_names=True, options=options)
+        is_compat = is_subtype(subtype, supertype, options=options)
         if IS_SETTABLE in get_member_flags(member, right):
             is_compat = is_compat and is_subtype(supertype, subtype, options=options)
         if not is_compat:

mypy/options.py

@@ -105,6 +105,9 @@ class Options:
     """Options collected from flags."""
 
     def __init__(self) -> None:
+        # stupid thing to make mypy project check properly
+        self.work_not_properly_function_names = False
+
         # Cache for clone_for_module()
         self._per_module_cache: dict[str, Options] | None = None
         # Despite the warnings about _per_module_cache being slow, this one might be good

mypy/subtypes.py

@@ -1081,7 +1081,6 @@ def f(self) -> A: ...
         for member in right.type.protocol_members:
             if member in members_not_to_check:
                 continue
-            ignore_names = member != "__call__"  # __call__ can be passed kwargs
             # The third argument below indicates to what self type is bound.
             # We always bind self to the subtype. (Similarly to nominal types).
             supertype = get_proper_type(find_member(member, right, left))
@@ -1103,9 +1102,7 @@ def f(self) -> A: ...
                 # Nominal check currently ignores arg names
                 # NOTE: If we ever change this, be sure to also change the call to
                 # SubtypeVisitor.build_subtype_kind(...) down below.
-                is_compat = is_subtype(
-                    subtype, supertype, ignore_pos_arg_names=ignore_names, options=options
-                )
+                is_compat = is_subtype(subtype, supertype, options=options)
             else:
                 is_compat = is_proper_subtype(subtype, supertype)
             if not is_compat:
@@ -1141,6 +1138,7 @@ def f(self) -> A: ...
     if not proper_subtype:
         # Nominal check currently ignores arg names, but __call__ is special for protocols
         ignore_names = right.type.protocol_members != ["__call__"]
+        ignore_names = False
     else:
         ignore_names = False
     subtype_kind = SubtypeVisitor.build_subtype_kind(

mypy/typeshed/stdlib/_weakrefset.pyi

@@ -16,10 +16,10 @@ class WeakSet(MutableSet[_T], Generic[_T]):
     def __init__(self, data: None = None) -> None: ...
     @overload
     def __init__(self, data: Iterable[_T]) -> None: ...
-    def add(self, item: _T) -> None: ...
-    def discard(self, item: _T) -> None: ...
+    def add(self, item: _T) -> None: ...  # type: ignore[override]
+    def discard(self, item: _T) -> None: ...  # type: ignore[override]
     def copy(self) -> Self: ...
-    def remove(self, item: _T) -> None: ...
+    def remove(self, item: _T) -> None: ...  # type: ignore[override]
     def update(self, other: Iterable[_T]) -> None: ...
     def __contains__(self, item: object) -> bool: ...
     def __len__(self) -> int: ...