Do a better job substituting into types

Author: msullivan

tests/test_type_dir.py

@@ -286,6 +286,27 @@ def test_type_dir_7():
     assert d is int
 
 
+class Simple[T]:
+    simple: T
+
+
+class Funny[T](Simple[list[T]]):
+    pass
+
+
+class Funny2(Funny[int]):
+    pass
+
+
+def test_type_dir_8():
+    d = eval_typing(Funny2)
+
+    assert format_helper.format_class(d) == textwrap.dedent("""\
+        class Funny2:
+            simple: list[int]
+    """)
+
+
 def _get_member(members, name):
     return next(
         iter(m for m in members.__args__ if m.__args__[0].__args__[0] == name)

typemap/type_eval/_apply_generic.py

@@ -4,7 +4,11 @@
 import types
 import typing
 
+from typing import _GenericAlias as typing_GenericAlias  # type: ignore [attr-defined]  # noqa: PLC2701
+
+
 from . import _eval_typing
+from . import _typing_inspect
 
 if typing.TYPE_CHECKING:
     from typing import Any
@@ -44,8 +48,17 @@ def dump(self, *, _level: int = 0):
             b.dump(_level=_level + 1)
 
 
+def substitute(ty, args):
+    if ty in args:
+        return args[ty]
+    elif isinstance(ty, (typing_GenericAlias, types.GenericAlias)):
+        return ty.__origin__[*[substitute(t, args) for t in ty.__args__]]
+    else:
+        return ty
+
+
 def box(cls: type[Any]) -> Boxed:
-    def _box(cls: type[Any], args: dict[str, Any]) -> Boxed:
+    def _box(cls: type[Any], args: dict[Any, Any]) -> Boxed:
         boxed_bases: list[Boxed] = []
 
         orig_bases = cls.__dict__.get("__orig_bases__")
@@ -60,14 +73,12 @@ def _box(cls: type[Any], args: dict[str, Any]) -> Boxed:
 
                 if issubclass(base, typing.Generic):
                     if base_params := getattr(base, "__parameters__", None):
+                        # obase should be _GenericAlias...
                         boxed_args = {}
                         for param, arg in zip(
                             base_params, obase.__args__, strict=True
                         ):
-                            if arg in args:
-                                boxed_args[param] = args[arg]
-                            else:
-                                boxed_args[param] = arg
+                            boxed_args[param] = substitute(arg, args)
                     else:
                         boxed_args = {}
 
@@ -85,7 +96,7 @@ def _box(cls: type[Any], args: dict[str, Any]) -> Boxed:
         cls = cls.__origin__
     else:
         if params := getattr(cls, "__parameters__", None):
-            args = {p: p for p in params}
+            args = {p: _typing_inspect.param_default(p) for p in params}
         else:
             args = {}
 
@@ -120,7 +131,7 @@ def merge_boxed_mro(seqs: list[list[Boxed]]) -> list[Boxed]:
 
 def _compute_mro(C: Boxed) -> list[Boxed]:
     return merge_boxed_mro(
-        [[C]] + list(map(_compute_mro, C.bases)) + [list(C.bases)]
+        [[C]] + [_compute_mro(b) for b in C.bases] + [list(C.bases)]
     )
 
 

typemap/type_eval/_eval_operators.py

@@ -423,10 +423,7 @@ def _get_defaults(base_head):
         return (typing.Any, SpecialFormEllipsis)
 
     if params := _get_params(base_head):
-        return tuple(
-            typing.Any if t.__default__ == typing.NoDefault else t.__default__
-            for t in params
-        )
+        return tuple(_typing_inspect.param_default(p) for p in params)
 
     return (typing.Any,) * arity
 

typemap/type_eval/_eval_typing.py

@@ -9,7 +9,7 @@
 import types
 import typing
 
-from typing import _GenericAlias  # type: ignore [attr-defined]  # noqa: PLC2701
+from typing import _GenericAlias as typing_GenericAlias  # type: ignore [attr-defined]  # noqa: PLC2701
 
 
 if typing.TYPE_CHECKING:
@@ -282,7 +282,12 @@ def _eval_type_alias(obj: typing.TypeAliasType, ctx: EvalContext):
 
 
 @_eval_types_impl.register
-def _eval_types_generic(obj: types.GenericAlias, ctx: EvalContext):
+def _eval_applied_type_alias(obj: types.GenericAlias, ctx: EvalContext):
+    """Eval a types.GenericAlias -- typically an applied type alias
+
+    This is typically an application of a type alias... except it can
+    also be an application of a built-in type (like list, tuple, dict)
+    """
     new_args = tuple(_eval_types(arg, ctx) for arg in obj.__args__)
 
     new_obj = obj.__origin__[new_args]  # type: ignore[index]
@@ -315,9 +320,10 @@ def _eval_types_generic(obj: types.GenericAlias, ctx: EvalContext):
 
 
 @_eval_types_impl.register
-def _eval_typing_generic(obj: _GenericAlias, ctx: EvalContext):
+def _eval_applied_class(obj: typing_GenericAlias, ctx: EvalContext):
+    """Eval a typing._GenericAlias -- an applied user-defined class"""
     # generic *classes* are typing._GenericAlias while generic type
-    # aliases are # types.GenericAlias? Why in the world.
+    # aliases are types.GenericAlias? Why in the world.
     if func := _eval_funcs.get(obj.__origin__):
         new_args = tuple(_eval_types(arg, ctx) for arg in obj.__args__)
         ret = func(*new_args, ctx=ctx)

typemap/type_eval/_typing_inspect.py

@@ -149,6 +149,10 @@ def is_eval_proxy(t: Any) -> TypeGuard[type[_eval_typing._EvalProxy]]:
     return isinstance(t, type) and issubclass(t, _eval_typing._EvalProxy)
 
 
+def param_default(p) -> Any:
+    return Any if p.__default__ == typing.NoDefault else p.__default__
+
+
 __all__ = (
     "is_annotated",
     "is_forward_ref",