Try fixing edge case in check_self_arg()

Author: ilevkivskyi

mypy/checker.py

@@ -1373,8 +1373,12 @@ def check_func_def(
                         if not is_same_type(arg_type, ref_type):
                             # This level of erasure matches the one in checkmember.check_self_arg(),
                             # better keep these two checks consistent.
-                            erased = get_proper_type(erase_typevars(erase_to_bound(arg_type)))
-                            if not is_subtype(ref_type, erased, ignore_type_params=True):
+                            erased = get_proper_type(
+                                erase_typevars(erase_to_bound(arg_type), use_upper_bound=True)
+                            )
+                            if not is_subtype(
+                                ref_type, erased, ignore_type_params=True, always_covariant=True
+                            ):
                                 if (
                                     isinstance(erased, Instance)
                                     and erased.type.is_protocol

mypy/checkmember.py

@@ -44,7 +44,6 @@
     erase_to_bound,
     freeze_all_type_vars,
     function_type,
-    get_all_type_vars,
     get_type_vars,
     make_simplified_union,
     supported_self_type,
@@ -1060,12 +1059,8 @@ def f(self: S) -> T: ...
             # better keep these two checks consistent.
             if subtypes.is_subtype(
                 dispatched_arg_type,
-                erase_typevars(erase_to_bound(selfarg)),
-                # This is to work around the fact that erased ParamSpec and TypeVarTuple
-                # callables are not always compatible with non-erased ones both ways.
-                always_covariant=any(
-                    not isinstance(tv, TypeVarType) for tv in get_all_type_vars(selfarg)
-                ),
+                erase_typevars(erase_to_bound(selfarg), use_upper_bound=True),
+                always_covariant=True,
                 ignore_pos_arg_names=True,
             ):
                 new_items.append(item)

mypy/erasetype.py

@@ -140,7 +140,9 @@ def visit_type_alias_type(self, t: TypeAliasType) -> ProperType:
         raise RuntimeError("Type aliases should be expanded before accepting this visitor")
 
 
-def erase_typevars(t: Type, ids_to_erase: Container[TypeVarId] | None = None) -> Type:
+def erase_typevars(
+    t: Type, ids_to_erase: Container[TypeVarId] | None = None, use_upper_bound: bool = False
+) -> Type:
     """Replace all type variables in a type with any,
     or just the ones in the provided collection.
     """
@@ -150,7 +152,7 @@ def erase_id(id: TypeVarId) -> bool:
             return True
         return id in ids_to_erase
 
-    return t.accept(TypeVarEraser(erase_id, AnyType(TypeOfAny.special_form)))
+    return t.accept(TypeVarEraser(erase_id, AnyType(TypeOfAny.special_form), use_upper_bound))
 
 
 def replace_meta_vars(t: Type, target_type: Type) -> Type:
@@ -161,13 +163,21 @@ def replace_meta_vars(t: Type, target_type: Type) -> Type:
 class TypeVarEraser(TypeTranslator):
     """Implementation of type erasure"""
 
-    def __init__(self, erase_id: Callable[[TypeVarId], bool], replacement: Type) -> None:
+    def __init__(
+        self,
+        erase_id: Callable[[TypeVarId], bool],
+        replacement: Type,
+        use_upper_bound: bool = False,
+    ) -> None:
         super().__init__()
         self.erase_id = erase_id
         self.replacement = replacement
+        self.use_upper_bound = use_upper_bound
 
     def visit_type_var(self, t: TypeVarType) -> Type:
         if self.erase_id(t.id):
+            if self.use_upper_bound:
+                return t.upper_bound
             return self.replacement
         return t
 
@@ -204,11 +214,16 @@ def visit_tuple_type(self, t: TupleType) -> Type:
         return result
 
     def visit_callable_type(self, t: CallableType) -> Type:
+        use_upper_bound = self.use_upper_bound
+        # This is to work around the fact that erased callables are not compatible
+        # with non-erased ones (due to contravariance in arg types).
+        self.use_upper_bound = False
         result = super().visit_callable_type(t)
         assert isinstance(result, ProperType) and isinstance(result, CallableType)
         # Usually this is done in semanal_typeargs.py, but erasure can create
         # a non-normal callable from normal one.
         result.normalize_trivial_unpack()
+        self.use_upper_bound = use_upper_bound
         return result
 
     def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:

mypy/nodes.py

@@ -592,7 +592,7 @@ def is_trivial_self(self) -> bool:
                 if not item.is_trivial_self:
                     self._is_trivial_self = False
                     return False
-            elif item.decorators or not item.func.is_trivial_self:
+            elif len(item.decorators) > 1 or not item.func.is_trivial_self:
                 self._is_trivial_self = False
                 return False
         self._is_trivial_self = True

mypy/typeshed/stdlib/os/__init__.pyi

@@ -721,7 +721,7 @@ class _Environ(MutableMapping[AnyStr, AnyStr], Generic[AnyStr]):
             unsetenv: Callable[[AnyStr, AnyStr], object],
         ) -> None: ...
 
-    def setdefault(self, key: AnyStr, value: AnyStr) -> AnyStr: ...
+    def setdefault(self, key: AnyStr, value: AnyStr) -> AnyStr: ...  # type: ignore[override]
     def copy(self) -> dict[AnyStr, AnyStr]: ...
     def __delitem__(self, key: AnyStr) -> None: ...
     def __getitem__(self, key: AnyStr) -> AnyStr: ...

mypy/typeshed/stdlib/weakref.pyi

@@ -110,7 +110,7 @@ class WeakValueDictionary(MutableMapping[_KT, _VT]):
     def items(self) -> Iterator[tuple[_KT, _VT]]: ...  # type: ignore[override]
     def itervaluerefs(self) -> Iterator[KeyedRef[_KT, _VT]]: ...
     def valuerefs(self) -> list[KeyedRef[_KT, _VT]]: ...
-    def setdefault(self, key: _KT, default: _VT) -> _VT: ...
+    def setdefault(self, key: _KT, default: _VT) -> _VT: ...  # type: ignore[override]
     @overload
     def pop(self, key: _KT) -> _VT: ...
     @overload

test-data/unit/check-overloading.test

@@ -6762,7 +6762,7 @@ class D(Generic[T]):
     def f(self, x: int) -> int: ...
     @overload
     def f(self, x: str) -> str: ...
-    def f(Self, x): ...
+    def f(self, x): ...
 
 a: D[str]  # E: Type argument "str" of "D" must be a subtype of "C"
 reveal_type(a.f(1))  # N: Revealed type is "builtins.int"