[red-knot] Disjointness for callable types

Author: dhruvmanila

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

@@ -61,7 +61,7 @@ static_assert(is_disjoint_from(B2, FinalSubclass))
 ## Tuple types
 
 ```py
-from typing_extensions import Literal
+from typing_extensions import Literal, Never
 from knot_extensions import TypeOf, is_disjoint_from, static_assert
 
 static_assert(is_disjoint_from(tuple[()], TypeOf[object]))
@@ -80,6 +80,16 @@ static_assert(is_disjoint_from(tuple[Literal[1], Literal[2]], tuple[Literal[1],
 static_assert(not is_disjoint_from(tuple[Literal[1], Literal[2]], tuple[Literal[1], int]))
 ```
 
+If a tuple type contains a `Never` element, it is considered similar to `Never` itself and is
+disjoint from any other type.
+
+```py
+static_assert(is_disjoint_from(tuple[Never], tuple[Never]))
+static_assert(is_disjoint_from(tuple[int, Never], tuple[int, Never]))
+static_assert(is_disjoint_from(tuple[int, Never], tuple[Never, int]))
+static_assert(is_disjoint_from(tuple[int, Never], tuple[int, int]))
+```
+
 ## Unions
 
 ```py
@@ -353,3 +363,27 @@ class UsesMeta2(metaclass=Meta2): ...
 
 static_assert(is_disjoint_from(type[UsesMeta1], type[UsesMeta2]))
 ```
+
+## Callables
+
+No two callable types are disjoint because there exists a callable type
+`(*args: object, **kwargs: object) -> Never` that is a subtype of all fully static callable types.
+
+```py
+from knot_extensions import CallableTypeOf, is_disjoint_from, static_assert
+from typing_extensions import Callable, Literal, Never
+
+def mixed(a: int, /, b: str, *args: int, c: int = 2, **kwargs: int) -> Never: ...
+
+static_assert(not is_disjoint_from(Callable[[], Never], CallableTypeOf[mixed]))
+static_assert(not is_disjoint_from(Callable[[int, str], float], CallableTypeOf[mixed]))
+
+# Using gradual form
+static_assert(not is_disjoint_from(Callable[..., None], Callable[[], None]))
+static_assert(not is_disjoint_from(Callable[..., None], Callable[..., None]))
+static_assert(not is_disjoint_from(Callable[..., None], Callable[[Literal[1]], None]))
+
+# Using `Never`
+static_assert(not is_disjoint_from(Callable[[], Never], Callable[[], Never]))
+static_assert(not is_disjoint_from(Callable[[Never], str], Callable[[Never], int]))
+```

crates/red_knot_python_semantic/src/types.rs

@@ -1262,6 +1262,22 @@ impl<'db> Type<'db> {
                 Type::Callable(CallableType::WrapperDescriptorDunderGet),
             ) => !KnownClass::WrapperDescriptorType.is_subclass_of(db, class),
 
+            (
+                Type::Callable(CallableType::General(self_callable)),
+                Type::Callable(CallableType::General(other_callable)),
+            ) => {
+                // No two callable types are ever disjoint because
+                // `(*args: object, **kwargs: object) -> Never` is a subtype of all fully static
+                // callable types.
+                false
+            }
+
+            (Type::Callable(CallableType::General(_)), _)
+            | (_, Type::Callable(CallableType::General(_))) => {
+                // TODO: Implement disjointness for general callable types
+                false
+            }
+
             (Type::ModuleLiteral(..), other @ Type::Instance(..))
             | (other @ Type::Instance(..), Type::ModuleLiteral(..)) => {
                 // Modules *can* actually be instances of `ModuleType` subclasses
@@ -1298,12 +1314,6 @@ impl<'db> Type<'db> {
                 // TODO: add checks for the above cases once we support them
                 instance.is_disjoint_from(db, KnownClass::Tuple.to_instance(db))
             }
-
-            (Type::Callable(CallableType::General(_)), _)
-            | (_, Type::Callable(CallableType::General(_))) => {
-                // TODO: Implement disjointedness for general callable types
-                false
-            }
         }
     }