Replace string-based ParamQuals with ParamKind IntEnum

Model parameter qualifiers on inspect._ParameterKind instead of using
ad-hoc string literals. Drop the ParamQuals Literal type alias and
bind Param's Q directly to the ParamKind enum.

Author: msullivan

pep.rst

@@ -393,18 +393,31 @@ Extended Callables, take 2
 
 We introduce a ``Param`` type the contains all the information about a function param::
 
-    class Param[N: str | None, T, Q: ParamQuals = typing.Never]:
+    class ParamKind(enum.IntEnum):
+        """Parameter kind qualifiers, modeled on inspect._ParameterKind."""
+        POSITIONAL_ONLY = 0
+        POSITIONAL_OR_KEYWORD = 1
+        VAR_POSITIONAL = 2
+        KEYWORD_ONLY = 3
+        VAR_KEYWORD = 4
+        HAS_DEFAULT = 5
+
+    class Param[N: str | None, T, Q: ParamKind = typing.Never]:
         pass
 
-    ParamQuals = typing.Literal["*", "**", "default", "keyword"]
-
-    type PosParam[N: str | None, T] = Param[N, T, Literal["positional"]]
-    type PosDefaultParam[N: str | None, T] = Param[N, T, Literal["positional", "default"]]
-    type DefaultParam[N: str, T] = Param[N, T, Literal["default"]]
-    type NamedParam[N: str, T] = Param[N, T, Literal["keyword"]]
-    type NamedDefaultParam[N: str, T] = Param[N, T, Literal["keyword", "default"]]
-    type ArgsParam[T] = Param[Literal[None], T, Literal["*"]]
-    type KwargsParam[T] = Param[Literal[None], T, Literal["**"]]
+    type PosParam[N: str | None, T] = Param[
+        N, T, Literal[ParamKind.POSITIONAL_ONLY]
+    ]
+    type PosDefaultParam[N: str | None, T] = Param[
+        N, T, Literal[ParamKind.POSITIONAL_ONLY, ParamKind.HAS_DEFAULT]
+    ]
+    type DefaultParam[N: str, T] = Param[N, T, Literal[ParamKind.HAS_DEFAULT]]
+    type NamedParam[N: str, T] = Param[N, T, Literal[ParamKind.KEYWORD_ONLY]]
+    type NamedDefaultParam[N: str, T] = Param[
+        N, T, Literal[ParamKind.KEYWORD_ONLY, ParamKind.HAS_DEFAULT]
+    ]
+    type ArgsParam[T] = Param[Literal[None], T, Literal[ParamKind.VAR_POSITIONAL]]
+    type KwargsParam[T] = Param[Literal[None], T, Literal[ParamKind.VAR_KEYWORD]]
 
 And then, we can represent the type of a function like::
 
@@ -424,13 +437,13 @@ as (we are omitting the ``Literal`` in places)::
 
     Callable[
         [
-            Param["a", int, "positional"],
+            Param["a", int, ParamKind.POSITIONAL_ONLY],
             Param["b", int],
-            Param["c", int, "default"],
-            Param[None, int, "*"],
-            Param["d", int, "keyword"],
-            Param["e", int, Literal["default", "keyword"]],
-            Param[None, int, "**"],
+            Param["c", int, ParamKind.HAS_DEFAULT],
+            Param[None, int, ParamKind.VAR_POSITIONAL],
+            Param["d", int, ParamKind.KEYWORD_ONLY],
+            Param["e", int, Literal[ParamKind.HAS_DEFAULT, ParamKind.KEYWORD_ONLY]],
+            Param[None, int, ParamKind.VAR_KEYWORD],
         ],
         int,
     ]
@@ -1130,12 +1143,12 @@ dataclasses-style method generation
                         typing.GetType[p],
                         # All arguments are keyword-only
                         # It takes a default if a default is specified in the class
-                        Literal["keyword"]
+                        Literal[typing.ParamKind.KEYWORD_ONLY]
                         if typing.IsAssignable[
                             GetDefault[typing.GetInit[p]],
                             Never,
                         ]
-                        else Literal["keyword", "default"],
+                        else Literal[typing.ParamKind.KEYWORD_ONLY, typing.ParamKind.HAS_DEFAULT],
                     ]
                     for p in typing.Iter[typing.Attrs[T]]
                 ],

tests/test_eval_call_with_types.py

@@ -12,6 +12,7 @@
     Iter,
     Members,
     Param,
+    ParamKind,
 )
 
 
@@ -27,7 +28,10 @@ def test_eval_call_with_types_callable_02():
 
 def test_eval_call_with_types_callable_03():
     res = eval_call_with_types(
-        Callable[[Param[Literal["x"], int, Literal["keyword"]]], int], x=int
+        Callable[
+            [Param[Literal["x"], int, Literal[ParamKind.KEYWORD_ONLY]]], int
+        ],
+        x=int,
     )
     assert res is int
 
@@ -64,7 +68,7 @@ class C: ...
         Callable[
             [
                 Param[Literal["self"], Self],
-                Param[Literal["x"], int, Literal["keyword"]],
+                Param[Literal["x"], int, Literal[ParamKind.KEYWORD_ONLY]],
             ],
             int,
         ],

tests/test_fastapilike_1.py

@@ -18,6 +18,7 @@
     GetQuals,
     Member,
     Members,
+    ParamKind,
     Param,
 )
 
@@ -53,12 +54,12 @@ class _Default:
                 Param[
                     GetName[p],
                     DropAnnotations[GetType[p]],
-                    Literal["keyword", "default"]
+                    Literal[ParamKind.KEYWORD_ONLY, ParamKind.HAS_DEFAULT]
                     if IsAssignable[
                         Literal[PropQuals.HAS_DEFAULT],
                         GetAnnotations[GetType[p]],
                     ]
-                    else Literal["keyword"],
+                    else Literal[ParamKind.KEYWORD_ONLY],
                 ]
                 for p in Iter[Attrs[T]]
             ],

tests/test_fastapilike_2.py

@@ -152,12 +152,15 @@ class Field[T: FieldArgs](typing.InitField[T]):
                     typing.GetType[p],
                     # All arguments are keyword-only
                     # It takes a default if a default is specified in the class
-                    Literal["keyword"]
+                    Literal[typing.ParamKind.KEYWORD_ONLY]
                     if typing.IsAssignable[
                         GetDefault[typing.GetInit[p]],
                         Never,
                     ]
-                    else Literal["keyword", "default"],
+                    else Literal[
+                        typing.ParamKind.KEYWORD_ONLY,
+                        typing.ParamKind.HAS_DEFAULT,
+                    ],
                 ]
                 for p in typing.Iter[typing.Attrs[T]]
             ],

tests/test_schemalike.py

@@ -12,6 +12,7 @@
     Member,
     NamedParam,
     Param,
+    ParamKind,
     StrConcat,
 )
 
@@ -50,7 +51,11 @@ class Property:
             Callable[
                 [
                     Param[Literal["self"], Schemaify[T]],
-                    NamedParam[Literal["schema"], Schema, Literal["keyword"]],
+                    NamedParam[
+                        Literal["schema"],
+                        Schema,
+                        Literal[ParamKind.KEYWORD_ONLY],
+                    ],
                 ],
                 GetType[p],
             ],

tests/test_type_dir.py

@@ -379,8 +379,8 @@ def test_type_members_func_1():
 typing.Callable[[\
 typemap.typing.Param[typing.Literal['self'], tests.test_type_dir.Base[int], typing.Never], \
 typemap.typing.Param[typing.Literal['a'], int | None, typing.Never], \
-typemap.typing.Param[typing.Literal['b'], int, typing.Literal['keyword', \
-'default']]], \
+typemap.typing.Param[typing.Literal['b'], int, typing.Literal[\
+<ParamKind.KEYWORD_ONLY: 3>, <ParamKind.HAS_DEFAULT: 5>]]], \
 dict[str, int]]"
     )