Use equivalence in assert_type (facebook#2702)

Summary:
Pull Request resolved: facebook#2702

Changes `assert_type` to check for equivalence between types instead of normalizing types and and checking for equality. This is both more spec-compliant and simpler.

Most of the test changes are because we no longer normalize `Unknown` to `Any`. Looks like we also recognize some more types as equivalent that we previously thought were different, in numpy.

Differential Revision: D95641740

Author: rchen152

conformance/third_party/conformance.exp

@@ -1614,8 +1614,8 @@
     {
       "code": -2,
       "column": 12,
-      "concise_description": "assert_type(Any, int) failed",
-      "description": "assert_type(Any, int) failed",
+      "concise_description": "assert_type(Unknown, int) failed",
+      "description": "assert_type(Unknown, int) failed",
       "line": 96,
       "name": "assert-type",
       "severity": "error",
@@ -3688,8 +3688,8 @@
     {
       "code": -2,
       "column": 12,
-      "concise_description": "assert_type(Class8[Any], Class8[str]) failed",
-      "description": "assert_type(Class8[Any], Class8[str]) failed",
+      "concise_description": "assert_type(Class8[Unknown], Class8[str]) failed",
+      "description": "assert_type(Class8[Unknown], Class8[str]) failed",
       "line": 185,
       "name": "assert-type",
       "severity": "error",
@@ -5189,8 +5189,8 @@
     {
       "code": -2,
       "column": 12,
-      "concise_description": "assert_type(int, Any) failed",
-      "description": "assert_type(int, Any) failed",
+      "concise_description": "assert_type(int, Unknown) failed",
+      "description": "assert_type(int, Unknown) failed",
       "line": 116,
       "name": "assert-type",
       "severity": "error",
@@ -5222,8 +5222,8 @@
     {
       "code": -2,
       "column": 20,
-      "concise_description": "assert_type(int, Any) failed",
-      "description": "assert_type(int, Any) failed",
+      "concise_description": "assert_type(int, Unknown) failed",
+      "description": "assert_type(int, Unknown) failed",
       "line": 129,
       "name": "assert-type",
       "severity": "error",

conformance/third_party/conformance.result

@@ -16,7 +16,7 @@
   "annotations_coroutines.py": [],
   "annotations_forward_refs.py": [
     "Line 87: Unexpected errors ['Expected a type form, got instance of `(self: Self@ClassD) -> None`']",
-    "Line 96: Unexpected errors ['assert_type(Any, int) failed']"
+    "Line 96: Unexpected errors ['assert_type(Unknown, int) failed']"
   ],
   "annotations_generators.py": [
     "Line 140: Unexpected errors ['This `yield` expression is unreachable']",
@@ -42,7 +42,7 @@
     "Line 186: Expected 1 errors",
     "Line 197: Expected 1 errors",
     "Line 167: Unexpected errors ['assert_type(Class7[int], Class7[str]) failed', \"Argument `Literal['']` is not assignable to parameter `x` with type `int`\"]",
-    "Line 185: Unexpected errors ['assert_type(Class8[Any], Class8[str]) failed']"
+    "Line 185: Unexpected errors ['assert_type(Class8[Unknown], Class8[str]) failed']"
   ],
   "constructors_consistency.py": [],
   "dataclasses_descriptors.py": [

pyrefly/lib/alt/special_calls.rs

@@ -37,7 +37,6 @@ use crate::error::context::TypeCheckKind;
 use crate::types::callable::FunctionKind;
 use crate::types::callable::unexpected_keyword;
 use crate::types::class::Class;
-use crate::types::special_form::SpecialForm;
 use crate::types::tuple::Tuple;
 use crate::types::types::Type;
 
@@ -53,34 +52,15 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let ret = if args.len() == 2 {
             let expr_a = &args[0];
             let expr_b = &args[1];
-            let a = self.expr_infer_with_hint(expr_a, hint, errors);
-            let b = self.expr_untype(expr_b, TypeFormContext::FunctionArgument, errors);
-            let self_form = self.heap.mk_special_form(SpecialForm::SelfType);
-            let normalize_type = |ty: Type, expr: &Expr| {
-                let mut ty = self
-                    .canonicalize_all_class_types(
-                        self.solver().deep_force(ty),
-                        expr.range(),
-                        errors,
-                    )
-                    .promote_typevar_values(self.stdlib)
-                    .explicit_any()
-                    .explicit_literals()
-                    .noreturn_to_never()
-                    .nonetype_to_none()
-                    .anon_callables()
-                    .anon_typed_dicts(self.stdlib)
-                    .distribute_type_over_union(self.heap)
-                    .simplify_intersections();
-                // Make assert_type(Self@SomeClass, typing.Self) work.
-                ty.subst_self_type_mut(&self_form);
-                // Re-sort unions & drop any display names.
-                // Make sure to keep this as the final step before comparison.
-                ty.sort_unions_and_drop_names()
-            };
-            let a = normalize_type(a, expr_a);
-            let b = normalize_type(b, expr_b);
-            if a != b {
+            let a = self
+                .solver()
+                .deep_force(self.expr_infer_with_hint(expr_a, hint, errors));
+            let b = self.solver().deep_force(self.expr_untype(
+                expr_b,
+                TypeFormContext::FunctionArgument,
+                errors,
+            ));
+            if !self.is_equivalent(&a, &b) {
                 self.error(
                     errors,
                     range,

pyrefly/lib/test/annotation.rs

@@ -19,7 +19,7 @@ class D:
     def int(self) -> None:
         ...
     x: "int" = 0  # E: Expected a type form
-assert_type(D.x, int)  # E: assert_type(Any, int) failed
+assert_type(D.x, int)  # E: assert_type(Unknown, int) failed
 "#,
 );
 

pyrefly/lib/test/attributes.rs

@@ -333,7 +333,7 @@ class A[T]:
         return cls(x)
 
 assert_type(A[int].m(0), A[int])
-assert_type(A.m(0), A[int]) # TODO # E: assert_type(A[Any], A[int]) failed
+assert_type(A.m(0), A[int]) # TODO # E: assert_type(A[Unknown], A[int]) failed
 
 def test_typevar_bounds[T: A[int]](x: type[T]):
     assert_type(x.m(0), A[int])

pyrefly/lib/test/callable.rs

@@ -1418,7 +1418,7 @@ class Class8(Generic[T]):
 
 r8 = accepts_callable(Class8)
 # pyrefly incorrectly errors on this - should be OK
-assert_type(r8([""], [""]), Class8[str])  # E: assert_type(Class8[Any], Class8[str]) failed
+assert_type(r8([""], [""]), Class8[str])  # E: assert_type(Class8[Unknown], Class8[str]) failed
 "#,
 );
 

pyrefly/lib/test/contextual.rs

@@ -377,8 +377,8 @@ from typing import Callable, assert_type
 def f[**P, R](f: Callable[P, R], g: Callable[P, R]) -> Callable[P, R]: ...
 def g1(x: int, *args: int): ...
 def g2(x: int, **kwargs: str): ...
-x1 = f(g1, lambda x, *args: assert_type(args, tuple[int, ...])) # E: assert_type(Any, tuple[int, ...]) failed
-x2 = f(g2, lambda x, **kwargs: assert_type(kwargs, dict[str, str])) # E: assert_type(Any, dict[str, str]) failed
+x1 = f(g1, lambda x, *args: assert_type(args, tuple[int, ...])) # E: assert_type(Unknown, tuple[int, ...]) failed
+x2 = f(g2, lambda x, **kwargs: assert_type(kwargs, dict[str, str])) # E: assert_type(Unknown, dict[str, str]) failed
     "#,
 );
 
@@ -622,8 +622,8 @@ testcase!(
 from typing import Protocol, assert_type, Any
 class Identity(Protocol):
     def __call__(self, *args: int, **kwargs: int) -> Any: ...
-x: Identity = lambda *args, **kwargs: assert_type(args, tuple[int, ...]) # E: assert_type(Any, tuple[int, ...]) failed
-y: Identity = lambda *args, **kwargs: assert_type(kwargs, dict[str, int]) # E: assert_type(Any, dict[str, int]) failed
+x: Identity = lambda *args, **kwargs: assert_type(args, tuple[int, ...]) # E: assert_type(Unknown, tuple[int, ...]) failed
+y: Identity = lambda *args, **kwargs: assert_type(kwargs, dict[str, int]) # E: assert_type(Unknown, dict[str, int]) failed
     "#,
 );
 

pyrefly/lib/test/generic_restrictions.rs

@@ -267,7 +267,7 @@ class C[T = int]:
         return self
     attr: T
 reveal_type(C.meth)  # E: [T = int](self: C[T], /) -> C[T]
-assert_type(C.attr, int)  # E: assert_type(Any, int) failed  # E: Generic attribute `attr` of class `C` is not visible on the class
+assert_type(C.attr, int)  # E: assert_type(Unknown, int) failed  # E: Generic attribute `attr` of class `C` is not visible on the class
  "#,
 );
 
@@ -1052,7 +1052,7 @@ testcase!(
     r#"
 from typing import assert_type
 def f[T1, T2 = T1](x: T1, y: T2 | None = None) -> tuple[T1, T2]: ...
-assert_type(f(1), tuple[int, int])  # E: assert_type(tuple[int, Any], tuple[int, int])
+assert_type(f(1), tuple[int, int])  # E: assert_type(tuple[int, Unknown], tuple[int, int])
     "#,
 );