Make the explicit one work again

Author: msullivan

typemap/type_eval/_apply_generic.py

@@ -281,7 +281,7 @@ def get_local_defns(boxed: Boxed) -> tuple[dict[str, Any], dict[str, Any]]:
     return annos, dct
 
 
-def flatten_class(cls: type) -> type:
+def flatten_class_new_proto(cls: type) -> type:
     # This is a hacky version of flatten_class that works by using
     # NewProtocol on Members!
     #
@@ -294,8 +294,13 @@ def flatten_class(cls: type) -> type:
 
     type ClsAlias = NewProtocol[*[m for m in Iter[Members[cls]]]]  # type: ignore[valid-type]
     nt = _eval_typing.eval_typing(ClsAlias)
-    nt.__name__ = cls.__name__
-    nt.__qualname__ = cls.__qualname__
+
+    args = typing.get_args(cls)
+    args_str = ", ".join(_type_repr(a) for a in args)
+    args_str = f'[{args_str}]' if args_str else ''
+
+    nt.__name__ = f'{cls.__name__}{args_str}'
+    nt.__qualname__ = f'{cls.__qualname__}{args_str}'
     del nt.__subclasshook__
 
     return nt
@@ -311,8 +316,9 @@ def _type_repr(t: Any) -> str:
         return repr(t)
 
 
-# XXX: This is all dead now???
-def apply(
+# TODO: Potentially most of this could be ripped out. The internals
+# don't use this at all, it's only used by format_class.
+def _flatten_class_explicit(
     cls: type[Any], ctx: _eval_typing.EvalContext
 ) -> type[_eval_typing._EvalProxy]:
     cls_boxed = box(cls)
@@ -349,7 +355,7 @@ def apply(
                 "__local_args__": args,
             },
         )
-        ctx.seen[boxed.alias_type()] = new[boxed] = cboxed
+        new[boxed] = cboxed
 
         annos: dict[str, Any] = {}
         dct: dict[str, Any] = {}
@@ -383,3 +389,11 @@ def apply(
             setattr(cboxed, k, _eval_typing._eval_types(v, ctx=ctx))
 
     return new[cls_boxed]
+
+
+def flatten_class_explicit(obj: typing.Any):
+    with _eval_typing._ensure_context() as ctx:
+        return _flatten_class_explicit(obj, ctx)
+
+
+flatten_class = flatten_class_explicit

typemap/type_eval/_eval_typing.py

@@ -187,6 +187,16 @@ def _is_type_alias_type(obj: typing.Any) -> bool:
     )
 
 
+def _apply_type(base, args):
+    # Some type aliases (like Final) get mad if they get a 1-ary tuple...
+    # TODO: Should we special case 0?
+    # (Should we fill in Anys???)
+    if len(args) == 1:
+        return base[args[0]]
+    else:
+        return base[*args]
+
+
 def _eval_types(obj: typing.Any, ctx: EvalContext):
     # Found a recursive alias, we need to unwind it
     if obj in ctx.alias_stack:
@@ -285,7 +295,7 @@ def _eval_applied_type_alias(obj: types.GenericAlias, ctx: EvalContext):
     """
     new_args = tuple(_eval_types(arg, ctx) for arg in obj.__args__)
 
-    new_obj = obj.__origin__[new_args]  # type: ignore[index]
+    new_obj = _apply_type(obj.__origin__, new_args)
     if isinstance(obj.__origin__, type):
         # This is a GenericAlias over a Python class, e.g. `dict[str, int]`
         # Let's reconstruct it by evaluating all arguments
@@ -326,7 +336,7 @@ def _eval_applied_class(obj: typing_GenericAlias, ctx: EvalContext):
         # return _eval_types(ret, ctx)  # ???
         return ret
     else:
-        return obj.__origin__[new_args]  # type: ignore[index]
+        return _apply_type(obj.__origin__, new_args)
 
 
 @_eval_types_impl.register
@@ -341,7 +351,7 @@ def _eval_ty_or_list(obj):
 
     new_args = tuple(_eval_ty_or_list(arg) for arg in typing.get_args(obj))
     # origin for Callable is collections.abc.Callable which kind of annoying
-    return typing.Callable[*new_args]
+    return _apply_type(typing.Callable, new_args)
 
 
 @_eval_types_impl.register