self type

Author: hauntsaninja

mypy/checkmember.py

@@ -1081,26 +1081,17 @@ def analyze_class_attribute_access(
             #         x: T
             #     C.x  # Error, ambiguous access
             #     C[int].x  # Also an error, since C[int] is same as C at runtime
-            # Exception is Self type wrapped in ClassVar, that is safe.
+            # Exception is Self type, which is always allowed
             def_vars = set(node.node.info.defn.type_vars)
-            if not node.node.is_classvar and node.node.info.self_type:
-                def_vars.add(node.node.info.self_type)
-
+            if node.node.info.self_type:
+                def_vars.discard(node.node.info.self_type)
             typ_vars = set(get_type_vars(t))
-            for tv in def_vars & typ_vars:
-                if (
-                    # Forgive access to variables generic over Self
-                    isinstance(tv.upper_bound, Instance)
-                    and super_info
-                    and tv.upper_bound.type.fullname == super_info.fullname
-                ):
-                    continue
+            if def_vars & typ_vars:
                 if node.node.is_classvar:
                     message = message_registry.GENERIC_CLASS_VAR_ACCESS
                 else:
                     message = message_registry.GENERIC_INSTANCE_VAR_CLASS_ACCESS
                 mx.msg.fail(message, mx.context)
-                break
 
             t = expand_self_type_if_needed(t, mx, node.node, itype, is_class=True)
             # Erase non-mapped variables, but keep mapped ones, even if there is an error.

test-data/unit/check-generics.test

@@ -2234,7 +2234,7 @@ reveal_type(xi)  # N: Revealed type is "builtins.int"
 [builtins fixtures/classmethod.pyi]
 
 [case testGenericClassAttrSelfType]
-from typing import TypeVar, Generic, Self, Type, Mapping
+from typing import TypeVar, Generic, Self, Type, Mapping, ClassVar
 
 class A:
     d: Mapping[str, Self]
@@ -2253,6 +2253,22 @@ def check_B(B_t: Type[B]) -> None:
     reveal_type(B.d)  # N: Revealed type is "typing.Mapping[builtins.str, __main__.B]"
     reveal_type(B_t.d)  # N: Revealed type is "typing.Mapping[builtins.str, __main__.B]"
 
+class AA:
+    d: ClassVar[Mapping[str, Self]]
+
+    @classmethod
+    def make(cls) -> Self:
+        return cls.d["asdf"]
+
+class BB(AA): ...
+
+def check_AA(AA_t: Type[AA]) -> None:
+    reveal_type(AA.d)  # N: Revealed type is "typing.Mapping[builtins.str, __main__.AA]"
+    reveal_type(AA_t.d)  # N: Revealed type is "typing.Mapping[builtins.str, __main__.AA]"
+
+def check_BB(BB_t: Type[BB]) -> None:
+    reveal_type(BB.d)  # N: Revealed type is "typing.Mapping[builtins.str, __main__.BB]"
+    reveal_type(BB_t.d)  # N: Revealed type is "typing.Mapping[builtins.str, __main__.BB]"
 [builtins fixtures/classmethod.pyi]
 
 [case testGenericClassAttrUnboundOnSubClass]

test-data/unit/check-selftype.test

@@ -2120,7 +2120,7 @@ c: C
 reveal_type(c.x)  # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.C]"
 reveal_type(c.y)  # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.C]"
 reveal_type(C.y)  # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.C]"
-C.x  # E: Access to generic instance variables via class is ambiguous
+C.x
 [builtins fixtures/classmethod.pyi]
 
 [case testAccessingTypingSelfUnion]