[ty] Unions/intersections of gradual types should be assignable to Never (#24056)

ibraheemdev · web-flow · commit ffeee66dfaf1 · 2026-03-19T16:02:07.000-04:00
This showed up in #23761 with `Divergent | Any`.
diff --git a/crates/ty_python_semantic/resources/mdtest/type_properties/is_assignable_to.md b/crates/ty_python_semantic/resources/mdtest/type_properties/is_assignable_to.md
@@ -924,6 +924,24 @@ static_assert(is_assignable_to(Never, type[str]))
 static_assert(is_assignable_to(Never, type[Any]))
 ```
 
+### `Any` / `Unknown` is assignable to `Never`
+
+`Any` and `Unknown` are gradual types. They could materialize to any given type at runtime,
+including `Never`.
+
+```py
+from ty_extensions import static_assert, is_assignable_to, Unknown, Intersection
+from typing_extensions import Never, Any
+
+static_assert(is_assignable_to(Any, Never))
+static_assert(is_assignable_to(Unknown, Never))
+static_assert(is_assignable_to(Any | Unknown, Never))
+static_assert(is_assignable_to(Intersection[Any, int], Never))
+static_assert(is_assignable_to(Intersection[Unknown, int], Never))
+static_assert(not is_assignable_to(Any | int, Never))
+static_assert(not is_assignable_to(Unknown | int, Never))
+```
+
 ## Callable
 
 The examples provided below are only a subset of the possible cases and include the ones with
diff --git a/crates/ty_python_semantic/src/types/relation.rs b/crates/ty_python_semantic/src/types/relation.rs
@@ -897,9 +897,6 @@ impl<'a, 'c, 'db> TypeRelationChecker<'a, 'c, 'db> {
                 self.never()
             }
 
-            // `Never` is the bottom type, the empty set.
-            (_, Type::Never) => self.never(),
-
             (Type::NewTypeInstance(source_newtype), Type::NewTypeInstance(target_newtype)) => {
                 self.check_newtype_pair(db, source_newtype, target_newtype)
             }
@@ -1027,6 +1024,9 @@ impl<'a, 'c, 'db> TypeRelationChecker<'a, 'c, 'db> {
                 )
             }
 
+            // `Never` is the bottom type, the empty set.
+            (_, Type::Never) => self.never(),
+
             // Other than the special cases checked above, no other types are a subtype of a
             // typevar, since there's no guarantee what type the typevar will be specialized to.
             // (If the typevar is bounded, it might be specialized to a smaller type than the

Original file line number	Diff line number	Diff line change
`@@ -897,9 +897,6 @@ impl<'a, 'c, 'db> TypeRelationChecker<'a, 'c, 'db> {`
`897`	`897`	`self.never()`
`898`	`898`	`}`
`899`	`899`
`900`		- // `Never` is the bottom type, the empty set.
`901`		`- (_, Type::Never) => self.never(),`
`902`		`-`
`903`	`900`	`(Type::NewTypeInstance(source_newtype), Type::NewTypeInstance(target_newtype)) => {`
`904`	`901`	`self.check_newtype_pair(db, source_newtype, target_newtype)`
`905`	`902`	`}`
`@@ -1027,6 +1024,9 @@ impl<'a, 'c, 'db> TypeRelationChecker<'a, 'c, 'db> {`
`1027`	`1024`	`)`
`1028`	`1025`	`}`
`1029`	`1026`
	`1027`	+ // `Never` is the bottom type, the empty set.
	`1028`	`+ (_, Type::Never) => self.never(),`
	`1029`	`+`
`1030`	`1030`	`// Other than the special cases checked above, no other types are a subtype of a`
`1031`	`1031`	`// typevar, since there's no guarantee what type the typevar will be specialized to.`
`1032`	`1032`	`// (If the typevar is bounded, it might be specialized to a smaller type than the`