Various minor fixes

Author: sharkdp

crates/red_knot_python_semantic/resources/mdtest/annotations/any.md

@@ -46,64 +46,59 @@ def f():
 y: Any = "not an Any"  # error: [invalid-assignment]
 ```
 
-## Subclass
+## Subclasses if `Any`
 
 The spec allows you to define subclasses of `Any`.
 
-`Subclass` has an unknown superclass, which might be `int`. The assignment to `x` should not be
+`SubclassOfAny` has an unknown superclass, which might be `int`. The assignment to `x` should not be
 allowed, even when the unknown superclass is `int`. The assignment to `y` should be allowed, since
 `Subclass` might have `int` as a superclass, and is therefore assignable to `int`.
 
 ```py
 from typing import Any
 
-class Subclass(Any): ...
+class SubclassOfAny(Any): ...
 
-reveal_type(Subclass.__mro__)  # revealed: tuple[Literal[Subclass], Any, Literal[object]]
+reveal_type(SubclassOfAny.__mro__)  # revealed: tuple[Literal[SubclassOfAny], Any, Literal[object]]
 
-x: Subclass = 1  # error: [invalid-assignment]
-y: int = Subclass()
-
-def _(s: Subclass):
-    reveal_type(s)  # revealed: Subclass
+x: SubclassOfAny = 1  # error: [invalid-assignment]
+y: int = SubclassOfAny()
 ```
 
-`Subclass` should not be assignable to a final class though, because `Subclass` could not possibly
-be a subclass of `FinalClass`:
+`SubclassOfAny` should not be assignable to a final class though, because `SubclassOfAny` could not
+possibly be a subclass of `FinalClass`:
 
 ```py
 from typing import final
 
 @final
 class FinalClass: ...
 
-f: FinalClass = Subclass()  # error: [invalid-assignment]
-```
-
-A use case where this comes up is with mocking libraries, where the mock object should be assignable
-to any type:
+f: FinalClass = SubclassOfAny()  # error: [invalid-assignment]
 
-```py
-from unittest.mock import MagicMock
+@final
+class OtherFinalClass: ...
 
-x: int = MagicMock()
+f: FinalClass | OtherFinalClass = SubclassOfAny()  # error: [invalid-assignment]
 ```
 
-A subclass of `Any` can be assigned to a `Callable` and called.
+A subclass of `Any` can also be assigned to arbitrary `Callable` types:
 
 ```py
 from typing import Callable, Any
 
-class MockCallable(Any):
-    pass
-
-def takes_callable(f: Callable):
+def takes_callable1(f: Callable):
     f()
 
-takes_callable(MockCallable())
+takes_callable1(SubclassOfAny())
+
+def takes_callable2(f: Callable[[int], None]):
+    f(1)
+
+takes_callable2(SubclassOfAny())
 ```
 
-But `Any` cannot be assigned to `Final` or `Literal`
+A subclass of `Any` cannot be assigned to literal types, since those can not be subclassed:
 
 ```py
 from typing import Any, Literal
@@ -114,22 +109,15 @@ class MockAny(Any):
 x: Literal[1] = MockAny()  # error: [invalid-assignment]
 ```
 
+A use case where subclasses of `Any` come up is in mocking libraries, where the mock object should
+be assignable to (almost) any type:
 
 ```py
-from typing import final, Any
-
-@final
-class FinalA: ...
-
-@final
-class FinalB: ...
-
-class MockAny(Any): ...
+from unittest.mock import MagicMock
 
-value: FinalA  | FinalB  = MockAny()  # error: [invalid-assignment]
+x: int = MagicMock()
 ```
 
-
 ## Invalid
 
 `Any` cannot be parameterized:

crates/red_knot_python_semantic/src/types.rs

@@ -1354,25 +1354,6 @@ impl<'db> Type<'db> {
                 .iter()
                 .any(|&elem_ty| ty.is_assignable_to(db, elem_ty)),
 
-            // Subclasses of Any are assignable to non-final, non-literal types,
-            // as Any can materialize to any such type, but not to final or literal types.
-            (Type::Instance(instance), target)
-                if instance.class().is_subclass_of_any_or_unknown(db) =>
-            {
-                match target {
-                    Type::IntLiteral(_)
-                    | Type::BooleanLiteral(_)
-                    | Type::StringLiteral(_)
-                    | Type::BytesLiteral(_)
-                    | Type::LiteralString
-                    | Type::SliceLiteral(_) => false,
-                    Type::Instance(target_instance) if target_instance.class().is_final(db) => {
-                        false
-                    }
-                    _ => true,
-                }
-            }
-
             // If the typevar is constrained, there must be multiple constraints, and the typevar
             // might be specialized to any one of them. However, the constraints do not have to be
             // disjoint, which means an lhs type might be assignable to all of the constraints.
@@ -1496,6 +1477,12 @@ impl<'db> Type<'db> {
                 self_callable.is_assignable_to(db, target_callable)
             }
 
+            (Type::NominalInstance(instance), Type::Callable(_))
+                if instance.class().is_subclass_of_any_or_unknown(db) =>
+            {
+                true
+            }
+
             (Type::NominalInstance(_) | Type::ProtocolInstance(_), Type::Callable(_)) => {
                 let call_symbol = self.member(db, "__call__").symbol;
                 match call_symbol {

crates/red_knot_python_semantic/src/types/class.rs

@@ -284,13 +284,7 @@ impl<'db> ClassType<'db> {
             }
         }
 
-        if self.iter_mro(db).any(|base| {
-            matches!(
-                base,
-                ClassBase::Dynamic(DynamicType::Any | DynamicType::Unknown)
-            )
-        }) && !other.is_final(db)
-        {
+        if self.is_subclass_of_any_or_unknown(db) && !other.is_final(db) {
             return true;
         }