Only process Param types when wrapped in Params

_callable_type_to_signature now treats standard callables
(Callable[[type, ...], ret]) separately from extended callables
(Callable[Params[Param[...], ...], ret]). All test files updated
to use Params wrapper consistently.

Author: msullivan

tests/test_dataclass_like.py

@@ -53,7 +53,7 @@ class Field[T: FieldArgs](typing.InitField[T]):
 type InitFnType[T] = typing.Member[
     Literal["__init__"],
     Callable[
-        [
+        typing.Params[
             typing.Param[Literal["self"], Self],
             *[
                 typing.Param[

tests/test_eval_call_with_types.py

@@ -10,6 +10,7 @@
     Iter,
     Members,
     Param,
+    Params,
 )
 
 
@@ -19,36 +20,46 @@ def test_eval_call_with_types_callable_01():
 
 
 def test_eval_call_with_types_callable_02():
-    res = eval_call_with_types(Callable[[Param[Literal["x"], int]], int], int)
+    res = eval_call_with_types(
+        Callable[Params[Param[Literal["x"], int]], int], int
+    )
     assert res is int
 
 
 def test_eval_call_with_types_callable_03():
     res = eval_call_with_types(
-        Callable[[Param[Literal["x"], int, Literal["keyword"]]], int], x=int
+        Callable[Params[Param[Literal["x"], int, Literal["keyword"]]], int],
+        x=int,
     )
     assert res is int
 
 
 def test_eval_call_with_types_callable_04():
     class C: ...
 
-    res = eval_call_with_types(Callable[[Param[Literal["self"], Self]], int], C)
+    res = eval_call_with_types(
+        Callable[Params[Param[Literal["self"], Self]], int], C
+    )
     assert res is int
 
 
 def test_eval_call_with_types_callable_05():
     class C: ...
 
-    res = eval_call_with_types(Callable[[Param[Literal["self"], Self]], C], C)
+    res = eval_call_with_types(
+        Callable[Params[Param[Literal["self"], Self]], C], C
+    )
     assert res is C
 
 
 def test_eval_call_with_types_callable_06():
     class C: ...
 
     res = eval_call_with_types(
-        Callable[[Param[Literal["self"], Self], Param[Literal["x"], int]], int],
+        Callable[
+            Params[Param[Literal["self"], Self], Param[Literal["x"], int]],
+            int,
+        ],
         C,
         int,
     )
@@ -60,7 +71,7 @@ class C: ...
 
     res = eval_call_with_types(
         Callable[
-            [
+            Params[
                 Param[Literal["self"], Self],
                 Param[Literal["x"], int, Literal["keyword"]],
             ],
@@ -74,13 +85,15 @@ class C: ...
 
 def test_eval_call_with_types_callable_08():
     T = TypeVar("T")
-    res = eval_call_with_types(Callable[[Param[Literal["x"], T]], str], int)
+    res = eval_call_with_types(
+        Callable[Params[Param[Literal["x"], T]], str], int
+    )
     assert res is str
 
 
 def test_eval_call_with_types_callable_09():
     T = TypeVar("T")
-    res = eval_call_with_types(Callable[[Param[Literal["x"], T]], T], int)
+    res = eval_call_with_types(Callable[Params[Param[Literal["x"], T]], T], int)
     assert res is int
 
 
@@ -89,7 +102,9 @@ def test_eval_call_with_types_callable_10():
 
     class C(Generic[T]): ...
 
-    res = eval_call_with_types(Callable[[Param[Literal["x"], C[T]]], T], C[int])
+    res = eval_call_with_types(
+        Callable[Params[Param[Literal["x"], C[T]]], T], C[int]
+    )
     assert res is int
 
 
@@ -102,9 +117,13 @@ class D(C[int]): ...
 
     class E(D): ...
 
-    res = eval_call_with_types(Callable[[Param[Literal["x"], C[T]]], T], D)
+    res = eval_call_with_types(
+        Callable[Params[Param[Literal["x"], C[T]]], T], D
+    )
     assert res is int
-    res = eval_call_with_types(Callable[[Param[Literal["x"], C[T]]], T], E)
+    res = eval_call_with_types(
+        Callable[Params[Param[Literal["x"], C[T]]], T], E
+    )
     assert res is int
 
 
@@ -206,7 +225,10 @@ def test_eval_call_with_types_bind_error_01():
         ValueError, match="Type variable T is already bound to int, but got str"
     ):
         eval_call_with_types(
-            Callable[[Param[Literal["x"], T], Param[Literal["y"], T]], T],
+            Callable[
+                Params[Param[Literal["x"], T], Param[Literal["y"], T]],
+                T,
+            ],
             int,
             str,
         )
@@ -230,7 +252,10 @@ class C(Generic[T]): ...
         ValueError, match="Type variable T is already bound to int, but got str"
     ):
         eval_call_with_types(
-            Callable[[Param[Literal["x"], C[T]], Param[Literal["y"], C[T]]], T],
+            Callable[
+                Params[Param[Literal["x"], C[T]], Param[Literal["y"], C[T]]],
+                T,
+            ],
             C[int],
             C[str],
         )

tests/test_fastapilike_1.py

@@ -19,6 +19,7 @@
     Member,
     Members,
     Param,
+    Params,
 )
 
 from . import format_helper
@@ -47,7 +48,7 @@ class _Default:
 type InitFnType[T] = Member[
     Literal["__init__"],
     Callable[
-        [
+        Params[
             Param[Literal["self"], Self],
             *[
                 Param[

tests/test_fastapilike_2.py

@@ -142,7 +142,7 @@ class Field[T: FieldArgs](typing.InitField[T]):
 type InitFnType[T] = typing.Member[
     Literal["__init__"],
     Callable[
-        [
+        typing.Params[
             typing.Param[Literal["self"], Self],
             *[
                 typing.Param[

tests/test_schemalike.py

@@ -3,6 +3,7 @@
 from typing import Callable, Literal
 
 from typemap.type_eval import eval_typing
+from typemap.typing import Params
 from typemap_extensions import (
     NewProtocol,
     Iter,
@@ -46,7 +47,7 @@ class Property:
         Member[
             StrConcat[Literal["get_"], p.name],
             Callable[
-                [
+                Params[
                     Param[Literal["self"], Schemaify[T]],
                     NamedParam[Literal["schema"], Schema, Literal["keyword"]],
                 ],
@@ -63,16 +64,17 @@ def test_schema_like_1():
     tgt = eval_typing(Schemaify[Property])
     fmt = format_helper.format_class(tgt)
 
-    assert fmt == textwrap.dedent("""\
+    getter_params = "self: Self, *, schema: tests.test_schemalike.Schema"
+    assert fmt == textwrap.dedent(f"""\
     class Schemaify[tests.test_schemalike.Property]:
         name: str
         required: bool
         multi: bool
         typ: tests.test_schemalike.Type
         expr: tests.test_schemalike.Expression | None
-        def get_name(self: Self, *, schema: tests.test_schemalike.Schema) -> str: ...
-        def get_required(self: Self, *, schema: tests.test_schemalike.Schema) -> bool: ...
-        def get_multi(self: Self, *, schema: tests.test_schemalike.Schema) -> bool: ...
-        def get_typ(self: Self, *, schema: tests.test_schemalike.Schema) -> tests.test_schemalike.Type: ...
-        def get_expr(self: Self, *, schema: tests.test_schemalike.Schema) -> tests.test_schemalike.Expression | None: ...
+        def get_name({getter_params}) -> str: ...
+        def get_required({getter_params}) -> bool: ...
+        def get_multi({getter_params}) -> bool: ...
+        def get_typ({getter_params}) -> tests.test_schemalike.Type: ...
+        def get_expr({getter_params}) -> tests.test_schemalike.Expression | None: ...
     """)

tests/test_type_eval.py

@@ -458,7 +458,10 @@ def f[T](self, x: T) -> OnlyIntToSet[T]: ...
     assert (
         f
         == Callable[
-            Params[Param[Literal["self"], Self], Param[Literal["x"], Vs[0]]],
+            Params[
+                Param[Literal["self"], Self],
+                Param[Literal["x"], Vs[0]],
+            ],
             OnlyIntToSet[Vs[0]],
         ]
     )
@@ -1283,7 +1286,7 @@ def test_eval_getarg_custom_08():
 def test_eval_getargs_generic_callable_01():
     T = TypeVar("T")
     t = GenericCallable[
-        tuple[T], lambda T: Callable[[Param[Literal["x"], T]], int]
+        tuple[T], lambda T: Callable[Params[Param[Literal["x"], T]], int]
     ]
     args = eval_typing(GetArgs[t, GenericCallable])
     assert args == tuple[tuple[T]]
@@ -1802,7 +1805,7 @@ def test_callable_to_signature_01():
     #     **kwargs: int
     # ) -> int:
     callable_type = Callable[
-        [
+        Params[
             Param[None, int],
             Param[Literal["b"], int],
             Param[Literal["c"], int, Literal["default"]],
@@ -2451,14 +2454,20 @@ def g(self) -> str: ...
             Member[Literal["b"], str, Never, Never, B],
             Member[
                 Literal["f"],
-                Callable[Params[Param[Literal["self"], Self]], int],
+                Callable[
+                    Params[Param[Literal["self"], Self]],
+                    int,
+                ],
                 Literal["ClassVar"],
                 object,
                 B,
             ],
             Member[
                 Literal["g"],
-                Callable[Params[Param[Literal["self"], Self]], str],
+                Callable[
+                    Params[Param[Literal["self"], Self]],
+                    str,
+                ],
                 Literal["ClassVar"],
                 object,
                 B,

typemap/type_eval/_eval_operators.py

@@ -493,22 +493,13 @@ def __repr__(self):
 
 
 def _callable_type_to_signature(callable_type: object) -> inspect.Signature:
-    """Convert a Callable type with Param specs to an inspect.Signature.
+    """Convert a Callable type to an inspect.Signature.
 
-    The callable_type should be of the form:
-        Callable[
-            [
-                Param[name, type, quals],
-                ...
-            ],
-            return_type,
-        ]
+    Extended callables use the form:
+        Callable[Params[Param[name, type, quals], ...], return_type]
 
-    Where:
-        - name is None for positional-only or variadic params, or a string
-        - type is the parameter type annotation
-        - quals is a Literal with any of: "*", "**", "keyword", "default"
-          or Never if no qualifiers
+    Standard callables use the form:
+        Callable[[type, ...], return_type]
     """
     args = typing.get_args(callable_type)
     if (
@@ -552,6 +543,28 @@ def _callable_type_to_signature(callable_type: object) -> inspect.Signature:
         # Unwrap Params wrapper
         if typing.get_origin(param_types) is Params:
             param_types = list(typing.get_args(param_types))
+        else:
+            # Standard callable (no Params wrapping) — build simple
+            # positional parameters from the type list
+            if isinstance(param_types, (list, tuple)):
+                params = []
+                for i, t in enumerate(param_types):
+                    params.append(
+                        inspect.Parameter(
+                            f"_arg{i}",
+                            kind=inspect.Parameter.POSITIONAL_ONLY,
+                            annotation=t,
+                        )
+                    )
+                if return_type is type(None):
+                    return_type = None
+                return inspect.Signature(
+                    parameters=params,
+                    return_annotation=return_type,
+                )
+            raise TypeError(
+                f"Expected Params[...] or list of types, got {param_types}"
+            )
 
     # Handle the case where param_types is a list of Param types
     if not isinstance(param_types, (list, tuple)):
@@ -698,10 +711,10 @@ def _callable_type_to_method(name, typ, ctx):
         else:
             cls_typ = type[typing.Self]  # type: ignore[name-defined]
         cls_param = Param[typing.Literal["cls"], cls_typ, quals]
-        typ = typing.Callable[[cls_param] + list(typing.get_args(params)), ret]
+        typ = typing.Callable[Params[cls_param, *typing.get_args(params)], ret]
     elif head is staticmethod:
         params, ret = typing.get_args(typ)
-        typ = typing.Callable[list(typing.get_args(params)), ret]
+        typ = typing.Callable[Params[*typing.get_args(params)], ret]
     else:
         params, ret = typing.get_args(typ)
         # Unwrap Params wrapper if present
@@ -729,7 +742,7 @@ def _callable_type_to_method(name, typ, ctx):
             for p in param_list
         ]
         ret = type(None) if name == "__init__" else ret
-        typ = typing.Callable[param_list, ret]
+        typ = typing.Callable[Params[*param_list], ret]
         head = lambda x: x
 
     func = _signature_to_function(name, _callable_type_to_signature(typ))