[codex] Improve tuple diagnostics and weak container assignability (#449)

JelleZijlstra · web-flow · commit 37e61f156c54 · 2026-04-03T13:10:34.000-07:00
## Summary

This PR improves two related pieces of relation checking.

- preserve the detailed element-level error from tuple-to-tuple
comparisons instead of collapsing it to `tuple is not assignable to
tuple`
- allow strong containers like `list[T]` and `set[T]` to satisfy weak
container literals in the invariant reverse direction when the weak
container could still be empty and all unpacked members accept `T`
- cover the taxonomy-shaped `defaultdict(lambda: ([], []))` case with
low-level regression tests

## Why

The tuple diagnostics change fixes a usability issue where nested tuple
mismatches lost the useful positional explanation produced deeper in the
relation machinery.

The weak-container change fixes a false positive in taxonomy where
annotated tuple values containing strong `list[ClassificationEntry]`
entries were rejected against weak empty-list literals inferred from
`defaultdict(lambda: ([], []))`.

## Impact

Users now get more actionable tuple mismatch errors, and pycroscope
accepts more realistic nested container patterns involving empty list or
set literals without weakening the ordinary
weak-literal-to-strong-container direction.

## 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 --extra tests pytest
pycroscope/test_value.py pycroscope/test_relations.py`
- `UV_CACHE_DIR=/tmp/uv-cache uv run --python 3.14 python
tools/taxonomy_ci.py --local-path /Users/jelle/Dropbox/code/taxonomy
--install | rg "taxonomy/db/export.py at line 741|taxonomy/db/export.py
at line 786|list\[ClassificationEntry\] is not assignable to &lt;list
containing \[\]&gt;"`
diff --git a/docs/changelog.md b/docs/changelog.md
@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- 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`.
 - Fix bare generic-class annotations so user-defined generics like `Capybara` now report `missing_generic_parameters`, and partially specialized forms like `Capybara[int]` report `invalid_specialization`.
 - Fix `hasattr()`-driven narrowing bookkeeping so synthetic attributes no longer show up as fake unused members, and looped identity checks like `value.param_spec is ps_args.param_spec` no longer poison nearby temporary-variable reads.
 - Fix `hasattr()`-based intersection lookup so class-object attributes like `cls.__name__` remain available after narrowing through unrelated `HasAttr[...]` predicates.
diff --git a/pycroscope/relations.py b/pycroscope/relations.py
@@ -885,6 +885,34 @@ def _has_relation(
     if isinstance(left, SequenceValue):
         if isinstance(right, SequenceValue):
             return _has_relation_sequence(left, right, relation, ctx)
+        if (
+            relation is Relation.ASSIGNABLE
+            and left.typ is not tuple
+            and isinstance(right, GenericValue)
+            and right.typ is left.typ
+            and len(right.args) == 1
+        ):
+            # In invariant comparisons we also check the reverse direction, which
+            # can ask whether a strong container[T] satisfies a weak container
+            # literal type. We only allow that when the weak container could
+            # still be empty and every unpacked member type accepts T.
+            right_member = right.args[0]
+            bounds_maps = []
+            for is_many, member in left.members:
+                if not is_many:
+                    return CanAssignError(
+                        f"{right} may be empty and cannot satisfy"
+                        f" known-non-empty {left}"
+                    )
+                can_assign = has_relation(member, right_member, relation, ctx)
+                if isinstance(can_assign, CanAssignError):
+                    return CanAssignError(
+                        f"{right} is not {relation.description} {left}", [can_assign]
+                    )
+                bounds_maps.append(can_assign)
+            if not bounds_maps:
+                return {}
+            return unify_bounds_maps(bounds_maps)
         if (
             left.typ is tuple
             and isinstance(
@@ -922,6 +950,15 @@ def _has_relation(
         return CanAssignError(f"{right} is not {relation.description} {left}")
 
     if isinstance(left, GenericValue):
+        if (
+            isinstance(right, SequenceValue)
+            and left.typ is tuple
+            and right.typ is tuple
+            and tuple_members_from_value(left, ctx) is not None
+        ):
+            return left.get_type_object(ctx).can_assign(
+                left, right, ctx, relation=relation
+            )
         if (
             relation is Relation.ASSIGNABLE
             and isinstance(right, DictIncompleteValue)
@@ -1787,15 +1824,27 @@ def _has_relation_sequence(
     relation: Literal[Relation.SUBTYPE, Relation.ASSIGNABLE],
     ctx: CanAssignContext,
 ) -> CanAssign:
+    # TypeObject.can_assign() does the nominal/container-level compatibility check
+    # for all sequences. For tuple/tuple, it also already performs the full
+    # element-by-element comparison via _compare_tuple_sequences(); preserve that
+    # detailed result instead of replacing it with a generic "tuple is not
+    # assignable to tuple" wrapper here.
     can_assign = left.get_type_object(ctx).can_assign(
         left, right, ctx, relation=relation
     )
     if isinstance(can_assign, CanAssignError):
+        if left.typ is tuple and right.typ is tuple:
+            return can_assign
         return CanAssignError(
             f"{stringify_object(right.typ)} is not {relation.description}"
             f" {stringify_object(left.typ)}"
         )
 
+    # Non-tuple sequences still need the concrete SequenceValue relation pass
+    # below, because the TypeObject check does not compare their known members.
+    if left.typ is tuple and right.typ is tuple:
+        return can_assign
+
     return _compare_tuple_sequences(left, right, relation, ctx)
 
 
diff --git a/pycroscope/test_value.py b/pycroscope/test_value.py
@@ -5,6 +5,7 @@
 import pickle
 import types
 import typing
+from collections import defaultdict
 from typing import NewType
 from unittest import mock
 
@@ -395,6 +396,74 @@ def test_sequence_value() -> None:
     )
 
 
+def test_nested_weak_tuple_value_arg_allows_empty_lists_in_defaultdict() -> None:
+    class Name:
+        pass
+
+    class ClassificationEntry:
+        pass
+
+    left = GenericValue(
+        dict,
+        [
+            TypedValue(Name),
+            SequenceValue(
+                tuple,
+                [
+                    (False, GenericValue(list, [TypedValue(ClassificationEntry)])),
+                    (False, GenericValue(list, [TypedValue(ClassificationEntry)])),
+                ],
+            ),
+        ],
+    )
+    right = GenericValue(
+        defaultdict,
+        [
+            AnyValue(AnySource.generic_argument),
+            SequenceValue(tuple, [(False, KnownValue([])), (False, KnownValue([]))]),
+        ],
+    )
+
+    assert_can_assign(left, right)
+
+
+def test_strong_list_is_assignable_to_empty_weak_list() -> None:
+    assert_can_assign(SequenceValue(list, []), GenericValue(list, [TypedValue(int)]))
+
+
+def test_strong_list_is_assignable_to_weak_list_with_only_unpacked_members() -> None:
+    assert_can_assign(
+        SequenceValue(list, [(True, TypedValue(object))]),
+        GenericValue(list, [TypedValue(int)]),
+    )
+
+
+def test_strong_set_is_assignable_to_weak_set_with_only_unpacked_members() -> None:
+    assert_can_assign(
+        SequenceValue(set, [(True, TypedValue(object))]),
+        GenericValue(set, [TypedValue(int)]),
+    )
+
+
+def test_strong_container_is_not_assignable_to_known_non_empty_weak_literal() -> None:
+    result = SequenceValue(list, [(False, KnownValue(1))]).can_assign(
+        GenericValue(list, [TypedValue(int)]), CTX
+    )
+
+    assert isinstance(result, CanAssignError)
+    assert result.message == (
+        "list[int] may be empty and cannot satisfy"
+        " known-non-empty <list containing [Literal[1]]>"
+    )
+
+
+def test_weak_list_is_still_assignable_to_strong_list() -> None:
+    assert_can_assign(
+        GenericValue(list, [TypedValue(int)]),
+        SequenceValue(list, [(False, KnownValue(1))]),
+    )
+
+
 def test_sequence_value_unpack() -> None:
     fmt_map = {"i": int, "s": str, "b": bool, "o": object}
 
