Default Param Q to Literal[ParamKind.POSITIONAL_OR_KEYWORD]

Replace the typing.Never default with the explicit POSITIONAL_OR_KEYWORD
kind, and always emit a kind qualifier in _function_type.

Author: msullivan

tests/test_type_dir.py

@@ -373,12 +373,13 @@ def test_type_members_func_1():
     assert name == typing.Literal["foo"]
     assert quals == typing.Literal["ClassVar"]
 
+    PK = "typing.Literal[<ParamKind.POSITIONAL_OR_KEYWORD: 1>]"
     assert (
         str(typ)
-        == "\
+        == f"\
 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['self'], tests.test_type_dir.Base[int], {PK}], \
+typemap.typing.Param[typing.Literal['a'], int | None, {PK}], \
 typemap.typing.Param[typing.Literal['b'], int, typing.Literal[\
 <ParamKind.KEYWORD_ONLY: 3>, <ParamKind.HAS_DEFAULT: 5>]]], \
 dict[str, int]]"
@@ -395,10 +396,11 @@ def test_type_members_func_2():
     assert name == typing.Literal["cbase"]
     assert quals == typing.Literal["ClassVar"]
 
+    PK = "typing.Literal[<ParamKind.POSITIONAL_OR_KEYWORD: 1>]"
     assert (
         str(typ)
-        == "\
-classmethod[tests.test_type_dir.Base[int], tuple[typemap.typing.Param[typing.Literal['a'], int | None, typing.Never], typemap.typing.Param[typing.Literal['b'], ~K, typing.Never]], dict[str, int]]"
+        == f"\
+classmethod[tests.test_type_dir.Base[int], tuple[typemap.typing.Param[typing.Literal['a'], int | None, {PK}], typemap.typing.Param[typing.Literal['b'], ~K, {PK}]], dict[str, int]]"
     )
 
 
@@ -410,12 +412,11 @@ def test_type_members_func_3():
     assert name == typing.Literal["sbase"]
     assert quals == typing.Literal["ClassVar"]
 
+    PK = "typing.Literal[<ParamKind.POSITIONAL_OR_KEYWORD: 1>]"
     assert (
         str(typ)
-        #          == "\
-        # staticmethod[tuple[typemap.typing.Param[typing.Literal['a'], int | typing.Literal['gotcha!'] | Z | None, typing.Never], typemap.typing.Param[typing.Literal['b'], ~K, typing.Never]], dict[str, int | Z]]"
-        == "\
-typemap.typing.GenericCallable[tuple[Z], staticmethod[tuple[typemap.typing.Param[typing.Literal['a'], int | typing.Literal['gotcha!'] | Z | None, typing.Never], typemap.typing.Param[typing.Literal['b'], ~K, typing.Never]], dict[str, int | Z]]]"
+        == f"\
+typemap.typing.GenericCallable[tuple[Z], staticmethod[tuple[typemap.typing.Param[typing.Literal['a'], int | typing.Literal['gotcha!'] | Z | None, {PK}], typemap.typing.Param[typing.Literal['b'], ~K, {PK}]], dict[str, int | Z]]]"
     )
 
 

tests/test_type_eval.py

@@ -450,16 +450,11 @@ def test_eval_getarg_callable_old():
 def test_eval_getarg_callable_01():
     t = Callable[[int, str], str]
     args = eval_typing(GetArg[t, Callable, Literal[0]])
-    assert (
-        args
-        == tuple[
-            Param[Literal[None], int, Never], Param[Literal[None], str, Never]
-        ]
-    )
+    assert args == tuple[Param[Literal[None], int], Param[Literal[None], str]]
 
     t = Callable[int, str]
     args = eval_typing(GetArg[t, Callable, Literal[0]])
-    assert args == tuple[Param[Literal[None], int, Never]]
+    assert args == tuple[Param[Literal[None], int]]
 
     t = Callable[[], str]
     args = eval_typing(GetArg[t, Callable, Literal[0]])
@@ -491,7 +486,7 @@ def test_eval_getarg_callable_02():
     gc_f = eval_typing(GetArg[gc, GenericCallable, Literal[1]])
     assert gc_f == f
     t = eval_typing(GetArg[gc_f, Callable, Literal[0]])
-    assert t == tuple[Param[Literal[None], T, Never]]
+    assert t == tuple[Param[Literal[None], T]]
     t = eval_typing(GetArg[gc_f, Callable, Literal[1]])
     assert t is T
 
@@ -644,7 +639,7 @@ class C:
 
     f = eval_typing(GetMethodLike[IndirectProtocol[C], Literal["f"]])
     t = eval_typing(GetArg[f, Callable, Literal[0]])
-    assert t == tuple[Param[Literal[None], int, Never],]
+    assert t == tuple[Param[Literal[None], int],]
     t = eval_typing(GetArg[f, Callable, Literal[1]])
     assert t is int
 

typemap/type_eval/_eval_operators.py

@@ -489,7 +489,7 @@ def _callable_type_to_method(name, typ):
         if has_pos_only:
             quals = typing.Literal[ParamKind.POSITIONAL_ONLY]
         else:
-            quals = typing.Never
+            quals = typing.Literal[ParamKind.POSITIONAL_OR_KEYWORD]
         # Override the receiver type with type[Self].
         # An annoying thing to know is that for a member classmethod of C,
         # cls *should* be type[C], but if it was not explicitly annotated, it
@@ -554,19 +554,21 @@ def _ann(x):
         quals = []
         if p.kind == inspect.Parameter.VAR_POSITIONAL:
             quals.append(ParamKind.VAR_POSITIONAL)
-        if p.kind == inspect.Parameter.VAR_KEYWORD:
+        elif p.kind == inspect.Parameter.VAR_KEYWORD:
             quals.append(ParamKind.VAR_KEYWORD)
-        if p.kind == inspect.Parameter.KEYWORD_ONLY:
+        elif p.kind == inspect.Parameter.KEYWORD_ONLY:
             quals.append(ParamKind.KEYWORD_ONLY)
-        if p.kind == inspect.Parameter.POSITIONAL_ONLY:
+        elif p.kind == inspect.Parameter.POSITIONAL_ONLY:
             quals.append(ParamKind.POSITIONAL_ONLY)
+        else:
+            quals.append(ParamKind.POSITIONAL_OR_KEYWORD)
         if p.default is not empty:
             quals.append(ParamKind.HAS_DEFAULT)
         params.append(
             Param[
                 typing.Literal[p.name],
                 _ann(ann),
-                typing.Literal[*quals] if quals else typing.Never,
+                typing.Literal[*quals],
             ]
         )
 

typemap/typing.py

@@ -152,7 +152,11 @@ class ParamKind(enum.IntEnum):
     HAS_DEFAULT = 5
 
 
-class Param[N: str | None, T, Q: ParamKind = typing.Never]:
+class Param[
+    N: str | None,
+    T,
+    Q: ParamKind = Literal[ParamKind.POSITIONAL_OR_KEYWORD],
+]:
     name: N
     typ: T
     quals: Q