Conformance suite: Minor tweaks to several assertions for better compatibility with ty

conformance/tests/annotations_generators.py

@@ -190,4 +190,4 @@ async def generator30() -> AsyncIterator[int]:
     yield
 
 
-assert_type(generator30, Callable[[], AsyncIterator[int]])
+assert_type(generator30(), AsyncIterator[int])

conformance/tests/generics_defaults.py

@@ -41,8 +41,12 @@ class OneDefault(Generic[T, DefaultBoolT]): ...
 
 class AllTheDefaults(Generic[T1, T2, DefaultStrT, DefaultIntT, DefaultBoolT]): ...
 
+def needs_allthedefaults_or_subclass(x: type[AllTheDefaults[Any, Any, str, int, bool]]) -> None: ...
+
+# do not use `assert_type` here: some type checkers infer a more precise type
+# than `type[]` for class objects
+needs_allthedefaults_or_subclass(AllTheDefaults)  # OK
 
-assert_type(AllTheDefaults, type[AllTheDefaults[Any, Any, str, int, bool]])
 assert_type(
     AllTheDefaults[int, complex], type[AllTheDefaults[int, complex, str, int, bool]]
 )
@@ -91,7 +95,12 @@ class Class_ParamSpec(Generic[DefaultP]): ...
 class Class_TypeVarTuple(Generic[*DefaultTs]): ...
 
 
-assert_type(Class_TypeVarTuple, type[Class_TypeVarTuple[*tuple[str, int]]])
+def needs_classtypevartuple_or_subclass(x: type[Class_TypeVarTuple[Any, Any]]) -> None: ...
+
+# do not use `assert_type` here: some type checkers infer a more precise type
+# than `type[]` for class objects
+needs_classtypevartuple_or_subclass(Class_TypeVarTuple)  # OK
+
 assert_type(Class_TypeVarTuple(), Class_TypeVarTuple[str, int])
 assert_type(Class_TypeVarTuple[int, bool](), Class_TypeVarTuple[int, bool])
 

conformance/tests/generics_defaults_referential.py

@@ -91,7 +91,13 @@ class Bar(Generic[Z1, ListDefaultT]):  # OK
     def __init__(self, x: Z1, y: ListDefaultT): ...
 
 
-assert_type(Bar, type[Bar[Any, list[Any]]])
+def requires_bar_or_subclass(x: type[Bar[Any, list[Any]]]) -> None: ...
+
+# Don't use `assert_type(Bar, type[Bar[Any, list[Any]]])` here,
+# since some type checkers infer a more precise type than `type[]` for
+# class objects
+requires_bar_or_subclass(Bar)  # OK
+
 assert_type(Bar[int], type[Bar[int, list[int]]])
 assert_type(Bar[int](0, []), Bar[int, list[int]])
 assert_type(Bar[int, list[str]](0, []), Bar[int, list[str]])

conformance/tests/generics_scoping.py

@@ -1,6 +1,6 @@
 # Specification: https://typing.readthedocs.io/en/latest/spec/generics.html#scoping-rules-for-type-variables
 
-from typing import TypeVar, Generic, Iterable, TypeAlias, assert_type
+from typing import TypeVar, Generic, Iterable, TypeAlias, assert_type, Literal
 
 # > A type variable used in a generic function could be inferred to represent
 # > different types in the same code block.
@@ -11,8 +11,13 @@ def fun_1(x: T) -> T:  # T here
 def fun_2(x: T) -> T:  # and here could be different
     return x
 
-assert_type(fun_1(1), int)
-assert_type(fun_2('a'), str)
+# One of these two should pass; either is acceptable:
+assert_type(fun_1(1), int)  # E[fun1-int]
+assert_type(fun_1(1), Literal[1])  # E[fun1-int]
+
+# One of these two should pass; either is acceptable:
+assert_type(fun_1("a"), str)  # E[fun1-str]
+assert_type(fun_1("a"), Literal["a"])  # E[fun1-str]
 
 # > A type variable used in a method of a generic class that coincides
 # > with one of the variables that parameterize this class is always bound
@@ -39,8 +44,14 @@ def method(self, x: T, y: S) -> S:
         return y
 
 x: Foo[int] = Foo()
-assert_type(x.method(0, "abc"), str)
-assert_type(x.method(0, b"abc"), bytes)
+
+# Either of these is acceptable; one of the two should pass:
+assert_type(x.method(0, "abc"), str)  # E[method-str]
+assert_type(x.method(0, "abc"), Literal["abc"])  # E[method-str]
+
+# Either of these is acceptable; one of the two should pass:
+assert_type(x.method(0, b"abc"), bytes)  # E[method-bytes]
+assert_type(x.method(0, b"abc"), Literal[b"abc"])  # E[method-bytes]
 
 # > Unbound type variables should not appear in the bodies of generic functions,
 # > or in the class bodies apart from method definitions.

conformance/tests/generics_syntax_scoping.py

@@ -4,7 +4,7 @@
 
 # Specification: https://peps.python.org/pep-0695/#type-parameter-scopes
 
-from typing import Callable, Mapping, Sequence, TypeVar, assert_type
+from typing import Callable, Mapping, Literal, Sequence, TypeVar, assert_type
 
 # > A compiler error or runtime exception is generated if the definition
 # > of an earlier type parameter references a later type parameter even
@@ -102,23 +102,24 @@ def method3[T](self, x: T):  # E
 T = int(0)
 
 
-class Outer2[T]:
-    T = int(1)
-
-    assert_type(T, int)
+def f(a: int, b: str, c: complex):
+    class Outer2[T]:
+        T = a
 
-    class Inner1:
-        T = str("")
+        assert_type(T, int)
 
-        assert_type(T, str)
+        class Inner1:
+            T = b
 
-        def inner_method(self):
-            assert_type(T, TypeVar)
+            assert_type(T, str)
 
-    def outer_method(self):
-        T = 3j
+            def inner_method(self):
+                assert_type(T, TypeVar)
 
-        assert_type(T, complex)
+        def outer_method(self):
+            T = c
 
-        def inner_func():
             assert_type(T, complex)
+
+            def inner_func():
+                assert_type(T, complex)