[codex] Fix type literal substitution regressions (#456)

JelleZijlstra · web-flow · commit 4a73f34cebfc · 2026-04-03T19:22:08.000-07:00
## Summary
- stop `type[T]` substitution from raising internal errors when
inference feeds back singleton literals or `None`
- keep generated-callable names readable by omitting a bogus `None.`
module prefix
- add both low-level and `@assert_passes()` regressions for the
taxonomy-shaped `type[T] | T` path

## Root Cause
Latest `main` made `SubclassValue.make()` strict again, which meant
generic specialization for patterns like `type[T] | T` could crash when
`T` was inferred from a singleton runtime value and then substituted
back into the `type[T]` branch. Taxonomy hits this through ADT-style
singleton tags.

Separately, some generated callables can have `__module__ = None`, and
`stringify_object()` was rendering that directly into messages.

## Impact
This removes the new taxonomy internal errors without bringing back the
broader callable-reset change in `checker.py`. Error messages for
generated callables also stay readable.

## Validation
- `UV_CACHE_DIR=/tmp/uv-cache uv run --python 3.14 --extra tests pytest`
- `UV_CACHE_DIR=/tmp/uv-cache uv run --python 3.14 python
tools/taxonomy_ci.py --local-path /Users/jelle/Dropbox/code/taxonomy
--install`

## Taxonomy Artifact
- regenerated raw errors:
`/Users/jelle/py/pycroscope/tmp/taxonomy/raw-errors-2026-04-03-minimal-main.txt`
diff --git a/docs/changelog.md b/docs/changelog.md
@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Avoid internal errors for some constructor-style generic patterns like `type[T] | T`, and stop showing a misleading `None.` module prefix in messages for generated callables.
 - Make `type()` results more consistent for imprecise values like `str`, `type[T]`, and `super()`, so pycroscope preserves subclass-aware class objects where appropriate and stops relying on implicit fallback behavior for internal type values.
 - 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.
diff --git a/pycroscope/test_name_check_visitor.py b/pycroscope/test_name_check_visitor.py
@@ -1859,6 +1859,37 @@ class Child(Base):
         def capybara(cls: type[Base]) -> None:
             cls.clirm_backrefs.append(1)
 
+    @assert_passes(run_in_both_module_modes=True)
+    def test_type_or_instance_parameter_does_not_crash_on_singleton_substitution(self):
+        from collections.abc import Iterable, Sequence
+        from typing import TypeVar
+
+        ADTT = TypeVar("ADTT", bound="ADT")
+
+        class ADT:
+            pass
+
+        class Child(ADT):
+            pass
+
+        class Tags:
+            child = Child()
+
+        def get_tags(
+            tags: Sequence[ADT] | None, tag_cls: type[ADTT] | ADTT, expected: ADTT
+        ) -> Iterable[ADTT]:
+            if tags is None:
+                return
+            for tag in tags:
+                if isinstance(tag_cls, type):
+                    if isinstance(tag, tag_cls):
+                        yield tag
+                elif tag is tag_cls:
+                    yield tag
+
+        def capybara(tags: Sequence[ADT]) -> None:
+            list(get_tags(tags, Tags.child, Tags.child))
+
     @assert_passes(run_in_both_module_modes=True)
     def test_metaclass_initialized_class_attribute_on_type_object(self):
         from typing import ClassVar
diff --git a/pycroscope/test_value.py b/pycroscope/test_value.py
@@ -6,10 +6,9 @@
 import types
 import typing
 from collections import defaultdict
-from typing import NewType
+from typing import Any, NewType, cast
 from unittest import mock
 
-import pytest
 from typing_extensions import Protocol, TypeVarTuple, runtime_checkable
 
 from . import tests, value
@@ -341,8 +340,20 @@ def test_subclass_value() -> None:
 
 
 def test_subclass_value_make_invalid_literal() -> None:
-    with pytest.raises(TypeError, match=r"Cannot construct type\[\.\.\.\]"):
-        SubclassValue.make(KnownValue(1))
+    assert SubclassValue.make(KnownValue(1)) == AnyValue(AnySource.error)
+
+
+def test_subclass_value_make_none_literal() -> None:
+    assert SubclassValue.make(KnownValue(None)) == SubclassValue(TypedValue(type(None)))
+
+
+def test_stringify_object_without_module_name() -> None:
+    def generated() -> None:
+        pass
+
+    cast(Any, generated).__module__ = None
+    cast(Any, generated).__qualname__ = "Generated.__init__"
+    assert value.stringify_object(generated) == "Generated.__init__"
 
 
 def test_generic_value() -> None:
diff --git a/pycroscope/value.py b/pycroscope/value.py
@@ -2810,16 +2810,24 @@ def make(cls, origin: Value) -> Value:
 
         This should only be called with values that are valid as the argument to
         ``type[...]``: a type expression, ``Any``, a ``TypeVar``, or a union of
-        those. Passing class objects or arbitrary values is a caller bug.
+        those. If inference substitutes a runtime class object or literal value
+        here, preserve the class case and degrade other invalid inputs instead of
+        crashing.
         """
         if isinstance(origin, MultiValuedValue):
             return unite_values(*[cls.make(val) for val in origin.vals])
         if isinstance(origin, AnyValue):
             # Type[Any] is equivalent to plain type
             return TypedValue(type)
+        if isinstance(origin, KnownValue):
+            if origin.val is None:
+                return cls(TypedValue(type(None)))
+            if isinstance(origin.val, type):
+                return cls(TypedValue(origin.val))
+            return AnyValue(AnySource.error)
         if isinstance(origin, (TypeVarValue, TypedValue)):
             return cls(origin)
-        raise TypeError(f"Cannot construct type[...] from {origin!r}")
+        return AnyValue(AnySource.inference)
 
 
 @dataclass(frozen=True, order=False)
@@ -4646,12 +4654,16 @@ def stringify_object(obj: Any) -> str:
         objclass = getattr(obj, "__objclass__", None)
         if objclass is not None:
             return f"{stringify_object(objclass)}.{obj.__name__}"
-        if obj.__module__ == BUILTIN_MODULE:
-            return obj.__name__
-        elif hasattr(obj, "__qualname__"):
-            return f"{obj.__module__}.{obj.__qualname__}"
-        else:
-            return f"{obj.__module__}.{obj.__name__}"
+        module_name = getattr(obj, "__module__", None)
+        qualname = getattr(obj, "__qualname__", None)
+        name = getattr(obj, "__name__", None)
+        if module_name == BUILTIN_MODULE and name is not None:
+            return name
+        if qualname is not None:
+            return f"{module_name}.{qualname}" if module_name else qualname
+        if name is not None:
+            return f"{module_name}.{name}" if module_name else name
+        return repr(obj)
     except Exception:
         return repr(obj)
 
