more lenient

Author: JelleZijlstra

conformance/tests/directives_assert_type.py

@@ -19,13 +19,13 @@ def func1(
     e: Annotated[Literal[4], ""],
 ):
     assert_type(a, int | str)  # OK
-    assert_type(a, int | bool | str)  # OK (equivalent type)
     assert_type(b, list[int])  # OK
     assert_type(c, Any)  # OK
     assert_type(d, "ForwardReference")  # OK
     assert_type(e, Literal[4])  # OK
 
     assert_type(a, int)  # E: Type mismatch
+    assert_type(a, Any)  # E: Type mismatch
     assert_type(c, int)  # E: Type mismatch
     assert_type(e, int)  # E: Type mismatch
 
@@ -34,5 +34,12 @@ def func1(
     assert_type(a, int | str, a)  # E: too many arguments
 
 
+# > If the two types are :term:`equivalent` but syntactically different,
+# > the type checker may reject the ``assert_type()`` call::
+
+def func2(name: str):
+    assert_type(name, str | Literal["spam"])  # E?: Equivalent but not identical
+
+
 class ForwardReference:
     pass

docs/spec/directives.rst

@@ -17,9 +17,19 @@ should emit an error if the value is not of the specified type::
 
     def greet(name: str) -> None:
         assert_type(name, str)  # OK, inferred type of `name` is `str`
-        assert_type(name, str | Literal["spam"])  # OK, this type is equivalent to `str`
         assert_type(name, int)  # type checker error
 
+If the two types are :term:`equivalent` but syntactically different,
+the type checker may reject the ``assert_type()`` call::
+
+  from typing import assert_type, Literal
+
+  def greet(name: str) -> None:
+      assert_type(name, str | Literal["spam"])  # type checker may error
+
+Type checkers should aim to minimize cases where they reject
+``assert_type()`` calls that use equivalent types.
+
 The second argument must be a valid :term:`type expression`.
 
 .. _`reveal-type`: