Move Callable functionality to existing eval_call_with_types.

Author: dnwpark

tests/test_qblike.py

@@ -2,7 +2,11 @@
 
 from typing import Literal, Unpack
 
-from typemap.type_eval import eval_call, eval_typing
+from typemap.type_eval import (
+    eval_call,
+    eval_call_with_types,
+    eval_typing,
+)
 from typemap.typing import (
     BaseTypedDict,
     NewProtocol,
@@ -122,3 +126,21 @@ class select[...]:
         class PropsOnly[tests.test_qblike.Tgt]:
             name: tests.test_qblike.Property[str]
     """)
+
+
+def test_qblike_4():
+    t = eval_call_with_types(
+        select,
+        A,
+        x=bool,
+        w=bool,
+        z=bool,
+    )
+    fmt = format_helper.format_class(t)
+
+    assert fmt == textwrap.dedent("""\
+        class select[...]:
+            x: tests.test_qblike.Property[int]
+            w: tests.test_qblike.Property[list[str]]
+            z: tests.test_qblike.Link[tests.test_qblike.PropsOnly[tests.test_qblike.Tgt]]
+        """)

tests/test_type_eval.py

@@ -17,7 +17,7 @@
 
 import pytest
 
-from typemap.type_eval import eval_typing, eval_type_call
+from typemap.type_eval import eval_call_with_types, eval_typing
 from typemap.typing import (
     Attrs,
     FromUnion,
@@ -850,17 +850,17 @@ def test_type_eval_annotated_04():
 
 
 def test_type_call_callable_01():
-    res = eval_type_call(Callable[[], int])
+    res = eval_call_with_types(Callable[[], int])
     assert res is int
 
 
 def test_type_call_callable_02():
-    res = eval_type_call(Callable[[Param[Literal["x"], int]], int], int)
+    res = eval_call_with_types(Callable[[Param[Literal["x"], int]], int], int)
     assert res is int
 
 
 def test_type_call_callable_03():
-    res = eval_type_call(
+    res = eval_call_with_types(
         Callable[[Param[Literal["x"], int, Literal["keyword"]]], int], x=int
     )
     assert res is int
@@ -869,21 +869,21 @@ def test_type_call_callable_03():
 def test_type_call_callable_04():
     class C: ...
 
-    res = eval_type_call(Callable[[Param[Literal["self"], Self]], int], C)
+    res = eval_call_with_types(Callable[[Param[Literal["self"], Self]], int], C)
     assert res is int
 
 
 def test_type_call_callable_05():
     class C: ...
 
-    res = eval_type_call(Callable[[Param[Literal["self"], Self]], C], C)
+    res = eval_call_with_types(Callable[[Param[Literal["self"], Self]], C], C)
     assert res is C
 
 
 def test_type_call_callable_06():
     class C: ...
 
-    res = eval_type_call(
+    res = eval_call_with_types(
         Callable[[Param[Literal["self"], Self], Param[Literal["x"], int]], int],
         C,
         int,
@@ -894,7 +894,7 @@ class C: ...
 def test_type_call_callable_07():
     class C: ...
 
-    res = eval_type_call(
+    res = eval_call_with_types(
         Callable[
             [
                 Param[Literal["self"], Self],
@@ -910,13 +910,13 @@ class C: ...
 
 def test_type_call_callable_08():
     T = TypeVar("T")
-    res = eval_type_call(Callable[[Param[Literal["x"], T]], str], int)
+    res = eval_call_with_types(Callable[[Param[Literal["x"], T]], str], int)
     assert res is str
 
 
 def test_type_call_callable_09():
     T = TypeVar("T")
-    res = eval_type_call(Callable[[Param[Literal["x"], T]], T], int)
+    res = eval_call_with_types(Callable[[Param[Literal["x"], T]], T], int)
     assert res is int
 
 
@@ -925,7 +925,7 @@ def test_type_call_callable_10():
 
     class C(Generic[T]): ...
 
-    res = eval_type_call(Callable[[Param[Literal["x"], C[T]]], T], C[int])
+    res = eval_call_with_types(Callable[[Param[Literal["x"], C[T]]], T], C[int])
     assert res is int
 
 
@@ -938,30 +938,30 @@ class D(C[int]): ...
 
     class E(D): ...
 
-    res = eval_type_call(Callable[[Param[Literal["x"], C[T]]], T], D)
+    res = eval_call_with_types(Callable[[Param[Literal["x"], C[T]]], T], D)
     assert res is int
-    res = eval_type_call(Callable[[Param[Literal["x"], C[T]]], T], E)
+    res = eval_call_with_types(Callable[[Param[Literal["x"], C[T]]], T], E)
     assert res is int
 
 
 def test_type_call_local_function_01():
     def func(x: int) -> int: ...
 
-    res = eval_type_call(func, int)
+    res = eval_call_with_types(func, int)
     assert res is int
 
 
 def test_type_call_local_function_02():
     def func(*, x: int) -> int: ...
 
-    res = eval_type_call(func, x=int)
+    res = eval_call_with_types(func, x=int)
     assert res is int
 
 
 def test_type_call_local_function_03():
     def func[T](x: T) -> T: ...
 
-    res = eval_type_call(func, int)
+    res = eval_call_with_types(func, int)
     assert res is int
 
 
@@ -970,7 +970,7 @@ class C: ...
 
     def func(x: C) -> C: ...
 
-    res = eval_type_call(func, C)
+    res = eval_call_with_types(func, C)
     assert res is C
 
 
@@ -979,7 +979,7 @@ class C: ...
 
     def func[T](x: T) -> T: ...
 
-    res = eval_type_call(func, C)
+    res = eval_call_with_types(func, C)
     assert res is C
 
 
@@ -990,7 +990,7 @@ class C(Generic[T]): ...
 
     def func[U](x: C[U]) -> C[U]: ...
 
-    res = eval_type_call(func, C[int])
+    res = eval_call_with_types(func, C[int])
     assert res == C[int]
 
 
@@ -1005,9 +1005,9 @@ class E(D): ...
 
     def func[U](x: C[U]) -> U: ...
 
-    res = eval_type_call(func, D)
+    res = eval_call_with_types(func, D)
     assert res is int
-    res = eval_type_call(func, E)
+    res = eval_call_with_types(func, E)
     assert res is int
 
 
@@ -1022,7 +1022,7 @@ class F(D, E): ...
 
     def func[U](x: C[U]) -> U: ...
 
-    res = eval_type_call(func, F)
+    res = eval_call_with_types(func, F)
     assert res is int
 
 
@@ -1031,7 +1031,7 @@ class C[T, U]: ...
 
     def func[V](x: C[int, V]) -> V: ...
 
-    res = eval_type_call(func, C[int, str])
+    res = eval_call_with_types(func, C[int, str])
     assert res is str
 
 
@@ -1041,7 +1041,7 @@ def test_type_call_bind_error_01():
     with pytest.raises(
         ValueError, match="Type variable T is already bound to int, but got str"
     ):
-        eval_type_call(
+        eval_call_with_types(
             Callable[[Param[Literal["x"], T], Param[Literal["y"], T]], T],
             int,
             str,
@@ -1054,7 +1054,7 @@ def func[T](x: T, y: T) -> T: ...
     with pytest.raises(
         ValueError, match="Type variable T is already bound to int, but got str"
     ):
-        eval_type_call(func, int, str)
+        eval_call_with_types(func, int, str)
 
 
 def test_type_call_bind_error_03():
@@ -1065,7 +1065,7 @@ class C(Generic[T]): ...
     with pytest.raises(
         ValueError, match="Type variable T is already bound to int, but got str"
     ):
-        eval_type_call(
+        eval_call_with_types(
             Callable[[Param[Literal["x"], C[T]], Param[Literal["y"], C[T]]], T],
             C[int],
             C[str],
@@ -1080,7 +1080,7 @@ def func[T](x: C[T], y: C[T]) -> T: ...
     with pytest.raises(
         ValueError, match="Type variable T is already bound to int, but got str"
     ):
-        eval_type_call(func, C[int], C[str])
+        eval_call_with_types(func, C[int], C[str])
 
 
 def test_type_call_bind_error_05():
@@ -1091,7 +1091,7 @@ class D[T]: ...
     def func[T](x: C[T]) -> T: ...
 
     with pytest.raises(ValueError, match="Argument type mismatch for x"):
-        eval_type_call(func, D[int])
+        eval_call_with_types(func, D[int])
 
 
 type GetCallableMember[T, N: str] = GetArg[
@@ -1112,23 +1112,23 @@ def test_type_call_member_01():
     class C:
         def invoke(self, x: int) -> int: ...
 
-    res = eval_type_call(GetCallableMember[C, Literal["invoke"]], C, int)
+    res = eval_call_with_types(GetCallableMember[C, Literal["invoke"]], C, int)
     assert res is int
 
 
 def test_type_call_member_02():
     class C:
         def invoke[T](self, x: T) -> T: ...
 
-    res = eval_type_call(GetCallableMember[C, Literal["invoke"]], C, int)
+    res = eval_call_with_types(GetCallableMember[C, Literal["invoke"]], C, int)
     assert res is int
 
 
 def test_type_call_member_03():
     class C[T]:
         def invoke(self, x: str) -> str: ...
 
-    res = eval_type_call(
+    res = eval_call_with_types(
         GetCallableMember[C[int], Literal["invoke"]], C[int], str
     )
     assert res is str
@@ -1138,7 +1138,7 @@ def test_type_call_member_04():
     class C[T]:
         def invoke(self, x: T) -> T: ...
 
-    res = eval_type_call(
+    res = eval_call_with_types(
         GetCallableMember[C[int], Literal["invoke"]], C[int], int
     )
     assert res is int
@@ -1148,15 +1148,17 @@ def test_type_call_member_05():
     class C[T]:
         def invoke(self) -> C[T]: ...
 
-    res = eval_type_call(GetCallableMember[C[int], Literal["invoke"]], C[int])
+    res = eval_call_with_types(
+        GetCallableMember[C[int], Literal["invoke"]], C[int]
+    )
     assert res == C[int]
 
 
 def test_type_call_member_06():
     class C[T]:
         def invoke[U](self, x: U) -> C[U]: ...
 
-    res = eval_type_call(
+    res = eval_call_with_types(
         GetCallableMember[C[int], Literal["invoke"]], C[int], str
     )
     assert res == C[str]

typemap/type_eval/__init__.py

@@ -7,7 +7,7 @@
 from ._apply_generic import flatten_class
 
 # XXX: this needs to go second due to nasty circularity -- try to fix that!!
-from ._eval_call import eval_call, eval_type_call
+from ._eval_call import eval_call, eval_call_with_types
 from ._subtype import issubtype
 from ._subsim import issubsimilar
 
@@ -19,7 +19,7 @@
     "eval_typing",
     "register_evaluator",
     "eval_call",
-    "eval_type_call",
+    "eval_call_with_types",
     "flatten_class",
     "issubtype",
     "issubsimilar",