more

Author: hauntsaninja

mypy/checkmember.py

@@ -1085,13 +1085,23 @@ def analyze_class_attribute_access(
             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)
+
             typ_vars = set(get_type_vars(t))
-            if any(tv for tv in def_vars & typ_vars if tv.upper_bound != itype):
+            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 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.
             # In the above example this means that we infer following types:

test-data/unit/check-generics.test

@@ -2243,10 +2243,16 @@ class A:
     def make(cls) -> Self:
         return cls.d["asdf"]
 
-def main(A_t: Type[A]) -> None:
+class B(A): ...
+
+def check_A(A_t: Type[A]) -> None:
     reveal_type(A.d)  # N: Revealed type is "typing.Mapping[builtins.str, __main__.A]"
     reveal_type(A_t.d)  # N: Revealed type is "typing.Mapping[builtins.str, __main__.A]"
 
+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]"
+
 [builtins fixtures/classmethod.pyi]
 
 [case testGenericClassAttrUnboundOnSubClass]

test-data/unit/check-selftype.test

@@ -1485,7 +1485,7 @@ class C:
 class D(C): ...
 
 reveal_type(C.meth)  # N: Revealed type is "def [Self <: __main__.C] (self: Self`1) -> builtins.list[Self`1]"
-C.attr  # E: Access to generic instance variables via class is ambiguous
+C.attr
 reveal_type(D().meth())  # N: Revealed type is "builtins.list[__main__.D]"
 reveal_type(D().attr)  # N: Revealed type is "builtins.list[__main__.D]"