Demo: experiment with supporting dot notation for Member

This adds a general mechanism of allowing dot notation to access type
aliases defined in a class if the class inherits from
`typing.SupportAliases`.

I updated one of the tests for it. Thoughts?

Author: msullivan

tests/test_fastapilike_2.py

@@ -52,13 +52,13 @@ class Field[T: FieldArgs](typing.InitField[T]):
 type Public[T] = typing.NewProtocol[
     *[
         typing.Member[
-            typing.GetName[p],
-            FixPublicType[typing.GetType[p], typing.GetInit[p]],
-            typing.GetQuals[p],
+            p.name,
+            FixPublicType[p.type, p.init],
+            p.quals,
         ]
         for p in typing.Iter[typing.Attrs[T]]
         if not typing.IsSub[
-            Literal[True], GetFieldItem[typing.GetInit[p], Literal["hidden"]]
+            Literal[True], GetFieldItem[p.init, Literal["hidden"]]
         ]
     ]
 ]
@@ -82,15 +82,15 @@ class Field[T: FieldArgs](typing.InitField[T]):
 type Create[T] = typing.NewProtocol[
     *[
         typing.Member[
-            typing.GetName[p],
-            typing.GetType[p],
-            typing.GetQuals[p],
-            GetDefault[typing.GetInit[p]],
+            p.name,
+            p.type,
+            p.quals,
+            GetDefault[p.init],
         ]
         for p in typing.Iter[typing.Attrs[T]]
         if not typing.IsSub[
             Literal[True],
-            GetFieldItem[typing.GetInit[p], Literal["primary_key"]],
+            GetFieldItem[p.init, Literal["primary_key"]],
         ]
     ]
 ]
@@ -116,15 +116,15 @@ class Field[T: FieldArgs](typing.InitField[T]):
 type Update[T] = typing.NewProtocol[
     *[
         typing.Member[
-            typing.GetName[p],
-            typing.GetType[p] | None,
-            typing.GetQuals[p],
+            p.name,
+            p.type | None,
+            p.quals,
             Literal[None],
         ]
         for p in typing.Iter[typing.Attrs[T]]
         if not typing.IsSub[
             Literal[True],
-            GetFieldItem[typing.GetInit[p], Literal["primary_key"]],
+            GetFieldItem[p.init, Literal["primary_key"]],
         ]
     ]
 ]
@@ -141,13 +141,13 @@ class Field[T: FieldArgs](typing.InitField[T]):
             typing.Param[Literal["self"], Self],
             *[
                 typing.Param[
-                    typing.GetName[p],
-                    typing.GetType[p],
+                    p.name,
+                    p.type,
                     # All arguments are keyword-only
                     # It takes a default if a default is specified in the class
                     Literal["keyword"]
                     if typing.IsSub[
-                        GetDefault[typing.GetInit[p]],
+                        GetDefault[p.init],
                         Never,
                     ]
                     else Literal["keyword", "default"],

typemap/type_eval/_eval_typing.py

@@ -18,6 +18,8 @@
     _UnpackGenericAlias as typing_UnpackGenericAlias,
 )
 
+from typemap.typing import _NestedGenericAlias
+
 
 if typing.TYPE_CHECKING:
     from typing import Any, Sequence
@@ -453,6 +455,42 @@ def _eval_applied_type_alias(obj: types.GenericAlias, ctx: EvalContext):
     return evaled
 
 
+@_eval_types_impl.register
+def _eval_nested_generic_alias(obj: _NestedGenericAlias, ctx: EvalContext):
+    base, alias = obj.__args__
+
+    # TODO: what if it has parameters of its own
+
+    func = alias.evaluate_value
+
+    # obj.__args__ matches the declared parameter order, but args are expected
+    # to be in the same order as func.__code__.co_freevars.
+    args_by_name = dict(
+        zip(
+            (p.__name__ for p in base.__origin__.__type_params__),
+            base.__args__,
+            strict=False,
+        )
+    )
+
+    args = tuple(
+        types.CellType(_eval_types(args_by_name[name], ctx))
+        if name in args_by_name
+        else value
+        for name, value in zip(
+            func.__code__.co_freevars, func.__closure__, strict=False
+        )
+    )
+    mod = sys.modules[obj.__module__]
+
+    ff = types.FunctionType(func.__code__, mod.__dict__, None, None, args)
+    unpacked = ff(annotationlib.Format.VALUE)
+
+    evaled = _eval_types(unpacked, ctx)
+
+    return evaled
+
+
 @_eval_types_impl.register
 def _eval_applied_class(obj: typing_GenericAlias, ctx: EvalContext):
     """Eval a typing._GenericAlias -- an applied user-defined class"""

typemap/typing.py

@@ -53,6 +53,29 @@ def __typing_unpacked_tuple_args__(self):
 ###
 
 
+class SupportAliases:
+    @classmethod
+    def __class_getitem__(cls, args):
+        # Return an _AliasSupportingGenericAlias instead of a _GenericAlias
+        res = super().__class_getitem__(args)
+        return _AliasSupportingGenericAlias(res.__origin__, res.__args__)
+
+
+class _NestedGenericAlias(_GenericAlias, _root=True):
+    pass
+
+
+class _AliasSupportingGenericAlias(_GenericAlias, _root=True):
+    def __getattr__(self, attr):
+        res = super().__getattr__(attr)
+        if isinstance(res, typing.TypeAliasType):
+            res = _NestedGenericAlias(NestedAlias, (self, res))
+        return res
+
+
+###
+
+
 # Not type-level computation but related
 
 
@@ -132,21 +155,21 @@ class Member[
     Q: MemberQuals = typing.Never,
     I = typing.Never,
     D = typing.Never,
-]:
-    name: N
-    typ: T
-    quals: Q
-    init: I
-    definer: D
+](SupportAliases):
+    type name = N
+    type type = T
+    type quals = Q
+    type init = I
+    type definer = D
 
 
 ParamQuals = Literal["*", "**", "keyword", "positional", "default"]
 
 
-class Param[N: str | None, T, Q: ParamQuals = typing.Never]:
-    name: N
-    typ: T
-    quals: Q
+class Param[N: str | None, T, Q: ParamQuals = typing.Never](SupportAliases):
+    type name = N
+    type type = T
+    type quals = Q
 
 
 type PosParam[N: str | None, T] = Param[N, T, Literal["positional"]]
@@ -160,11 +183,15 @@ class Param[N: str | None, T, Q: ParamQuals = typing.Never]:
 type KwargsParam[T] = Param[Literal[None], T, Literal["**"]]
 
 
-type GetName[T: Member | Param] = GetMemberType[T, Literal["name"]]
-type GetType[T: Member | Param] = GetMemberType[T, Literal["typ"]]
-type GetQuals[T: Member | Param] = GetMemberType[T, Literal["quals"]]
-type GetInit[T: Member] = GetMemberType[T, Literal["init"]]
-type GetDefiner[T: Member] = GetMemberType[T, Literal["definer"]]
+type GetName[T: Member | Param] = T.name
+type GetType[T: Member | Param] = T.type
+type GetQuals[T: Member | Param] = T.quals
+type GetInit[T: Member] = T.init
+type GetDefiner[T: Member] = T.definer
+
+
+class NestedAlias[Obj, Alias]:
+    pass
 
 
 class Attrs[T](_TupleLikeOperator):