Minor ParamSpec improvements (#385)

* make Ellipsis a ParameterKind

* P.args and P.kwargs

* fix __str__

* changelog

Author: JelleZijlstra

docs/changelog.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- Small improvements to `ParamSpec` support (#385)
 - Allow `CustomCheck` to customize what values
   a value can be assigned to (#383)
 - Fix incorrect inference of `self` argument on

pyanalyze/annotations.py

@@ -59,7 +59,7 @@
     TypeGuard,
 )
 from .find_unused import used
-from .signature import SigParameter, Signature, ParameterKind
+from .signature import ELLIPSIS_PARAM, SigParameter, Signature, ParameterKind
 from .safe import is_typing_name, is_instance_of_typing_name
 from . import type_evaluation
 from .value import (
@@ -75,6 +75,8 @@
     MultiValuedValue,
     NO_RETURN_VALUE,
     NoReturnGuardExtension,
+    ParamSpecArgsValue,
+    ParamSpecKwargsValue,
     ParameterTypeGuardExtension,
     TypeGuardExtension,
     TypedValue,
@@ -391,7 +393,7 @@ def _type_from_runtime(val: Any, ctx: Context, is_typeddict: bool = False) -> Va
         args = typing_inspect.get_args(val)
         return _value_of_origin_args(Callable, args, val, ctx)
     elif val is AsynqCallable:
-        return CallableValue(Signature.make([], is_ellipsis_args=True, is_asynq=True))
+        return CallableValue(Signature.make([ELLIPSIS_PARAM], is_asynq=True))
     elif isinstance(val, type):
         return _maybe_typed_value(val)
     elif val is None:
@@ -425,6 +427,10 @@ def _type_from_runtime(val: Any, ctx: Context, is_typeddict: bool = False) -> Va
         return TypeVarValue(tv, bound=bound, constraints=constraints)
     elif is_instance_of_typing_name(val, "ParamSpec"):
         return TypeVarValue(val, is_paramspec=True)
+    elif is_instance_of_typing_name(val, "ParamSpecArgs"):
+        return ParamSpecArgsValue(val.__origin__)
+    elif is_instance_of_typing_name(val, "ParamSpecKwargs"):
+        return ParamSpecKwargsValue(val.__origin__)
     elif is_typing_name(val, "Final") or is_typing_name(val, "ClassVar"):
         return AnyValue(AnySource.incomplete_annotation)
     elif typing_inspect.is_classvar(val) or typing_inspect.is_final_type(val):
@@ -467,14 +473,9 @@ def _type_from_runtime(val: Any, ctx: Context, is_typeddict: bool = False) -> Va
             [TypeGuardExtension(_type_from_runtime(val.__type__, ctx))],
         )
     elif isinstance(val, AsynqCallable):
-        params, is_ellipsis_args = _callable_args_from_runtime(
-            val.args, "AsynqCallable", ctx
-        )
+        params = _callable_args_from_runtime(val.args, "AsynqCallable", ctx)
         sig = Signature.make(
-            params,
-            _type_from_runtime(val.return_type, ctx),
-            is_asynq=True,
-            is_ellipsis_args=is_ellipsis_args,
+            params, _type_from_runtime(val.return_type, ctx), is_asynq=True
         )
         return CallableValue(sig)
     elif isinstance(val, ExternalType):
@@ -506,22 +507,22 @@ def _type_from_runtime(val: Any, ctx: Context, is_typeddict: bool = False) -> Va
 
 def _callable_args_from_runtime(
     arg_types: Any, label: str, ctx: Context
-) -> Tuple[Sequence[SigParameter], bool]:
+) -> Sequence[SigParameter]:
     if arg_types is Ellipsis or arg_types == [Ellipsis]:
-        return [], True
+        return [ELLIPSIS_PARAM]
     elif type(arg_types) in (tuple, list):
         if len(arg_types) == 1:
             (arg,) = arg_types
             if arg is Ellipsis:
-                return [], True
+                return [ELLIPSIS_PARAM]
             elif is_typing_name(getattr(arg, "__origin__", None), "Concatenate"):
                 return _args_from_concatenate(arg, ctx)
             elif is_instance_of_typing_name(arg, "ParamSpec"):
                 param_spec = TypeVarValue(arg, is_paramspec=True)
                 param = SigParameter(
                     "__P", kind=ParameterKind.PARAM_SPEC, annotation=param_spec
                 )
-                return [param], False
+                return [param]
         types = [_type_from_runtime(arg, ctx) for arg in arg_types]
         params = [
             SigParameter(
@@ -533,23 +534,21 @@ def _callable_args_from_runtime(
             )
             for i, typ in enumerate(types)
         ]
-        return params, False
+        return params
     elif is_instance_of_typing_name(arg_types, "ParamSpec"):
         param_spec = TypeVarValue(arg_types, is_paramspec=True)
         param = SigParameter(
             "__P", kind=ParameterKind.PARAM_SPEC, annotation=param_spec
         )
-        return [param], False
+        return [param]
     elif is_typing_name(getattr(arg_types, "__origin__", None), "Concatenate"):
         return _args_from_concatenate(arg_types, ctx)
     else:
         ctx.show_error(f"Invalid arguments to {label}: {arg_types!r}")
-        return [], True
+        return [ELLIPSIS_PARAM]
 
 
-def _args_from_concatenate(
-    concatenate: Any, ctx: Context
-) -> Tuple[Sequence[SigParameter], bool]:
+def _args_from_concatenate(concatenate: Any, ctx: Context) -> Sequence[SigParameter]:
     types = [_type_from_runtime(arg, ctx) for arg in concatenate.__args__]
     params = [
         SigParameter(
@@ -561,7 +560,7 @@ def _args_from_concatenate(
         )
         for i, annotation in enumerate(types)
     ]
-    return params, False
+    return params
 
 
 def _get_typeddict_value(
@@ -987,14 +986,8 @@ def _value_of_origin_args(
         *arg_types, return_type = args
         if len(arg_types) == 1 and isinstance(arg_types[0], list):
             arg_types = arg_types[0]
-        params, is_ellipsis_args = _callable_args_from_runtime(
-            arg_types, "Callable", ctx
-        )
-        sig = Signature.make(
-            params,
-            _type_from_runtime(return_type, ctx),
-            is_ellipsis_args=is_ellipsis_args,
-        )
+        params = _callable_args_from_runtime(arg_types, "Callable", ctx)
+        sig = Signature.make(params, _type_from_runtime(return_type, ctx))
         return CallableValue(sig)
     elif is_typing_name(origin, "Annotated"):
         origin, metadata = args
@@ -1077,10 +1070,7 @@ def _make_callable_from_value(
     if args == KnownValue(Ellipsis):
         return CallableValue(
             Signature.make(
-                [],
-                return_annotation=return_annotation,
-                is_ellipsis_args=True,
-                is_asynq=is_asynq,
+                [ELLIPSIS_PARAM], return_annotation=return_annotation, is_asynq=is_asynq
             )
         )
     elif isinstance(args, SequenceIncompleteValue):

pyanalyze/arg_spec.py

@@ -22,6 +22,7 @@
 from .stacked_scopes import Composite, uniq_chain
 from .signature import (
     ANY_SIGNATURE,
+    ELLIPSIS_PARAM,
     ConcreteSignature,
     Impl,
     MaybeSignature,
@@ -642,9 +643,8 @@ def _uncached_get_argspec(
                     inspect_sig = self._safe_get_signature(constructor)
                 if inspect_sig is None:
                     return Signature.make(
-                        [],
+                        [ELLIPSIS_PARAM],
                         return_type,
-                        is_ellipsis_args=True,
                         callable=obj,
                         allow_call=allow_call,
                     )
@@ -703,9 +703,8 @@ def _uncached_get_argspec(
     def _make_any_sig(self, obj: object) -> Signature:
         if FunctionsSafeToCall.contains(obj, self.options):
             return Signature.make(
-                [],
+                [ELLIPSIS_PARAM],
                 AnyValue(AnySource.inference),
-                is_ellipsis_args=True,
                 is_asynq=True,
                 allow_call=True,
                 callable=obj,