Allow redundant Self by default; add error code

python · ilevkivskyi · Nov 15, 2022 · Nov 7, 2022 · Nov 7, 2022 · Nov 7, 2022
commit 324eff2bef6b076340f67add43f77dee49cea5a4
diff --git a/docs/source/error_code_list2.rst b/docs/source/error_code_list2.rst
@@ -82,6 +82,25 @@ Example:
         # Error: Redundant cast to "int"  [redundant-cast]
         return cast(int, x)
 
+Check that methods do not have redundant Self annotations [redundant-self]
+--------------------------------------------------------------------------
+
+Such annotations are allowed by :pep:`673` but are redundant, so if you want
+warnings about them, enable this error code.
+
+Example:
+
+.. code-block:: python
+
+   # mypy: enable-error-code="redundant-self"
+
+   from typing import Self
+
+   class C:
+       # Error: Redundant Self annotation on method first argument
+       def copy(self: Self) -> Self:
+           return type(self)()
+
 Check that comparisons are overlapping [comparison-overlap]
 -----------------------------------------------------------
 

diff --git a/mypy/errorcodes.py b/mypy/errorcodes.py
@@ -180,6 +180,12 @@ def __str__(self) -> str:
     "General",
     default_enabled=False,
 )
+REDUNDANT_SELF_TYPE = ErrorCode(
+    "redundant-self",
+    "Warn about redundant Self type annotations on method first argument",
+    "General",
+    default_enabled=False,
+)
 
 
 # Syntax errors are often blocking.

diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -219,6 +219,7 @@
 from mypy.semanal_typeddict import TypedDictAnalyzer
 from mypy.tvar_scope import TypeVarLikeScope
 from mypy.typeanal import (
+    SELF_TYPE_NAMES,
     TypeAnalyser,
     TypeVarLikeList,
     TypeVarLikeQuery,
@@ -948,12 +949,42 @@ def prepare_method_signature(self, func: FuncDef, info: TypeInfo, has_self_type:
                     func.type = replace_implicit_first_type(functype, leading_type)
                 elif has_self_type and isinstance(func.unanalyzed_type, CallableType):
                     if not isinstance(get_proper_type(func.unanalyzed_type.arg_types[0]), AnyType):
-                        self.fail(
-                            "Method cannot have explicit self annotation and Self type", func
-                        )
+                        if self.is_expected_self_type(
+                            self_type, func.is_class or func.name == "__new__"
+                        ):
+                            # This error is off by default, since it is explicitly allowed
+                            # by the PEP 673.
+                            self.fail(
+                                "Redundant Self annotation on method first argument",
+                                func,
+                                code=codes.REDUNDANT_SELF_TYPE,
+                            )
+                        else:
+                            self.fail(
+                                "Method cannot have explicit self annotation and Self type", func
+                            )
         elif has_self_type:
             self.fail("Static methods cannot use Self type", func)
 
+    def is_expected_self_type(self, typ: Type, is_classmethod: bool) -> bool:
+        """Does this (analyzed or not) type represent the expected Self type for a method?"""
+        assert self.type is not None
+        typ = get_proper_type(typ)
+        if is_classmethod:
+            if isinstance(typ, TypeType):
+                return self.is_expected_self_type(typ.item, is_classmethod=False)
+            if isinstance(typ, UnboundType):
+                sym = self.lookup_qualified(typ.name, typ, suppress_errors=True)
+                if sym is not None and sym.fullname == "typing.Type" and typ.args:
+                    return self.is_expected_self_type(typ.args[0], is_classmethod=False)
+            return False
+        if isinstance(typ, TypeVarType):
+            return typ == self.type.self_type
+        if isinstance(typ, UnboundType):
+            sym = self.lookup_qualified(typ.name, typ, suppress_errors=True)
+            return sym is not None and sym.fullname in SELF_TYPE_NAMES
+        return False
+
     def set_original_def(self, previous: Node | None, new: FuncDef | Decorator) -> bool:
         """If 'new' conditionally redefine 'previous', set 'previous' as original
 

diff --git a/test-data/unit/check-selftype.test b/test-data/unit/check-selftype.test
@@ -1470,3 +1470,47 @@ class C:
     x: Self
     def __init__(self, x: C) -> None:
         self.x = x  # E: Incompatible types in assignment (expression has type "C", variable has type "Self")
+
+[case testTypingSelfRedundantAllowed]
+from typing import Self, Type
+
+class C:
+    def f(self: Self) -> Self:
+        d: Defer
+        class Defer: ...
+        return self
+
+    @classmethod
+    def g(cls: Type[Self]) -> Self:
+        d: DeferAgain
+        class DeferAgain: ...
+        return cls()
+[builtins fixtures/classmethod.pyi]
+
+[case testTypingSelfRedundantWarning]
+# mypy: enable-error-code="redundant-self"
+
+from typing import Self, Type
+
+class C:
+    def copy(self: Self) -> Self:  # E: Redundant Self annotation on method first argument
+        d: Defer
+        class Defer: ...
+        return self
+
+    @classmethod
+    def g(cls: Type[Self]) -> Self:  # E: Redundant Self annotation on method first argument
+        d: DeferAgain
+        class DeferAgain: ...
+        return cls()
+[builtins fixtures/classmethod.pyi]
+
+-- Handle unusual locations consistently using a flag
+
+-- Self in cast and type assert should be a Self (and probably actually everywhere)
+
+-- Always prohibit in type aliases
+
+-- Protocol test with ClassVar default
+
+-- NamedTuple with Self (class)method