equivalence like you've never seen

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/call/overloads.md

@@ -1073,6 +1073,11 @@ def f(a: Foo, b: list[str], c: list[LiteralString], e):
     # since both overloads match and they have return types that are not equivalent,
     # step (5) of the overload evaluation algorithm says we must evaluate the result of the
     # call as `Unknown`.
+    #
+    # Note: although the spec does not state as such (since intersections in general are not
+    # specified currently), `(str | LiteralString) & Unknown` might also be a reasonable type
+    # here (the union of all overload returns, intersected with `Unknown`) -- here that would
+    # simplify to `str & Unknown`.
     reveal_type(a.join(e))  # revealed: Unknown
 ```
 

crates/ty_python_semantic/resources/mdtest/protocols.md

@@ -1121,13 +1121,31 @@ from typing import TypeVar
 
 S = TypeVar("S")
 
+class NonGenericProto1(Protocol):
+    x: int
+    y: str
+
+class NonGenericProto2(Protocol):
+    y: str
+    x: int
+
+class Nominal1: ...
+class Nominal2: ...
+
 class GenericProto[T](Protocol):
     x: T
 
 class LegacyGenericProto(Protocol[S]):
     x: S
 
 static_assert(is_equivalent_to(GenericProto[int], LegacyGenericProto[int]))
+static_assert(is_equivalent_to(GenericProto[NonGenericProto1], LegacyGenericProto[NonGenericProto2]))
+
+static_assert(
+    is_equivalent_to(
+        GenericProto[NonGenericProto1 | Nominal1 | Nominal2], LegacyGenericProto[Nominal2 | Nominal1 | NonGenericProto2]
+    )
+)
 
 static_assert(not is_equivalent_to(GenericProto[str], GenericProto[int]))
 static_assert(not is_equivalent_to(GenericProto[str], LegacyGenericProto[int]))