Disambiguate unions independent of member class order (#230)

[vineethsaivs]

Fixes #230.

Problem

create_default_dis_func (aka create_uniq_field_dis_func) fails to disambiguate a valid union depending on the order its member classes are passed in.

from attrs import define
from cattrs import Converter
from cattrs.disambiguators import create_default_dis_func

@define
class A: ab: int; a: str
@define
class B: ab: int; bc: int
@define
class C: bc: int

c = Converter()
create_default_dis_func(c, A, B, C)   # ok
create_default_dis_func(c, B, A, C)   # TypeError: <class 'C'> has no usable non-default attributes

A valid assignment exists (A -> a, B -> ab, C -> bc), and 3 of the 6 orderings find it while the other 3 raise.

Root cause

The "unique keys" branch resolves discriminator fields in a single fixed-order pass. For each class it subtracts the fields of every not-yet-pinned class and takes what's left as that class's unique fields. A class whose fields are all shared with another still-unpinned class therefore gets no unique field and is pushed into the single fallback slot; a second such class then raises. Since the processing order is fixed up front (sorted once by field count) and never re-selects which class to pin next, whether the valid assignment is found depends on the input order. In the example, if C is processed while B is still unpinned, C's only field bc is shared with B, so C has no unique field even though pinning B on ab first would free bc for C.

Fix

Resolve unique fields iteratively to a fixpoint. On each pass, pin every class that has a non-default field unique among the classes not yet pinned. Pinning a class removes its fields from consideration, which can make a previously ambiguous class uniquely identifiable, so passes repeat until one pins nothing. The single class that still cannot be pinned becomes the fallback; more than one remaining is a genuine ambiguity and still raises TypeError. This is order-independent and contained to the one function; the discriminator-literal path and both dis_func variants are unchanged.

The generated dis_func still checks keys in insertion (pin) order, and that stays correct: a class is pinned only on a field unique among the classes still unpinned on that pass, so its key cannot appear in the payload of any class pinned later or in the fallback, and an earlier-pinned class's key cannot appear in a later class's payload.

Test

test_disambiguation_is_order_independent builds the union above and asserts that all 6 orderings both succeed and route each member's payload back to the correct class. It fails on the current code (3 of 6 orderings raise) and passes with this change. The existing test_edge_errors cases (no fields, shared single field, unhelpful discriminator, and the fallback cases) still pass, as do the union suites.

[codspeed-hq]

Merging this PR will not alter performance

✅ 64 untouched benchmarks

---

_{Comparing vineethsaivs:fix/disambiguate-order-independent (b2d0716) with main (3d07082)¹}

Footnotes

1. No successful run was found on main (d7de3c2) during the generation of this report, so 3d07082 was used instead as the comparison base. There might be some changes unrelated to this pull request in this report. ↩

[Tinche]

Interesting! LGTM. Will re-review in a couple of days and maybe merge. Thanks.