Support dot notation for Member (#76)

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

@@ -59,13 +59,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.IsAssignable[
-            Literal[True], GetFieldItem[typing.GetInit[p], Literal["hidden"]]
+            Literal[True], GetFieldItem[p.init, Literal["hidden"]]
         ]
     ]
 ]
@@ -89,15 +89,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.IsAssignable[
             Literal[True],
-            GetFieldItem[typing.GetInit[p], Literal["primary_key"]],
+            GetFieldItem[p.init, Literal["primary_key"]],
         ]
     ]
 ]
@@ -123,15 +123,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.IsAssignable[
             Literal[True],
-            GetFieldItem[typing.GetInit[p], Literal["primary_key"]],
+            GetFieldItem[p.init, Literal["primary_key"]],
         ]
     ]
 ]
@@ -148,13 +148,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.IsAssignable[
-                        GetDefault[typing.GetInit[p]],
+                        GetDefault[p.init],
                         Never,
                     ]
                     else Literal["keyword", "default"],

typemap/type_eval/_eval_typing.py

@@ -15,6 +15,8 @@
     _UnpackGenericAlias as typing_UnpackGenericAlias,
 )
 
+from typemap.typing import _NestedGenericAlias
+
 
 if typing.TYPE_CHECKING:
     from typing import Any, Sequence
@@ -397,6 +399,27 @@ 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
+
+    named_args = dict(
+        zip(
+            (p.__name__ for p in base.__origin__.__type_params__),
+            base.__args__,
+            strict=False,
+        )
+    )
+
+    unpacked = _apply_generic.get_annotations(
+        alias, named_args, key='evaluate_value'
+    )
+
+    return _eval_types(unpacked, ctx)
+
+
 @_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

@@ -57,6 +57,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
 
 
@@ -160,21 +183,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"]]
@@ -188,11 +211,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):