fix(parametric-is): resolve a subclass's arguments down its base chain

the probe assumed a subclass's type arguments line up positionally with its
base's, so `class Odd[T](list[int])` reported `T` as list's argument:
`Odd[str]() is list[str]` answered True even though `Odd` is a `list[int]`.
a reordering base (`class Swap[A, B](dict[B, A])`) was wrong the same way.

arguments are now resolved down the declared base chain, substituting the
type parameters into each base, so a base that fixes, reorders or nests its
arguments is followed faithfully. this subsumes both default patches: a bare
class starts from its own pep 696 defaults and the same walk carries them
through, so the special cases for own-identity and base-recorded parameters
collapse into one mechanism.

the positional rule survives only as a last resort, after resolution fails,
for a builtin registered as a *virtual* subclass of an abc (`list` for
`Sequence`) which has no base to walk. because it now runs on the resolved
base rather than the original subclass, `Odd[str]` reaches it as `list[int]`
and still answers `Sequence[int]` correctly.

fix(parametric-is): resolve own-identity type-param defaults

a type parameter that appears only in the class's own identity
(`class A[T = Never]`) is recorded in no base, so the mro walk had nothing
to resolve and the probe found no arguments at all. read it straight off
`__type_params__` instead.

this is precisely the case constructor reification cannot cover: it fills
defaults by injecting `A[int]()`, but only when the default has a runtime
spelling, so an unspellable one like `Never` leaves the constructor bare.
the two mechanisms are complementary — injection covers own-identity
parameters with spellable defaults, this covers the rest.

restricted to `klass is origin`: a subclass's parameters have no positional
relationship to a base's, so `class Odd[T = str](list[int])` must not report
`str` as list's argument.

fix(parametric-is): resolve pep 696 defaults in the runtime probe

a class records its generic bases *unsubstituted* — `class L[T = Never]
(list[T])` stores `list[T]`, never `list[Never]` — so the probe was
comparing a bare TypeVar against the target and never matching. a
parameter left at its default now resolves to that default, so
`L() is list[Never]` answers True.

the substitution is applied only when the value records no explicit
`__orig_class__`: an `L[int]()` fixes `T` itself, and reading the class
default over the top of that would report an argument the value never had
(`L[str]() is list[int]` must stay False).

Author: KotlinIsland

crates/by_transforms/src/transforms/parametric_is.rs

@@ -85,29 +85,97 @@ pub(crate) fn variance_tuple(variances: &[u8]) -> String {
 }
 
 pub(crate) const PARAMETRIC_IS_RUNTIME: &str = "\
+def _by_type_param_defaults(args):
+    # a class records its generic bases *unsubstituted* — `class L[T = Never]
+    # (list[T])` stores `list[T]`, never `list[Never]` — so a type parameter
+    # left at its pep 696 default resolves to that default rather than staying a
+    # bare TypeVar that matches nothing
+    resolved = []
+    substituted = False
+    for arg in args:
+        has_default = getattr(arg, \"has_default\", None)
+        if has_default is not None and has_default():
+            resolved.append(arg.__default__)
+            substituted = True
+        else:
+            resolved.append(arg)
+    return tuple(resolved) if substituted else args
+
+def _by_subst(annotation, mapping):
+    # replace type parameters with the arguments bound to them, rebuilding
+    # nested aliases (`list[dict[str, T]]` with `T = int` → `list[dict[str, int]]`)
+    try:
+        if annotation in mapping:
+            return mapping[annotation]
+    except TypeError:
+        pass
+    args = getattr(annotation, \"__args__\", ())
+    if not args:
+        return annotation
+    replaced = tuple(_by_subst(arg, mapping) for arg in args)
+    if replaced == args:
+        return annotation
+    origin = getattr(annotation, \"__origin__\", None)
+    if origin is None:
+        return annotation
+    try:
+        return origin[replaced]
+    except TypeError:
+        return annotation
+
+def _by_specialize(alias, origin, depth=0):
+    # the arguments with which `alias` satisfies `origin`, resolved *down the
+    # declared base chain* rather than assumed to line up positionally. a base
+    # that fixes or reorders its arguments is then followed faithfully:
+    # `class Odd[T](list[int])` is a `list[int]` whatever `T` is, and
+    # `class Swap[A, B](dict[B, A])` specializes `dict` in the other order
+    if depth > 16:
+        return None
+    klass = getattr(alias, \"__origin__\", alias)
+    if not isinstance(klass, type):
+        return None
+    args = getattr(alias, \"__args__\", ())
+    params = getattr(klass, \"__type_params__\", ())
+    if not args:
+        defaulted = _by_type_param_defaults(params)
+        if defaulted is not params:
+            args = defaulted
+    if klass is origin:
+        return args or None
+    mapping = {}
+    for param, arg in zip(params, args):
+        try:
+            mapping[param] = arg
+        except TypeError:
+            pass
+    bases = klass.__dict__.get(\"__orig_bases__\")
+    if bases is None:
+        # a class inheriting only plain classes records no `__orig_bases__`
+        bases = getattr(klass, \"__bases__\", ())
+    for base in bases:
+        found = _by_specialize(_by_subst(base, mapping) if mapping else base, origin, depth + 1)
+        if found is not None:
+            return found
+    # the declared bases don't reach `origin`: a builtin registered as a *virtual*
+    # subclass of an abc (`list` for `Sequence`) has no base to walk. its
+    # arguments do line up positionally once membership is established. this runs
+    # only after resolution has failed, so it applies to the already-resolved base
+    # (`list[int]`), never to a subclass that fixes or reorders arguments
+    if args and isinstance(origin, type):
+        try:
+            if issubclass(klass, origin):
+                return args
+        except TypeError:
+            pass
+    return None
+
 def _by_generic_args(value, origin):
-    found = []
-    def consider(alias):
-        base_origin = getattr(alias, \"__origin__\", None)
-        if base_origin is origin:
-            found.append(getattr(alias, \"__args__\", ()))
-        elif isinstance(base_origin, type) and isinstance(origin, type):
-            # a specialization of a sub-origin (`list[int]` for a `Sequence`
-            # target) carries the arguments through inheritance, matched by
-            # position once membership is established
-            try:
-                is_sub = issubclass(base_origin, origin)
-            except TypeError:
-                is_sub = False
-            if is_sub:
-                found.append(getattr(alias, \"__args__\", ()))
+    # an explicit `A[int]()` records its specialization on the instance;
+    # otherwise the class itself is the starting point and any pep 696 defaults
+    # stand in for the arguments it was constructed with
     reified = getattr(value, \"__orig_class__\", None)
-    if reified is not None:
-        consider(reified)
-    for klass in type(value).__mro__:
-        for base in klass.__dict__.get(\"__orig_bases__\", ()):
-            consider(base)
-    return found
+    found = _by_specialize(reified if reified is not None else type(value), origin)
+    return [found] if found is not None else []
 
 def _parametric_is(value, alias, variances):
     alias = getattr(alias, \"__value__\", alias)

crates/by_transforms/tests/parametric_is_runtime.rs

@@ -24,7 +24,7 @@ use by_transforms::{Config, PythonVersion, transpile};
 /// annotation, a covariant read-only member, a nested-generic member, a missing
 /// member, and an inheriting subclass.
 const PROGRAM: &str = r#"
-from typing import Literal, Protocol
+from typing import Literal, Never, Protocol
 
 class HasA[T](Protocol):
     a: T
@@ -159,6 +159,67 @@ assert (GetBool() is Get[bool]) is True, "return matches bool"
 assert (GetBool() is Get[int]) is True, "return covariant: bool <: int"
 assert (GetBool() is Get[str]) is False, "return bool is not str"
 
+# a class records its generic bases *unsubstituted* (`class L[T = Never]
+# (list[T])` stores `list[T]`), so a type parameter left at its pep 696 default
+# must resolve to that default — otherwise the probe compares a bare TypeVar and
+# never matches
+class DefaultNever[T = Never](list[T]): ...
+
+class DefaultInt[T = int](list[T]): ...
+
+assert (DefaultNever() is list[Never]) is True, "a defaulted parameter resolves to its default"
+assert (DefaultNever() is list[int]) is False, "the default is not some other argument"
+assert (DefaultInt() is list[int]) is True, "a non-Never default resolves too"
+
+# an *explicit* specialization wins over the default: reading the default over
+# the top of it would report an argument the value never had
+assert (DefaultInt[str]() is list[str]) is True, "the explicit argument matches"
+assert (DefaultInt[str]() is list[int]) is False, "the default must not leak in"
+
+# a parameter with no default stays unknown, so it matches nothing
+class NoDefault[T](list[T]): ...
+
+assert (NoDefault() is list[int]) is False, "an unknown argument matches nothing"
+
+# a parameter that appears *only* in the class's own identity is recorded in no
+# base at all, so it is read straight off `__type_params__`. `Never` has no
+# runtime spelling, so the constructor is left bare — this is exactly the case
+# type reification cannot cover
+class OwnNever[T = Never]:
+    a: T
+
+assert (OwnNever() is OwnNever[Never]) is True, "an own-identity default resolves"
+assert (OwnNever() is OwnNever[int]) is False, "and is not some other argument"
+
+# a subclass's arguments are resolved *down the declared base chain*, never
+# assumed to line up positionally with the base's. `Odd` is a `list[int]`
+# whatever `T` is, so `T` must never be reported as list's argument
+class Odd[T = str](list[int]): ...
+
+assert (Odd() is list[int]) is True, "the base's written argument stands"
+assert (Odd() is list[str]) is False, "the subclass's own argument is not the base's"
+assert (Odd[str]() is list[int]) is True, "explicit argument, base still fixed"
+assert (Odd[str]() is list[str]) is False, "an explicit argument is not the base's either"
+
+# a base may also *reorder* its arguments
+class Swap[A, B](dict[B, A]): ...
+
+assert (Swap[int, str]() is dict[str, int]) is True, "the base's order is followed"
+assert (Swap[int, str]() is dict[int, str]) is False, "not the subclass's order"
+
+# a base may nest the parameter
+class Wrap[T](list[dict[str, T]]): ...
+
+assert (Wrap[int]() is list[dict[str, int]]) is True, "a nested parameter substitutes"
+assert (Wrap[int]() is list[dict[str, bool]]) is False, "and stays exact"
+
+# plain (non-generic) inheritance is still followed to the generic base
+class Plain(list[int]): ...
+
+class Deeper(Plain): ...
+
+assert (Deeper() is list[int]) is True, "a plain subclass inherits the specialization"
+
 # a *literal* type argument (`A[True]`) specializes the member to
 # `Literal[True]`, rebuilt at runtime by `_by_lit`. an invariant data member
 # stays exact — a `bool` annotation is not a `Literal[True]`