Expand existing tests.

Author: dnwpark

tests/test_type_eval.py

@@ -15,7 +15,6 @@
     Tuple,
     TypeVar,
     Union,
-    get_args,
     overload,
 )
 
@@ -428,20 +427,26 @@ def f[TX](self, x: TX) -> OnlyIntToSet[TX]: ...
 
     m = eval_typing(GetMember[C, Literal["f"]])
     assert eval_typing(GetName[m]) == Literal["f"]
+    assert eval_typing(IsAssignable[GetType[m], GenericCallable])
     assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
     assert eval_typing(GetDefiner[m]) == C
 
-    t = eval_typing(GetType[m])
-    Vs = get_args(get_args(t)[0])
-    L = get_args(t)[1]
-    f = L(*Vs)
-    assert (
-        f
-        == Callable[
-            [Param[Literal["self"], C], Param[Literal["x"], Vs[0]]],
-            OnlyIntToSet[Vs[0]],
-        ]
-    )
+    ft = m.__args__[1].__args__[1]
+    with _ensure_context():
+        assert (
+            ft(str)
+            == Callable[
+                [Param[Literal["self"], C], Param[Literal["x"], str]],
+                str,
+            ]
+        )
+        assert (
+            ft(int)
+            == Callable[
+                [Param[Literal["self"], C], Param[Literal["x"], int]],
+                set[int],
+            ]
+        )
 
 
 def test_getmember_03():
@@ -452,20 +457,26 @@ def f[T](self, x: T) -> OnlyIntToSet[T]: ...
 
     m = eval_typing(GetMember[P, Literal["f"]])
     assert eval_typing(GetName[m]) == Literal["f"]
+    assert eval_typing(IsAssignable[GetType[m], GenericCallable])
     assert eval_typing(GetQuals[m]) == Literal["ClassVar"]
     assert eval_typing(GetDefiner[m]) != C  # eval typing generates a new class
 
-    t = eval_typing(GetType[m])
-    Vs = get_args(get_args(t)[0])
-    L = get_args(t)[1]
-    f = L(*Vs)
-    assert (
-        f
-        == Callable[
-            [Param[Literal["self"], Self], Param[Literal["x"], Vs[0]]],
-            OnlyIntToSet[Vs[0]],
-        ]
-    )
+    ft = m.__args__[1].__args__[1]
+    with _ensure_context():
+        assert (
+            ft(str)
+            == Callable[
+                [Param[Literal["self"], Self], Param[Literal["x"], str]],
+                OnlyIntToSet[str],
+            ]
+        )
+        assert (
+            ft(int)
+            == Callable[
+                [Param[Literal["self"], Self], Param[Literal["x"], int]],
+                OnlyIntToSet[int],
+            ]
+        )
 
 
 def test_getmember_04():
@@ -790,15 +801,18 @@ def test_eval_getarg_callable_02():
     T = TypeVar("T")
 
     # Params not wrapped
-    f = Callable[[T], T]
+    f = lambda T: Callable[[T], T]
     gc = GenericCallable[tuple[T], f]
     t = eval_typing(GetArg[gc, GenericCallable, Literal[0]])
     assert t == tuple[T]
     gc_f = eval_typing(GetArg[gc, GenericCallable, Literal[1]])
     assert gc_f == Never
 
+    with _ensure_context():
+        assert gc.__args__[1](str) == Callable[[str], str]
+
     # Params wrapped
-    f = Callable[
+    f = lambda T: Callable[
         [
             Param[Literal[None], T, Literal["positional"]],
             Param[Literal["y"], T],
@@ -815,6 +829,19 @@ def test_eval_getarg_callable_02():
     gc_f = eval_typing(GetArg[gc, GenericCallable, Literal[1]])
     assert gc_f == Never
 
+    with _ensure_context():
+        assert (
+            gc.__args__[1](str)
+            == Callable[
+                [
+                    Param[Literal[None], str, Literal["positional"]],
+                    Param[Literal["y"], str],
+                    Param[Literal["z"], str, Literal["keyword"]],
+                ],
+                str,
+            ]
+        )
+
 
 type IndirectProtocol[T] = NewProtocol[*[m for m in Iter[Members[T]]],]
 type GetMethodLike[T, Name] = GetArg[
@@ -963,6 +990,20 @@ def f[T](self, x: T, /, y: T, *, z: T) -> T: ...
     f = eval_typing(GetArg[gc, GenericCallable, Literal[1]])
     assert f is Never
 
+    with _ensure_context():
+        assert (
+            gc.__args__[1](str)
+            == Callable[
+                [
+                    Param[Literal["self"], C, Literal["positional"]],
+                    Param[Literal["x"], str, Literal["positional"]],
+                    Param[Literal["y"], str],
+                    Param[Literal["z"], str, Literal["keyword"]],
+                ],
+                str,
+            ]
+        )
+
 
 def test_eval_getarg_callable_08():
     # generic classmethod
@@ -977,6 +1018,20 @@ def f[T](cls, x: T, /, y: T, *, z: T) -> T: ...
     f = eval_typing(GetArg[gc, GenericCallable, Literal[1]])
     assert f is Never
 
+    with _ensure_context():
+        assert (
+            gc.__args__[1](str)
+            == classmethod[
+                C,
+                tuple[
+                    Param[Literal["x"], str, Literal["positional"]],
+                    Param[Literal["y"], str],
+                    Param[Literal["z"], str, Literal["keyword"]],
+                ],
+                str,
+            ]
+        )
+
 
 def test_eval_getarg_callable_09():
     # generic staticmethod
@@ -991,6 +1046,19 @@ def f[T](x: T, /, y: T, *, z: T) -> T: ...
     f = eval_typing(GetArg[gc, GenericCallable, Literal[1]])
     assert f is Never
 
+    with _ensure_context():
+        assert (
+            gc.__args__[1](str)
+            == staticmethod[
+                tuple[
+                    Param[Literal["x"], str, Literal["positional"]],
+                    Param[Literal["y"], str],
+                    Param[Literal["z"], str, Literal["keyword"]],
+                ],
+                str,
+            ]
+        )
+
 
 def test_eval_getarg_tuple():
     t = tuple[int, ...]