[codex] Simplify type-value normalization (#454)

JelleZijlstra · web-flow · commit 9e5555e1c5e9 · 2026-04-03T15:40:44.000-07:00
## Summary
- make `Value.get_type_value()` context-aware so type-value computation
can reuse normal simplification rules
- simplify `IntersectionValue.get_type_value()` via `intersect_multi()`
and `MultiValuedValue.get_type_value()` via `unite_values()`
- model predicate type-values as `type[object]` and add regression tests
for `hasattr()`-guarded constructor calls

## Why
Taxonomy hit confusing constructor overloads after `hasattr()` narrowing
because `type(tag)` preserved predicate-derived fallback class branches
instead of simplifying back to the real class object.

## Root cause
`get_type_value()` was context-free and
`IntersectionValue.get_type_value()` just wrapped member type-values in
a new intersection without normalizing them. That left callable fallback
members in place long enough for constructor signature collection to
turn them into spurious overloads like `object.__init__`.

## Testing
- `UV_CACHE_DIR=/tmp/uv-cache uv run --python 3.14 --extra tests pytest
pycroscope/test_value.py pycroscope/test_constructors.py`
diff --git a/docs/changelog.md b/docs/changelog.md
@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Simplify `type()` lookups through narrowed intersections, so `hasattr()`-guarded class-object calls preserve the real constructor signature instead of picking up confusing fallback overloads like `object.__init__`.
 - Fix assignability involving weak list literals in nested invariant containers, so values like `defaultdict(lambda: ([], []))` can satisfy annotated tuple-valued `dict` entries instead of failing on the inner empty-list literals.
 - Improve nested tuple mismatch diagnostics so assignments involving tuple-valued generics now report which tuple element failed instead of the vague message `tuple is not assignable to tuple`.
 - Add an opt-in `--find-unused-call-patterns` check, plus `enforce_no_unused_call_patterns`, to report parameters whose accepted call shapes are only partially exercised, including always-omitted defaults, one-sided boolean flags, and unused union members.
diff --git a/pycroscope/implementation.py b/pycroscope/implementation.py
@@ -2212,7 +2212,7 @@ def _subclasses_impl(ctx: CallContext) -> Value:
 
 
 def _type_impl(ctx: CallContext) -> Value:
-    return ctx.vars["object"].get_type_value()
+    return ctx.vars["object"].get_type_value(ctx.visitor)
 
 
 def _assert_is_impl(ctx: CallContext) -> ImplReturn:
diff --git a/pycroscope/name_check_visitor.py b/pycroscope/name_check_visitor.py
@@ -13675,7 +13675,7 @@ def _get_dunder(
         elif isinstance(callee_val, KnownValueWithTypeVars):
             fallback_lookup_val = callee_val
         else:
-            fallback_lookup_val = callee_val.get_type_value()
+            fallback_lookup_val = callee_val.get_type_value(self)
         if isinstance(synthetic_lookup_val, TypedValue) and isinstance(
             synthetic_lookup_val.typ, str
         ):
diff --git a/pycroscope/test_constructors.py b/pycroscope/test_constructors.py
@@ -1,10 +1,31 @@
 # static analysis: ignore
 
+from .error_code import ErrorCode
 from .test_name_check_visitor import TestNameCheckVisitorBase
 from .test_node_visitor import assert_passes
 
 
 class TestConstructors(TestNameCheckVisitorBase):
+    def test_hasattr_constructor_does_not_add_object_overload(self):
+        errors = self._run_str(
+            """
+            class C:
+                def __init__(self, x: int) -> None:
+                    self.x = x
+
+            def f(c: C) -> None:
+                if hasattr(c, "name"):
+                    type(c)(name=1)
+            """,
+            expect_failure=False,
+            fail_after_first=False,
+        )
+        assert len(errors) == 1
+        error = errors[0]
+        assert error["code"] == ErrorCode.incompatible_call
+        assert "object.__init__" not in error["message"]
+        assert "C.__init__" in error["message"]
+
     @assert_passes()
     def test_metaclass_call(self):
         from typing import Type
diff --git a/pycroscope/test_value.py b/pycroscope/test_value.py
@@ -964,6 +964,22 @@ def test_predicate_intersection() -> None:
     assert_can_assign(pred, inters)
 
 
+def test_predicate_get_type_value_uses_subclass_object() -> None:
+    pred = value.PredicateValue(MinLen(1))
+    assert pred.get_type_value(CTX) == SubclassValue(TypedValue(object))
+
+
+def test_intersection_get_type_value_simplifies() -> None:
+    pred = value.PredicateValue(MinLen(1))
+    inters = IntersectionValue((TypedValue(str), pred))
+    assert inters.get_type_value(CTX) == KnownValue(str)
+
+
+def test_union_get_type_value_uses_unite_values() -> None:
+    union = MultiValuedValue([KnownValue(True), KnownValue(False)])
+    assert union.get_type_value(CTX) == KnownValue(bool)
+
+
 def test_overlapping_value_intersection_simplifies() -> None:
     overlapping_int = OverlappingValue(TypedValue(int))
 
diff --git a/pycroscope/type_object.py b/pycroscope/type_object.py
@@ -3983,13 +3983,13 @@ def _protocol_classmethod_receiver_value(
         receiver_type = _receiver_type_value(receiver_value, ctx)
         if receiver_type is not None:
             return SubclassValue.make(receiver_type)
-        return SubclassValue.make(receiver_value.get_type_value())
+        return SubclassValue.make(receiver_value.get_type_value(ctx))
     receiver_key = _class_key_from_value(receiver_value)
     if receiver_key is not None:
         class_object = _class_object_value_for_key(receiver_key, ctx)
         if class_object is not None:
             return class_object
-    return SubclassValue.make(receiver_value.get_type_value())
+    return SubclassValue.make(receiver_value.get_type_value(ctx))
 
 
 def _merge_protocol_receiver_typevars(
diff --git a/pycroscope/value.py b/pycroscope/value.py
@@ -643,7 +643,7 @@ def get_fallback_value(self) -> Optional["Value"]:
         """
         return None
 
-    def get_type_value(self) -> "Value":
+    def get_type_value(self, ctx: "CanAssignContext") -> "Value":
         """Return the type of this object as used for dunder lookups."""
         return self
 
@@ -975,8 +975,8 @@ def __str__(self) -> str:
     def get_fallback_value(self) -> Value:
         return self.runtime_value
 
-    def get_type_value(self) -> Value:
-        return self.runtime_value.get_type_value()
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
+        return self.runtime_value.get_type_value(ctx)
 
     def substitute_typevars(self, typevars: TypeVarMap) -> "PartialValue":
         return PartialValue(
@@ -1018,8 +1018,8 @@ def __str__(self) -> str:
     def get_fallback_value(self) -> Value:
         return self.runtime_value
 
-    def get_type_value(self) -> Value:
-        return self.runtime_value.get_type_value()
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
+        return self.runtime_value.get_type_value(ctx)
 
     def substitute_typevars(self, typevars: TypeVarMap) -> "PartialCallValue":
         return PartialCallValue(
@@ -1057,8 +1057,8 @@ def __str__(self) -> str:
     def get_fallback_value(self) -> Value:
         return TypedValue(super)
 
-    def get_type_value(self) -> Value:
-        return self.get_fallback_value().get_type_value()
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
+        return self.get_fallback_value().get_type_value(ctx)
 
     def substitute_typevars(self, typevars: TypeVarMap) -> "SuperValue":
         return SuperValue(
@@ -1564,8 +1564,8 @@ def is_type(self, typ: type) -> bool:
     def get_type(self) -> type | None:
         return self.get_value().get_type()
 
-    def get_type_value(self) -> Value:
-        return self.get_value().get_type_value()
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
+        return self.get_value().get_type_value(ctx)
 
     def can_overlap(
         self, other: Value, ctx: CanAssignContext, mode: OverlapMode
@@ -1631,7 +1631,7 @@ def get_type_object(
     ) -> "pycroscope.type_object.TypeObject":
         return ctx.make_type_object(type(self.val))
 
-    def get_type_value(self) -> Value:
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
         return KnownValue(type(self.val))
 
     def can_overlap(
@@ -1813,7 +1813,7 @@ def is_type(self, typ: type) -> bool:
     def get_type(self) -> type:
         return type(self.get_method())
 
-    def get_type_value(self) -> Value:
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
         return KnownValue(type(self.get_method()))
 
     def can_overlap(
@@ -2043,7 +2043,7 @@ def get_type(self) -> type | None:
             return None
         return self.typ
 
-    def get_type_value(self) -> Value:
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
         if isinstance(self.typ, str):
             return AnyValue(AnySource.inference)
         return KnownValue(self.typ)
@@ -2102,8 +2102,8 @@ def can_overlap(
             return CanAssignError(f"NewTypes {self} and {other} cannot overlap")
         return super().can_overlap(other, ctx, mode)
 
-    def get_type_value(self) -> Value:
-        return self.value.get_type_value()
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
+        return self.value.get_type_value(ctx)
 
     def get_fallback_value(self) -> Value:
         return self.value
@@ -2596,7 +2596,7 @@ def walk_values(self) -> Iterable["Value"]:
         yield self
         yield from self.class_type.walk_values()
 
-    def get_type_value(self) -> Value:
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
         if isinstance(self.class_type.typ, type):
             return KnownValue(type(self.class_type.typ))
         return TypedValue(type)
@@ -2782,7 +2782,7 @@ def get_type(self) -> type | None:
         else:
             return None
 
-    def get_type_value(self) -> Value:
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
         typ = self.get_type()
         if typ is not None:
             return KnownValue(typ)
@@ -2837,8 +2837,10 @@ def walk_values(self) -> Iterable[Value]:
         for val in self.vals:
             yield from val.walk_values()
 
-    def get_type_value(self) -> Value:
-        return IntersectionValue(tuple(val.get_type_value() for val in self.vals))
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
+        return pycroscope.relations.intersect_multi(
+            [val.get_type_value(ctx) for val in self.vals], ctx
+        )
 
     def __str__(self) -> str:
         return " & ".join(str(val) for val in self.vals)
@@ -2860,8 +2862,8 @@ def walk_values(self) -> Iterable[Value]:
     def get_fallback_value(self) -> Value:
         return TypedValue(object)
 
-    def get_type_value(self) -> Value:
-        return self.get_fallback_value().get_type_value()
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
+        return self.get_fallback_value().get_type_value(ctx)
 
     def __str__(self) -> str:
         return f"Overlapping[{self.type}]"
@@ -2902,10 +2904,10 @@ def can_overlap(
             errors.append(error)
         return CanAssignError("Cannot overlap with Union", errors)
 
-    def get_type_value(self) -> Value:
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
         if not self.vals:
             return self
-        return MultiValuedValue([val.get_type_value() for val in self.vals])
+        return unite_values(*[val.get_type_value(ctx) for val in self.vals])
 
     def decompose(self) -> Iterable[Value]:
         return self.vals
@@ -3061,8 +3063,8 @@ def get_fallback_value(self) -> Value:
             return unite_values(*self.typevar_param.constraints)
         return AnyValue(AnySource.inference)  # TODO: should be object
 
-    def get_type_value(self) -> Value:
-        return self.get_fallback_value().get_type_value()
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
+        return self.get_fallback_value().get_type_value(ctx)
 
     def __str__(self) -> str:
         return str(self.typevar_param)
@@ -3106,8 +3108,8 @@ def can_overlap(
     def get_fallback_value(self) -> Value:
         return AnyValue(AnySource.inference)
 
-    def get_type_value(self) -> Value:
-        return self.get_fallback_value().get_type_value()
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
+        return self.get_fallback_value().get_type_value(ctx)
 
     def __str__(self) -> str:
         return str(self.typevar)
@@ -3724,8 +3726,8 @@ def is_type(self, typ: type) -> bool:
     def get_type(self) -> type | None:
         return self.value.get_type()
 
-    def get_type_value(self) -> Value:
-        return self.value.get_type_value()
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
+        return self.value.get_type_value(ctx)
 
     def substitute_typevars(self, typevars: TypeVarMap) -> Value:
         metadata = tuple(val.substitute_typevars(typevars) for val in self.metadata)
@@ -3881,8 +3883,10 @@ def __str__(self) -> str:
     def substitute_typevars(self, typevars: TypeVarMap) -> Value:
         return PredicateValue(self.predicate.substitute_typevars(typevars))
 
-    def get_type_value(self) -> Value:
-        return KnownValue(object)
+    def get_type_value(self, ctx: CanAssignContext) -> Value:
+        # A predicate only preserves that the runtime class is some subclass of
+        # `object`, not an exact class object.
+        return SubclassValue(TypedValue(object))
 
     def walk_values(self) -> Iterable[Value]:
         yield self
