fix is_subtype_of/is_assignable_to handling & organize test cases

Author: mtshiba

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_assignable_to.md

@@ -306,44 +306,25 @@ static_assert(is_assignable_to(Intersection[Unrelated, Not[int]], Not[int]))
 static_assert(is_assignable_to(Intersection[Intersection[str, Not[Literal[""]]], int], Intersection[str, Not[Literal[""]]]))
 static_assert(is_assignable_to(Intersection[Intersection[Any, Not[int]], Not[str]], Intersection[Any, Not[int]]))
 
+# The condition `is_assignable_to(T & U, U)` should still be satisfied after the following transformations:
 # `LiteralString & AlwaysTruthy` -> `LiteralString & ~Literal[""]`
-static_assert(is_assignable_to(Intersection[LiteralString, AlwaysTruthy], AlwaysTruthy))
 static_assert(is_assignable_to(Intersection[LiteralString, Not[Literal[""]]], AlwaysTruthy))
 static_assert(is_assignable_to(Intersection[LiteralString, Not[Literal["", "a"]]], AlwaysTruthy))
-static_assert(not is_assignable_to(Intersection[object, Not[Literal[""]]], AlwaysTruthy))
-static_assert(is_assignable_to(Intersection[LiteralString, Not[Literal[""]]], Intersection[AlwaysTruthy, Not[Literal[1]]]))
-# `LiteralString & ~AlwaysTruthy` -> `LiteralString & Literal[""]`
-static_assert(is_assignable_to(Intersection[LiteralString, Not[AlwaysTruthy]], Not[AlwaysTruthy]))
-static_assert(is_assignable_to(Intersection[LiteralString, Literal[""]], Not[AlwaysTruthy]))
-static_assert(not is_assignable_to(Intersection[LiteralString, Literal["", "a"]], Not[AlwaysTruthy]))
-static_assert(is_assignable_to(Intersection[LiteralString, Not[AlwaysTruthy]], Literal[""]))
-static_assert(is_assignable_to(Intersection[LiteralString, Literal[""]], Literal[""]))
-# `bool & ~AlwaysTruthy`, `bool & ~Literal[True]` -> `bool & Literal[False]`
-static_assert(is_assignable_to(Intersection[bool, Not[AlwaysTruthy]], Literal[False]))
-static_assert(is_assignable_to(Intersection[bool, Not[Literal[True]]], Literal[False]))
-
-# `LiteralString & AlwaysFalsy` -> `LiteralString & Literal[""]`
-static_assert(is_assignable_to(Intersection[LiteralString, AlwaysFalsy], AlwaysFalsy))
-static_assert(is_assignable_to(Intersection[LiteralString, Literal[""]], AlwaysFalsy))
-static_assert(not is_assignable_to(Intersection[LiteralString, Literal["", "a"]], AlwaysFalsy))
-static_assert(is_assignable_to(Intersection[LiteralString, AlwaysFalsy], Literal[""]))
+# `LiteralString & ~AlwaysTruthy` -> `Literal[""]`
+static_assert(is_assignable_to(Literal[""], Not[AlwaysTruthy]))
+static_assert(not is_assignable_to(Literal["", "a"], Not[AlwaysTruthy]))
+# `LiteralString & AlwaysFalsy` -> `Literal[""]`
+static_assert(is_assignable_to(Literal[""], AlwaysFalsy))
+static_assert(not is_assignable_to(Literal["", "a"], AlwaysFalsy))
 # `LiteralString & ~AlwaysFalsy`  -> `LiteralString & ~Literal[""]`
-static_assert(is_assignable_to(Intersection[LiteralString, Not[AlwaysFalsy]], Not[AlwaysFalsy]))
 static_assert(is_assignable_to(Intersection[LiteralString, Not[Literal[""]]], Not[AlwaysFalsy]))
 static_assert(is_assignable_to(Intersection[LiteralString, Not[Literal["", "a"]]], Not[AlwaysFalsy]))
-# `bool & ~AlwaysFalsy`, `bool & ~Literal[False]` -> `bool & Literal[True]`
-static_assert(is_assignable_to(Intersection[bool, Not[AlwaysFalsy]], Literal[True]))
-static_assert(is_assignable_to(Intersection[bool, Not[Literal[False]]], Literal[True]))
-# `bool & ~AlwaysFalsy`, `bool & ~Literal[False]` -> `bool & Literal[True]`
-static_assert(is_assignable_to(Intersection[bool, Not[AlwaysFalsy]], Literal[True]))
-static_assert(is_assignable_to(Intersection[bool, Not[Literal[False]]], Literal[True]))
-
-static_assert(is_assignable_to(Intersection[bool, Literal[False] | AlwaysTruthy], Literal[False] | AlwaysTruthy))
-static_assert(
-    is_assignable_to(
-        Intersection[Intersection[AlwaysFalsy, Not[Literal[False]]], bool], Intersection[AlwaysFalsy, Not[Literal[False]]]
-    )
-)
+# `bool & ~AlwaysTruthy`, `bool & ~Literal[True]` -> `Literal[False]`
+static_assert(is_assignable_to(Literal[False], Not[AlwaysTruthy]))
+static_assert(is_assignable_to(Literal[False], Not[Literal[True]]))
+# `bool & ~AlwaysFalsy`, `bool & ~Literal[False]` -> `Literal[True]`
+static_assert(is_assignable_to(Literal[True], Not[AlwaysFalsy]))
+static_assert(is_assignable_to(Literal[True], Not[Literal[False]]))
 ```
 
 ## General properties

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_disjoint_from.md

@@ -200,7 +200,7 @@ static_assert(is_disjoint_from(None, Intersection[int, Not[str]]))
 
 ```py
 from typing_extensions import Literal, LiteralString
-from knot_extensions import Intersection, Not, TypeOf, is_disjoint_from, static_assert
+from knot_extensions import Intersection, Not, TypeOf, is_disjoint_from, static_assert, AlwaysFalsy, AlwaysTruthy
 
 static_assert(is_disjoint_from(Literal[True], Literal[False]))
 static_assert(is_disjoint_from(Literal[True], Literal[1]))
@@ -231,6 +231,31 @@ static_assert(not is_disjoint_from(Literal["a"], str))
 static_assert(is_disjoint_from(Intersection[str, Not[Literal["a"]]], Literal["a"]))
 static_assert(is_disjoint_from(Intersection[str, Not[Literal["a", "b"]]], Literal["a"]))
 static_assert(not is_disjoint_from(Intersection[str, Not[Literal["a"]]], Literal["b"]))
+
+static_assert(is_disjoint_from(AlwaysFalsy, Intersection[LiteralString, Not[Literal[""]]]))
+static_assert(is_disjoint_from(AlwaysTruthy, Literal[""]))
+
+static_assert(is_disjoint_from(Intersection[Not[Literal[True]], Not[Literal[False]]], bool))
+static_assert(is_disjoint_from(Intersection[AlwaysFalsy, Not[Literal[False]]], bool))
+static_assert(is_disjoint_from(Intersection[AlwaysTruthy, Not[Literal[True]]], bool))
+static_assert(is_disjoint_from(Intersection[Literal[True], Not[AlwaysTruthy]], bool))
+static_assert(is_disjoint_from(Intersection[Literal[False], Not[AlwaysFalsy]], bool))
+
+# The condition `is_disjoint(T, Not[T])` must still be satisfied after the following transformations:
+# `LiteralString & AlwaysTruthy` -> `LiteralString & ~Literal[""]`
+static_assert(is_disjoint_from(Intersection[LiteralString, AlwaysTruthy], Not[LiteralString] | AlwaysFalsy))
+# `LiteralString & ~AlwaysTruthy` -> `LiteralString & Literal[""]`
+static_assert(is_disjoint_from(Intersection[LiteralString, Not[AlwaysTruthy]], Not[LiteralString] | AlwaysTruthy))
+# `bool & ~AlwaysTruthy`, `bool & ~Literal[True]` -> `bool & Literal[False]`
+static_assert(is_disjoint_from(Intersection[bool, Not[AlwaysTruthy]], Not[bool] | AlwaysTruthy))
+static_assert(is_disjoint_from(Intersection[bool, Not[Literal[True]]], Not[bool] | Literal[True]))
+# `LiteralString & AlwaysFalsy` -> `LiteralString & Literal[""]`
+static_assert(is_disjoint_from(Intersection[LiteralString, AlwaysFalsy], Not[LiteralString] | AlwaysTruthy))
+# `LiteralString & ~AlwaysFalsy`  -> `LiteralString & ~Literal[""]`
+static_assert(is_disjoint_from(Intersection[LiteralString, Not[AlwaysFalsy]], Not[LiteralString] | AlwaysFalsy))
+# `bool & ~AlwaysFalsy`, `bool & ~Literal[False]` -> `bool & Literal[True]`
+static_assert(is_disjoint_from(Intersection[bool, Not[AlwaysFalsy]], Not[bool] | AlwaysFalsy))
+static_assert(is_disjoint_from(Intersection[bool, Not[Literal[False]]], Not[bool] | Literal[False]))
 ```
 
 ### Class, module and function literals

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_equivalent_to.md

@@ -118,4 +118,26 @@ class R: ...
 static_assert(is_equivalent_to(Intersection[tuple[P | Q], R], Intersection[tuple[Q | P], R]))
 ```
 
+## Transformation by intersection
+
+```py
+from knot_extensions import Intersection, Not, AlwaysTruthy, AlwaysFalsy, static_assert, is_equivalent_to
+from typing_extensions import Literal, LiteralString
+
+# `LiteralString & AlwaysTruthy` -> `LiteralString & ~Literal[""]`
+static_assert(is_equivalent_to(Intersection[LiteralString, AlwaysTruthy], Intersection[LiteralString, Not[Literal[""]]]))
+# `LiteralString & ~AlwaysTruthy` -> `Literal[""]`
+static_assert(is_equivalent_to(Intersection[LiteralString, Not[AlwaysTruthy]], Literal[""]))
+# `LiteralString & AlwaysFalsy` -> `Literal[""]`
+static_assert(is_equivalent_to(Intersection[LiteralString, AlwaysFalsy], Literal[""]))
+# `LiteralString & ~AlwaysFalsy`  -> `LiteralString & ~Literal[""]`
+static_assert(is_equivalent_to(Intersection[LiteralString, Not[AlwaysFalsy]], Intersection[LiteralString, Not[Literal[""]]]))
+# `bool & ~AlwaysFalsy`, `bool & ~Literal[False]` -> `bool & Literal[True]`
+static_assert(is_equivalent_to(Intersection[bool, Not[AlwaysFalsy]], Literal[True]))
+static_assert(is_equivalent_to(Intersection[bool, Not[Literal[False]]], Literal[True]))
+# `bool & ~AlwaysTruthy`, `bool & ~Literal[True]` -> `bool & Literal[False]`
+static_assert(is_equivalent_to(Intersection[bool, Not[AlwaysTruthy]], Literal[False]))
+static_assert(is_equivalent_to(Intersection[bool, Not[Literal[True]]], Literal[False]))
+```
+
 [the equivalence relation]: https://typing.readthedocs.io/en/latest/spec/glossary.html#term-equivalent

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_subtype_of.md

@@ -297,36 +297,25 @@ static_assert(is_subtype_of(bool, Literal[True] | AlwaysFalsy))
 static_assert(not is_subtype_of(Literal[True] | AlwaysFalsy, Literal[False] | AlwaysTruthy))
 static_assert(is_subtype_of(LiteralString, Literal[""] | AlwaysTruthy))
 
+# The condition `is_subtype_of(T & U, U)` must still be satisfied after the following transformations:
 # `LiteralString & AlwaysTruthy` -> `LiteralString & ~Literal[""]`
-static_assert(is_subtype_of(Intersection[LiteralString, AlwaysTruthy], AlwaysTruthy))
 static_assert(is_subtype_of(Intersection[LiteralString, Not[Literal[""]]], AlwaysTruthy))
 static_assert(is_subtype_of(Intersection[LiteralString, Not[Literal["", "a"]]], AlwaysTruthy))
-static_assert(not is_subtype_of(Intersection[object, Not[Literal[""]]], AlwaysTruthy))
-# `LiteralString & ~AlwaysTruthy` -> `LiteralString & Literal[""]`
-static_assert(is_subtype_of(Intersection[LiteralString, Not[AlwaysTruthy]], Not[AlwaysTruthy]))
-static_assert(is_subtype_of(Intersection[LiteralString, Literal[""]], Not[AlwaysTruthy]))
-static_assert(not is_subtype_of(Intersection[LiteralString, Literal["", "a"]], Not[AlwaysTruthy]))
-static_assert(is_subtype_of(Intersection[LiteralString, Not[AlwaysTruthy]], Literal[""]))
-# `bool & ~AlwaysTruthy`, `bool & ~Literal[True]` -> `bool & Literal[False]`
-static_assert(is_subtype_of(Intersection[bool, Not[AlwaysTruthy]], Literal[False]))
-static_assert(is_subtype_of(Intersection[bool, Not[Literal[True]]], Literal[False]))
-
-# `LiteralString & AlwaysFalsy` -> `LiteralString & Literal[""]`
-static_assert(is_subtype_of(Intersection[LiteralString, AlwaysFalsy], AlwaysFalsy))
-static_assert(is_subtype_of(Intersection[LiteralString, Literal[""]], AlwaysFalsy))
-static_assert(not is_subtype_of(Intersection[LiteralString, Literal["", "a"]], AlwaysFalsy))
-static_assert(is_subtype_of(Intersection[LiteralString, AlwaysFalsy], Literal[""]))
-static_assert(is_subtype_of(Intersection[LiteralString, Literal[""]], Literal[""]))
-# `LiteralString & ~AlwaysFalsy`  -> `LiteralString & ~Literal[""]`
-static_assert(is_subtype_of(Intersection[LiteralString, Not[AlwaysFalsy]], Not[AlwaysFalsy]))
+# `LiteralString & ~AlwaysTruthy` -> `Literal[""]`
+static_assert(is_subtype_of(Literal[""], Not[AlwaysTruthy]))
+static_assert(not is_subtype_of(Literal["", "a"], Not[AlwaysTruthy]))
+# `LiteralString & AlwaysFalsy` -> `Literal[""]`
+static_assert(is_subtype_of(Literal[""], AlwaysFalsy))
+static_assert(not is_subtype_of(Literal["", "a"], AlwaysFalsy))
+# `LiteralString & ~AlwaysFalsy` -> `LiteralString & ~Literal[""]`
 static_assert(is_subtype_of(Intersection[LiteralString, Not[Literal[""]]], Not[AlwaysFalsy]))
 static_assert(is_subtype_of(Intersection[LiteralString, Not[Literal["", "a"]]], Not[AlwaysFalsy]))
-# `bool & ~AlwaysFalsy`, `bool & ~Literal[False]` -> `bool & Literal[True]`
-static_assert(is_subtype_of(Intersection[bool, Not[AlwaysFalsy]], Literal[True]))
-static_assert(is_subtype_of(Intersection[bool, Not[Literal[False]]], Literal[True]))
-# `bool & ~AlwaysFalsy`, `bool & ~Literal[False]` -> `bool & Literal[True]`
-static_assert(is_subtype_of(Intersection[bool, Not[AlwaysFalsy]], Literal[True]))
-static_assert(is_subtype_of(Intersection[bool, Not[Literal[False]]], Literal[True]))
+# `bool & ~AlwaysTruthy`, `bool & ~Literal[True]` -> `Literal[False]`
+static_assert(is_subtype_of(Literal[False], Not[AlwaysTruthy]))
+static_assert(is_subtype_of(Literal[False], Not[Literal[True]]))
+# `bool & ~AlwaysFalsy`, `bool & ~Literal[False]` -> `Literal[True]`
+static_assert(is_subtype_of(Literal[True], Not[AlwaysFalsy]))
+static_assert(is_subtype_of(Literal[True], Not[Literal[False]]))
 ```
 
 ### Module literals