stubtest: error if a dunder method is missing from a stub

mypy/stubtest.py

@@ -25,7 +25,7 @@
 from mypy import nodes
 from mypy.config_parser import parse_config_file
 from mypy.options import Options
-from mypy.util import FancyFormatter, bytes_to_human_readable_repr, is_dunder, SPECIAL_DUNDERS
+from mypy.util import FancyFormatter, bytes_to_human_readable_repr, is_dunder
 
 
 class Missing:
@@ -243,6 +243,58 @@ def _belongs_to_runtime(r: types.ModuleType, attr: str) -> bool:
         )
 
 
+IGNORED_DUNDERS = frozenset({
+    # Very special attributes
+    "__weakref__",
+    "__slots__",
+    "__dict__",
+    "__text_signature__",
+    "__match_args__",
+    # Pickle methods
+    "__setstate__",
+    "__getstate__",
+    "__getnewargs__",
+    "__getinitargs__",
+    "__reduce_ex__",
+    "__reduce__",
+    # typing implementation details
+    "__parameters__",
+    "__origin__",
+    "__args__",
+    "__orig_bases__",
+    "__mro_entries__",
+    "__forward_is_class__",
+    "__forward_module__",
+    "__final__",
+    # isinstance/issubclass hooks that type-checkers don't usually care about
+    "__instancecheck__",
+    "__subclasshook__",
+    "__subclasscheck__",
+    # Dataclasses implementation details
+    "__dataclass_fields__",
+    "__dataclass_params__",
+    # ctypes weirdness
+    "__ctype_be__",
+    "__ctype_le__",
+    "__ctypes_from_outparam__",
+    # Two float methods only used internally for CPython test suite, not for public use
+    "__set_format__",
+    "__getformat__",
+    # These two are basically useless for type checkers
+    "__hash__",
+    "__getattr__",
+    # For some reason, mypy doesn't infer classes with metaclass=ABCMeta inherit this attribute
+    "__abstractmethods__",
+    "__doc__",  # Can only ever be str | None, who cares?
+    "__del__",  # Only ever called when an object is being deleted, who cares?
+    "__new_member__",  # If an enum defines __new__, the method is renamed as __new_member__
+})
+
+
+def is_private(name: str) -> bool:
+    return name.startswith("_") and not is_dunder(name)
+
+
 @verify.register(nodes.TypeInfo)
 def verify_typeinfo(
     stub: nodes.TypeInfo, runtime: MaybeMissing[Type[Any]], object_path: List[str]
@@ -274,11 +326,9 @@ class SubClass(runtime):  # type: ignore
 
     # Check everything already defined in the stub
     to_check = set(stub.names)
-    # There's a reasonable case to be made that we should always check all dunders, but it's
-    # currently quite noisy. We could turn this into a denylist instead of an allowlist.
     to_check.update(
         # cast to workaround mypyc complaints
-        m for m in cast(Any, vars)(runtime) if not m.startswith("_") or m in SPECIAL_DUNDERS
+        m for m in cast(Any, vars)(runtime) if not is_private(m) and m not in IGNORED_DUNDERS
     )
 
     for entry in sorted(to_check):
@@ -713,7 +763,15 @@ def verify_funcitem(
 def verify_none(
     stub: Missing, runtime: MaybeMissing[Any], object_path: List[str]
 ) -> Iterator[Error]:
-    yield Error(object_path, "is not present in stub", stub, runtime)
+    # Do not error for an object missing from the stub
+    # If the runtime object is a types.WrapperDescriptorType object
+    # and has a non-special dunder name.
+    # The vast majority of these are false positives.
+    if not (
+        isinstance(runtime, type(object.__init__))
+        and is_dunder(getattr(runtime, "__name__", ""), exclude_special=True)
+    ):
+        yield Error(object_path, "is not present in stub", stub, runtime)
 
 
 @verify.register(nodes.Var)

mypy/test/teststubtest.py

@@ -37,6 +37,7 @@ def use_tmp_dir() -> Iterator[None]:
 VT = TypeVar('VT')
 
 class object:
+    __module__: str
     def __init__(self) -> None: pass
 class type: ...
 
@@ -657,6 +658,16 @@ def h(x: str): ...
         yield Case(
             stub="from mystery import A, B as B, C as D  # type: ignore", runtime="", error="B"
         )
+        yield Case(
+            stub="class Y: ...",
+            runtime="__all__ += ['Y']\nclass Y:\n  def __or__(self, other): return self|other",
+            error="Y.__or__"
+        )
+        yield Case(
+            stub="class Z: ...",
+            runtime="__all__ += ['Z']\nclass Z:\n  def __reduce__(self): return (Z,)",
+            error=None
+        )
 
     @collect_cases
     def test_missing_no_runtime_all(self) -> Iterator[Case]:
@@ -678,7 +689,7 @@ def test_non_public_2(self) -> Iterator[Case]:
         yield Case(stub="g: int", runtime="def g(): ...", error="g")
 
     @collect_cases
-    def test_special_dunders(self) -> Iterator[Case]:
+    def test_dunders(self) -> Iterator[Case]:
         yield Case(
             stub="class A:\n  def __init__(self, a: int, b: int) -> None: ...",
             runtime="class A:\n  def __init__(self, a, bx): pass",