Import latest copy of conformance tests

Summary:
I noticed that Danny submitted a couple PRs to make the conformance tests more flexible on what lines they expect certain errors on. This diff pulls in those changes, which give us a nice conformance boost.

We do have a new conformance failure due to python/typing#2015.

Reviewed By: yangdanny97

Differential Revision: D78778303

fbshipit-source-id: 256563b1f8e983263d2425708861d91dc00a4330

Author: rchen152

conformance/third_party/aliases_newtype.py

@@ -14,6 +14,9 @@
 
 assert_type(UserId(5) + 1, int)
 
+# > NewType('Derived', Base) returns a dummy function
+_: type = UserId  # E: functions are not instances of `type`
+
 # > Both isinstance and issubclass, as well as subclassing will fail for
 # > NewType('Derived', Base) since function objects don’t support these
 # > operations.

conformance/third_party/aliases_type_statement.py

@@ -85,5 +85,5 @@ def func3():
 
 type RecursiveTypeAlias5[T] = T | list[RecursiveTypeAlias5[T]]
 
-type RecursiveTypeAlias6 = RecursiveTypeAlias7  # E[RTA6]: circular definition
-type RecursiveTypeAlias7 = RecursiveTypeAlias6  # E[RTA6]: circular definition
+type RecursiveTypeAlias6 = RecursiveTypeAlias7  # E[RTA6+]: circular definition
+type RecursiveTypeAlias7 = RecursiveTypeAlias6  # E[RTA6+]: circular definition

conformance/third_party/aliases_typealiastype.py

@@ -16,10 +16,10 @@
 GoodAlias1 = TypeAliasType("GoodAlias1", int)
 GoodAlias2 = TypeAliasType("GoodAlias2", list[T], type_params=(T,))
 GoodAlias3 = TypeAliasType("GoodAlias3", list[T] | list[S], type_params=(S, T))
-GoodAlias4 = TypeAliasType("GoodAlias4", T | list[GoodAlias4[T]], type_params=(T,))
+GoodAlias4 = TypeAliasType("GoodAlias4", T | "list[GoodAlias4[T]]", type_params=(T,))
 GoodAlias5 = TypeAliasType(
     "GoodAlias5",
-    Callable[P, TStr] | list[S] | list[GoodAlias5[S, TStr, P]] | tuple[*Ts],
+    Callable[P, TStr] | list[S] | list["GoodAlias5[S, TStr, P]"] | tuple[*Ts],
     type_params=(S, TStr, P, Ts),
 )
 
@@ -43,9 +43,9 @@ class ClassA(Generic[T]):
 BadAlias1 = TypeAliasType("BadAlias1", list[S], type_params=(T,))  # E: S not in scope
 BadAlias2 = TypeAliasType("BadAlias2", list[S])  # E: S not in scope
 BadAlias3 = TypeAliasType("BadAlias3", int, type_params=my_tuple)  # E: not literal tuple
-BadAlias4 = TypeAliasType("BadAlias4", BadAlias4)  # E: circular dependency
-BadAlias5 = TypeAliasType("BadAlias5", T | BadAlias5[str], type_params=(T,))  # E: circular dependency
-BadAlias6 = TypeAliasType("BadAlias6", BadAlias7)  # E: circular dependency
+BadAlias4 = TypeAliasType("BadAlias4", "BadAlias4")  # E: circular dependency
+BadAlias5 = TypeAliasType("BadAlias5", T | "BadAlias5[str]", type_params=(T,))  # E: circular dependency
+BadAlias6 = TypeAliasType("BadAlias6", "BadAlias7")  # E: circular dependency
 BadAlias7 = TypeAliasType("BadAlias7", BadAlias6)  # E?: circular dependency
 
 # The following are invalid type expressions for a type alias.
@@ -62,3 +62,5 @@ class ClassA(Generic[T]):
 BadAlias18 = TypeAliasType("BadAlias18", 1)  # E
 BadAlias19 = TypeAliasType("BadAlias19", list or set)  # E
 BadAlias20 = TypeAliasType("BadAlias20", f"{'int'}")  # E
+
+BadAlias21 = TypeAliasType("BadAlias21", list[BadAlias21])  # E

conformance/third_party/classes_classvar.py

@@ -57,8 +57,14 @@ class ClassA(Generic[T, P]):
     good1: CV[int] = 1
     good2: ClassVar[list[str]] = []
     good3: ClassVar[Any] = 1
+    # > If an assigned value is available, the type should be inferred as some type
+    # > to which this value is assignable.
+    # Here, type checkers could infer good4 as `float` or `Any`, for example.
     good4: ClassVar = 3.1
-    good5: Annotated[ClassVar[list[int]], ""] = []
+    # > If the `ClassVar` qualifier is used without any assigned value, the type
+    # > should be inferred as `Any`:
+    good5: ClassVar  #E? Type checkers may error on uninitialized ClassVar
+    good6: Annotated[ClassVar[list[int]], ""] = []
 
     def method1(self, a: ClassVar[int]):  # E: ClassVar not allowed here
         x: ClassVar[str] = ""  # E: ClassVar not allowed here
@@ -75,7 +81,7 @@ def method2(self) -> ClassVar[int]:  # E: ClassVar not allowed here
 assert_type(ClassA.good1, int)
 assert_type(ClassA.good2, list[str])
 assert_type(ClassA.good3, Any)
-assert_type(ClassA.good4, float)
+assert_type(ClassA.good5, Any)
 
 
 class BasicStarship: