Convert Callable ... to Params[*args: Any, **kwargs: Any]

Ellipsis in Callable[..., ret] and bare Callable now produce
Params[Param[None, Any, "*"], Param[None, Any, "**"]] instead
of SpecialFormEllipsis, so all Callable param access consistently
returns Params.

Author: msullivan

tests/test_type_eval.py

@@ -756,11 +756,23 @@ def test_eval_getarg_callable_old():
 
     t = Callable[..., str]
     args = eval_typing(GetArg[t, Callable, 0])
-    assert args == SpecialFormEllipsis
+    assert (
+        args
+        == Params[
+            Param[Literal[None], Any, Literal["*"]],
+            Param[Literal[None], Any, Literal["**"]],
+        ]
+    )
 
     t = Callable
     args = eval_typing(GetArg[t, Callable, 0])
-    assert args == SpecialFormEllipsis
+    assert (
+        args
+        == Params[
+            Param[Literal[None], Any, Literal["*"]],
+            Param[Literal[None], Any, Literal["**"]],
+        ]
+    )
 
     t = Callable
     args = eval_typing(GetArg[t, Callable, 1])
@@ -780,14 +792,26 @@ def test_eval_getarg_callable_01():
     args = eval_typing(GetArg[t, Callable, Literal[0]])
     assert args == Params[()]
 
-    # XXX: Is this what we want? Or should it be *args, **kwargs
+    # ... becomes *args: Any, **kwargs: Any
     t = Callable[..., str]
     args = eval_typing(GetArg[t, Callable, Literal[0]])
-    assert args == SpecialFormEllipsis
+    assert (
+        args
+        == Params[
+            Param[Literal[None], Any, Literal["*"]],
+            Param[Literal[None], Any, Literal["**"]],
+        ]
+    )
 
     t = Callable
     args = eval_typing(GetArg[t, Callable, Literal[0]])
-    assert args == SpecialFormEllipsis
+    assert (
+        args
+        == Params[
+            Param[Literal[None], Any, Literal["*"]],
+            Param[Literal[None], Any, Literal["**"]],
+        ]
+    )
 
     t = Callable
     args = eval_typing(GetArg[t, Callable, Literal[1]])

typemap/type_eval/_eval_operators.py

@@ -495,12 +495,19 @@ def __repr__(self):
 def _unwrap_params(param_types) -> list:
     """Unwrap params into a list of Param types.
 
-    Accepts Params[...] (extended format), or a list/tuple of plain
-    types (standard format, converted to positional-only Params).
+    Accepts Params[...] (extended format), Ellipsis (any params),
+    or a list/tuple of plain types (standard format, converted to
+    positional-only Params).
     """
     if typing.get_origin(param_types) is Params:
         return list(typing.get_args(param_types))
 
+    if param_types is ...:
+        return [
+            Param[typing.Literal[None], typing.Any, typing.Literal["*"]],
+            Param[typing.Literal[None], typing.Any, typing.Literal["**"]],
+        ]
+
     if isinstance(param_types, (list, tuple)):
         items = list(param_types)
     else:
@@ -890,18 +897,7 @@ def _fix_callable_args(base, args):
     if idx >= len(args):
         return args
     args = list(args)
-    special = _fix_type(args[idx])
-    if typing.get_origin(special) is Params:
-        args[idx] = Params[
-            *[
-                (
-                    t
-                    if typing.get_origin(t) is Param
-                    else Param[typing.Literal[None], t]
-                )
-                for t in typing.get_args(special)
-            ]
-        ]
+    args[idx] = Params[*_unwrap_params(args[idx])]
     return tuple(args)
 
 
@@ -1039,7 +1035,13 @@ def _get_defaults(base_head):
     # Callable and tuple need to produce a SpecialFormEllipsis for arg
     # 0 and 1, respectively.
     if base_head is collections.abc.Callable:
-        return (SpecialFormEllipsis, typing.Any)
+        return (
+            Params[
+                Param[typing.Literal[None], typing.Any, typing.Literal["*"]],
+                Param[typing.Literal[None], typing.Any, typing.Literal["**"]],
+            ],
+            typing.Any,
+        )
     elif base_head is tuple:
         return (typing.Any, SpecialFormEllipsis)