Merge branch 'main' into dcreager/legacy-class

* main:
  Improve messages outputted by py-fuzzer (#17764)
  [`red-knot`] Allow subclasses of Any to be assignable to Callable types (#17717)
  [red-knot] Increase durability of read-only `File` fields (#17757)
  [red-knot] Cache source type during semanic index building (#17756)
  [`flake8-use-pathlib`] Fix `PTH116` false positive when `stat` is passed a file descriptor (#17709)
  Sync vendored typeshed stubs (#17753)

Author: dcreager

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

@@ -46,42 +46,71 @@ def f():
 y: Any = "not an Any"  # error: [invalid-assignment]
 ```
 
-## Subclass
+## Subclasses of `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]
+f: FinalClass = SubclassOfAny()  # error: [invalid-assignment]
+
+@final
+class OtherFinalClass: ...
+
+f: FinalClass | OtherFinalClass = SubclassOfAny()  # error: [invalid-assignment]
+```
+
+A subclass of `Any` can also be assigned to arbitrary `Callable` types:
+
+```py
+from typing import Callable, Any
+
+def takes_callable1(f: Callable):
+    f()
+
+takes_callable1(SubclassOfAny())
+
+def takes_callable2(f: Callable[[int], None]):
+    f(1)
+
+takes_callable2(SubclassOfAny())
+```
+
+A subclass of `Any` cannot be assigned to literal types, since those can not be subclassed:
+
+```py
+from typing import Any, Literal
+
+class MockAny(Any):
+    pass
+
+x: Literal[1] = MockAny()  # error: [invalid-assignment]
 ```
 
-A use case where this comes up is with mocking libraries, where the mock object should be assignable
-to any type:
+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 unittest.mock import MagicMock

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -10,7 +10,7 @@ use ruff_db::source::{source_text, SourceText};
 use ruff_index::IndexVec;
 use ruff_python_ast::name::Name;
 use ruff_python_ast::visitor::{walk_expr, walk_pattern, walk_stmt, Visitor};
-use ruff_python_ast::{self as ast, PythonVersion};
+use ruff_python_ast::{self as ast, PySourceType, PythonVersion};
 use ruff_python_parser::semantic_errors::{
     SemanticSyntaxChecker, SemanticSyntaxContext, SemanticSyntaxError,
 };
@@ -75,6 +75,7 @@ pub(super) struct SemanticIndexBuilder<'db> {
     // Builder state
     db: &'db dyn Db,
     file: File,
+    source_type: PySourceType,
     module: &'db ParsedModule,
     scope_stack: Vec<ScopeInfo>,
     /// The assignments we're currently visiting, with
@@ -118,6 +119,7 @@ impl<'db> SemanticIndexBuilder<'db> {
         let mut builder = Self {
             db,
             file,
+            source_type: file.source_type(db.upcast()),
             module: parsed,
             scope_stack: Vec::new(),
             current_assignments: vec![],
@@ -445,7 +447,7 @@ impl<'db> SemanticIndexBuilder<'db> {
         #[allow(unsafe_code)]
         // SAFETY: `definition_node` is guaranteed to be a child of `self.module`
         let kind = unsafe { definition_node.into_owned(self.module.clone()) };
-        let category = kind.category(self.file.is_stub(self.db.upcast()));
+        let category = kind.category(self.source_type.is_stub());
         let is_reexported = kind.is_reexported();
 
         let definition = Definition::new(

crates/red_knot_python_semantic/src/types.rs

@@ -1465,6 +1465,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

@@ -249,6 +249,16 @@ impl<'db> ClassType<'db> {
         class_literal.is_final(db)
     }
 
+    /// Is this class a subclass of `Any` or `Unknown`?
+    pub(crate) fn is_subclass_of_any_or_unknown(self, db: &'db dyn Db) -> bool {
+        self.iter_mro(db).any(|base| {
+            matches!(
+                base,
+                ClassBase::Dynamic(DynamicType::Any | DynamicType::Unknown)
+            )
+        })
+    }
+
     /// If `self` and `other` are generic aliases of the same generic class, returns their
     /// corresponding specializations.
     fn compatible_specializations(
@@ -328,13 +338,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;
         }
 

crates/red_knot_vendored/vendor/typeshed/source_commit.txt

@@ -1 +1 @@
-f65bdc1acde54fda93c802459280da74518d2eef
+eec809d049d10a5ae9b88780eab15fe36a9768d7

crates/red_knot_vendored/vendor/typeshed/stdlib/_frozen_importlib_external.pyi

@@ -36,7 +36,10 @@ def spec_from_file_location(
     loader: LoaderProtocol | None = None,
     submodule_search_locations: list[str] | None = ...,
 ) -> importlib.machinery.ModuleSpec | None: ...
-
+@deprecated(
+    "Deprecated as of Python 3.6: Use site configuration instead. "
+    "Future versions of Python may not enable this finder by default."
+)
 class WindowsRegistryFinder(importlib.abc.MetaPathFinder):
     if sys.version_info < (3, 12):
         @classmethod
@@ -118,6 +121,13 @@ class FileLoader:
 class SourceFileLoader(importlib.abc.FileLoader, FileLoader, importlib.abc.SourceLoader, SourceLoader):  # type: ignore[misc]  # incompatible method arguments in base classes
     def set_data(self, path: str, data: ReadableBuffer, *, _mode: int = 0o666) -> None: ...
     def path_stats(self, path: str) -> Mapping[str, Any]: ...
+    def source_to_code(  # type: ignore[override]  # incompatible with InspectLoader.source_to_code
+        self,
+        data: ReadableBuffer | str | _ast.Module | _ast.Expression | _ast.Interactive,
+        path: ReadableBuffer | StrPath,
+        *,
+        _optimize: int = -1,
+    ) -> types.CodeType: ...
 
 class SourcelessFileLoader(importlib.abc.FileLoader, FileLoader, _LoaderBasics):
     def get_code(self, fullname: str) -> types.CodeType | None: ...

crates/red_knot_vendored/vendor/typeshed/stdlib/ast.pyi

@@ -1893,8 +1893,12 @@ if sys.version_info >= (3, 14):
     def compare(left: AST, right: AST, /, *, compare_attributes: bool = False) -> bool: ...
 
 class NodeVisitor:
+    # All visit methods below can be overwritten by subclasses and return an
+    # arbitrary value, which is passed to the caller.
     def visit(self, node: AST) -> Any: ...
     def generic_visit(self, node: AST) -> Any: ...
+    # The following visit methods are not defined on NodeVisitor, but can
+    # be implemented by subclasses and are called during a visit if defined.
     def visit_Module(self, node: Module) -> Any: ...
     def visit_Interactive(self, node: Interactive) -> Any: ...
     def visit_Expression(self, node: Expression) -> Any: ...

crates/red_knot_vendored/vendor/typeshed/stdlib/contextlib.pyi

@@ -179,7 +179,7 @@ class AsyncExitStack(_BaseExitStack[_ExitT_co], metaclass=abc.ABCMeta):
     async def __aenter__(self) -> Self: ...
     async def __aexit__(
         self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
-    ) -> bool: ...
+    ) -> _ExitT_co: ...
 
 if sys.version_info >= (3, 10):
     class nullcontext(AbstractContextManager[_T, None], AbstractAsyncContextManager[_T, None]):

crates/red_knot_vendored/vendor/typeshed/stdlib/curses/__init__.pyi

@@ -23,11 +23,6 @@ COLOR_PAIRS: int
 
 def wrapper(func: Callable[Concatenate[window, _P], _T], /, *arg: _P.args, **kwds: _P.kwargs) -> _T: ...
 
-# typeshed used the name _CursesWindow for the underlying C class before
-# it was mapped to the name 'window' in 3.8.
-# Kept here as a legacy alias in case any third-party code is relying on it.
-_CursesWindow = window
-
 # At runtime this class is unexposed and calls itself curses.ncurses_version.
 # That name would conflict with the actual curses.ncurses_version, which is
 # an instance of this class.

crates/red_knot_vendored/vendor/typeshed/stdlib/email/_header_value_parser.pyi

@@ -17,9 +17,9 @@ TOKEN_ENDS: Final[set[str]]
 ASPECIALS: Final[set[str]]
 ATTRIBUTE_ENDS: Final[set[str]]
 EXTENDED_ATTRIBUTE_ENDS: Final[set[str]]
-# Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+# Added in Python 3.9.20, 3.10.15, 3.11.10, 3.12.5
 NLSET: Final[set[str]]
-# Added in Python 3.8.20, 3.9.20, 3.10.15, 3.11.10, 3.12.5
+# Added in Python 3.9.20, 3.10.15, 3.11.10, 3.12.5
 SPECIALSNL: Final[set[str]]
 
 if sys.version_info >= (3, 10):