Reduce more uninhabited intersections to Never (#43)

Author: JelleZijlstra

docs/changelog.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## Unreleased
+
+- Reduce more uninhabited intersections to `Never`
+
 ## Version 0.2.0 (June 26, 2025)
 
 - Fix crash on class definition keyword args when the `no_implicit_any` error

pycroscope/checker.py

@@ -151,7 +151,11 @@ def _build_type_object(self, typ: Union[type, super, str]) -> TypeObject:
             else:
                 protocol_members = set()
             return TypeObject(
-                typ, bases, is_protocol=is_protocol, protocol_members=protocol_members
+                typ,
+                bases,
+                is_protocol=is_protocol,
+                protocol_members=protocol_members,
+                is_final=self.ts_finder.is_final(typ),
             )
         elif isinstance(typ, super):
             return TypeObject(typ, self.get_additional_bases(typ))
@@ -181,7 +185,8 @@ def _build_type_object(self, typ: Union[type, super, str]) -> TypeObject:
                     typ, additional_bases, is_protocol=True, protocol_members=members
                 )
 
-            return TypeObject(typ, additional_bases)
+            is_final = self.ts_finder.is_final(typ)
+            return TypeObject(typ, additional_bases, is_final=is_final)
 
     def _get_recursive_typeshed_bases(
         self, typ: Union[type, str]

pycroscope/relations.py

@@ -9,6 +9,8 @@
 
 import collections.abc
 import enum
+import struct
+import sys
 from collections.abc import Iterable, Iterator, Sequence
 from dataclasses import dataclass, replace
 from types import FunctionType
@@ -19,7 +21,7 @@
 import pycroscope
 from pycroscope.analysis_lib import Sentinel
 from pycroscope.find_unused import used
-from pycroscope.safe import safe_equals, safe_isinstance
+from pycroscope.safe import safe_equals, safe_isinstance, safe_issubclass
 from pycroscope.typevar import resolve_bounds_map
 from pycroscope.value import (
     NO_RETURN_VALUE,
@@ -1374,10 +1376,96 @@ def _intersect_typed(
 ) -> TypeOrIrreducible:
     if isinstance(left, TypedDictValue) and isinstance(right, TypedDictValue):
         return _intersect_typeddict(left, right, ctx)
-    # TODO: Consider more options
+
+    # If either type is final, the intersection reduces to Never unless the final class
+    # is a subclass of the other class. In that case, we treat the intersection as irreducible.
+    # Note that we would have already reduced intersections where the *types* are subtypes;
+    # the irreducible case can happen in certain situations involving generics.
+    left_tobj = left.get_type_object(ctx)
+    right_tobj = right.get_type_object(ctx)
+    if left_tobj.is_final and not left_tobj.is_assignable_to_type_object(right_tobj):
+        return NO_RETURN_VALUE
+    if right_tobj.is_final and not right_tobj.is_assignable_to_type_object(left_tobj):
+        return NO_RETURN_VALUE
+
+    # If both types are nominal and are real (non-synthetic) types, we can mirror CPython's logic
+    # to check whether a child class can exist at runtime.
+    if (
+        not left_tobj.is_protocol
+        and not right_tobj.is_protocol
+        and isinstance(left_tobj.typ, type)
+        and isinstance(right_tobj.typ, type)
+        and not _can_nominal_types_intersect(left_tobj.typ, right_tobj.typ)
+    ):
+        return NO_RETURN_VALUE
+
+    # TODO: Consider more options for reducing the intersection:
+    # - Certain cases involving incompatible metaclasses can return to Never
+    # - Possibly some cases with attributes of incompatible types (possibly debatable)
+    # - Cases involving SequenceValue, DictIncompleteValue, and other concrete subclasses of
+    #   TypedValue
     return Irreducible
 
 
+def _can_nominal_types_intersect(t1: type[object], t2: type[object]) -> bool:
+    sb1 = _solid_base(t1)
+    sb2 = _solid_base(t2)
+    return safe_issubclass(sb1, sb2) or safe_issubclass(sb2, sb1)
+
+
+SIZEOF_PYOBJECT = struct.calcsize("P")
+
+
+def _shape_differs(t1: type[object], t2: type[object]) -> bool:
+    """Check whether two types differ in shape.
+
+    Mirrors the shape_differs() function in typeobject.c in CPython."""
+    if sys.version_info >= (3, 12):
+        return (
+            t1.__basicsize__ != t2.__basicsize__ or t1.__itemsize__ != t2.__itemsize__
+        )
+    else:
+        # CPython had more complicated logic before 3.12:
+        # https://github.com/python/cpython/blob/f3c6f882cddc8dc30320d2e73edf019e201394fc/Objects/typeobject.c#L2224
+        # We attempt to mirror it here well enough to support the most common cases.
+        if t1.__itemsize__ or t2.__itemsize__:
+            return (
+                t1.__basicsize__ != t2.__basicsize__
+                or t1.__itemsize__ != t2.__itemsize__
+            )
+        t_size = t1.__basicsize__
+        if (
+            # TODO: better understanding of attributes of type objects
+            not t2.__weakrefoffset__  # static analysis: ignore[value_always_true]
+            and t1.__weakrefoffset__ + SIZEOF_PYOBJECT == t_size
+        ):
+            t_size -= SIZEOF_PYOBJECT
+        if (
+            not t2.__dictoffset__  # static analysis: ignore[value_always_true]
+            and t1.__dictoffset__ + SIZEOF_PYOBJECT == t_size
+        ):
+            t_size -= SIZEOF_PYOBJECT
+        if (
+            not t2.__weakrefoffset__  # static analysis: ignore[value_always_true]
+            and t2.__weakrefoffset__ == t_size
+        ):
+            t_size -= SIZEOF_PYOBJECT
+        return t_size != t2.__basicsize__
+
+
+def _solid_base(typ: type[object]) -> type[object]:
+    """Return the "solid base" of a type, mirroring the logic in CPython's typeobject.c.
+
+    A "solid base" is a base that determines the shape of the type."""
+    if typ is object:
+        return object
+    base = typ.__base__
+    assert base is not None, f"Type {typ} has no base"
+    if _shape_differs(typ, base):
+        return typ
+    return _solid_base(base)
+
+
 def _intersect_maybe_mutable(
     left: Value,
     left_readonly: bool,

pycroscope/test_relations.py

@@ -47,3 +47,25 @@ def capybara(
 
             assert_type(y, Intersection[A, B])
             assert_type(y.x, Intersection[int, Any])
+
+    @assert_passes()
+    def test_typed_value_intersections(self):
+        from typing_extensions import Never, assert_type, final
+
+        from pycroscope.extensions import Intersection
+
+        class A:
+            x: int
+
+        @final
+        class B:
+            x: str
+
+        def capybara(
+            ab: Intersection[A, B],
+            int_str: Intersection[int, str],
+            a_int: Intersection[A, int],
+        ) -> None:
+            assert_type(ab, Never)
+            assert_type(int_str, Never)
+            assert_type(a_int, Never)  # E: inference_failure

pycroscope/type_object.py

@@ -18,7 +18,7 @@
     Signature,
 )
 
-from .safe import safe_in, safe_isinstance, safe_issubclass
+from .safe import safe_getattr, safe_in, safe_isinstance, safe_issubclass
 from .value import (
     UNINITIALIZED_VALUE,
     AnySource,
@@ -53,6 +53,7 @@ def get_mro(typ: Union[type, super]) -> Sequence[type]:
 class TypeObject:
     typ: Union[type, super, str]
     base_classes: set[Union[type, str]] = field(default_factory=set)
+    is_final: bool = False
     is_protocol: bool = False
     protocol_members: set[str] = field(default_factory=set)
     is_thrift_enum: bool = field(init=False)
@@ -73,6 +74,8 @@ def __post_init__(self) -> None:
         else:
             assert isinstance(self.typ, type), repr(self.typ)
             self.is_universally_assignable = issubclass(self.typ, mock.NonCallableMock)
+            if safe_getattr(self.typ, "__final__", False):
+                self.is_final = True
         self.is_thrift_enum = hasattr(self.typ, "_VALUES_TO_NAMES")
         self.base_classes |= set(get_mro(self.typ))
         # As a special case, the Python type system treats int as

pycroscope/typeshed.py

@@ -287,6 +287,35 @@ def get_argspec_for_fully_qualified_name(
         )
         return sig
 
+    def is_final(self, fq_name: Union[str, type]) -> bool:
+        """Return whether this type is marked as final in the stubs."""
+        if isinstance(fq_name, type):
+            maybe_fq_name = self._get_fq_name(fq_name)
+            if maybe_fq_name is None:
+                return False
+            fq_name = maybe_fq_name
+        info = self._get_info_for_name(fq_name)
+        mod, _ = fq_name.rsplit(".", maxsplit=1)
+        return self._is_final_from_info(info, mod)
+
+    def _is_final_from_info(
+        self, info: typeshed_client.resolver.ResolvedName, mod: str
+    ) -> bool:
+        if info is None:
+            return False
+        if isinstance(info, typeshed_client.ImportedInfo):
+            return self._is_final_from_info(info.info, mod)
+        if isinstance(info, typeshed_client.NameInfo) and isinstance(
+            info.ast, ast.ClassDef
+        ):
+            for deco in info.ast.decorator_list:
+                deco_value = self._parse_expr(deco, mod)
+                if isinstance(deco_value, KnownValue) and is_typing_name(
+                    deco_value.val, "final"
+                ):
+                    return True
+        return False
+
     def get_bases(self, typ: type) -> Optional[list[Value]]:
         """Return the base classes for this type, including generic bases."""
         return self.get_bases_for_value(TypedValue(typ))