stubtest: don't flag __class_getitem__ as missing on a generic stub

A class that implements `__class_getitem__` at runtime to support
subscription is correctly modelled in a stub by declaring the class as
generic (PEP 695 `class C[T]` or `Generic[T]`). stubtest nevertheless
reported `C.__class_getitem__ is not present in stub` in that case.

Skip the `__class_getitem__` runtime member when the stub class is generic
(`TypeInfo.is_generic()`) and does not explicitly declare it. Non-generic
stubs still report the missing method as before.

Fixes #21253

Author: ShirGanon

mypy/stubtest.py

@@ -707,6 +707,16 @@ def verify_typeinfo(
             mangled_entry = f"_{stub.name.lstrip('_')}{entry}"
         stub_to_verify = next((t.names[entry].node for t in stub.mro if entry in t.names), MISSING)
         assert stub_to_verify is not None
+        # A generic class is subscriptable at the type level via its type
+        # parameters; a runtime `__class_getitem__` is just the implementation
+        # detail backing that. Don't report it as missing from a stub that
+        # already declares the class as generic. See #21253.
+        if (
+            entry == "__class_getitem__"
+            and isinstance(stub_to_verify, Missing)
+            and stub.is_generic()
+        ):
+            continue
         try:
             try:
                 runtime_attr = getattr(runtime, mangled_entry)

mypy/test/teststubtest.py

@@ -292,6 +292,33 @@ def f(self, number, text): pass
             error=None,
         )
 
+    @collect_cases
+    def test_class_getitem_on_generic(self) -> Iterator[Case]:
+        # A runtime `__class_getitem__` backs subscriptability that a stub
+        # expresses via generic type parameters, so it should not be reported
+        # as missing from a generic stub. See #21253.
+        yield Case(
+            stub="""
+            from typing import Generic, TypeVar
+            _T = TypeVar("_T")
+            class GenericClassGetItem(Generic[_T]): ...
+            """,
+            runtime="""
+            class GenericClassGetItem:
+                def __class_getitem__(cls, item, /): return cls
+            """,
+            error=None,
+        )
+        # But a non-generic stub should still flag the extra runtime method.
+        yield Case(
+            stub="class PlainClassGetItem: ...",
+            runtime="""
+            class PlainClassGetItem:
+                def __class_getitem__(cls, item, /): return cls
+            """,
+            error="PlainClassGetItem.__class_getitem__",
+        )
+
     @collect_cases
     def test_types(self) -> Iterator[Case]:
         yield Case(