don't consider self

Resolves https://github.com/astral-sh/ruff/issues/20512

This PR expands FA102’s preview coverage to flag every
PEP 585-compatible API that breaks without from `from __future__ import
annotations`, including `collections.abc`. The rule now treats asyncio
futures, pathlib-style queues, weakref containers, shelve proxies, and
the full `collections.abc` family as generics once preview mode is
enabled.

Stable behavior is unchanged; the broader matching runs behind
`is_future_required_preview_generics_enabled`, letting us vet the new
diagnostics before marking them as stable.

I've also added a snapshot test that covers all of the newly supported
types.

Check out
https://docs.python.org/3/library/stdtypes.html#standard-generic-classes
for a list of commonly used PEP 585-compatible APIs.

.github/workflows/ci.yaml

@@ -932,7 +932,7 @@ jobs:
           tool: cargo-codspeed
 
       - name: "Build benchmarks"
-        run: cargo codspeed build --features "codspeed,instrumented" --no-default-features -p ruff_benchmark formatter lexer linter parser
+        run: cargo codspeed build --features "codspeed,instrumented" --no-default-features -p ruff_benchmark --bench formatter --bench lexer --bench linter --bench parser
 
       - name: "Run benchmarks"
         uses: CodSpeedHQ/action@653fdc30e6c40ffd9739e40c8a0576f4f4523ca1 # v4.0.1
@@ -967,7 +967,7 @@ jobs:
           tool: cargo-codspeed
 
       - name: "Build benchmarks"
-        run: cargo codspeed build --features "codspeed,instrumented" --no-default-features -p ruff_benchmark ty
+        run: cargo codspeed build --features "codspeed,instrumented" --no-default-features -p ruff_benchmark --bench ty
 
       - name: "Run benchmarks"
         uses: CodSpeedHQ/action@653fdc30e6c40ffd9739e40c8a0576f4f4523ca1 # v4.0.1

CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## 0.13.3
+
+Released on 2025-10-02.
+
+### Preview features
+
+- Display diffs for `ruff format --check` and add support for different output formats ([#20443](https://github.com/astral-sh/ruff/pull/20443))
+- \[`pyflakes`\] Handle some common submodule import situations for `unused-import` (`F401`) ([#20200](https://github.com/astral-sh/ruff/pull/20200))
+- \[`ruff`\] Do not flag `%r` + `repr()` combinations (`RUF065`) ([#20600](https://github.com/astral-sh/ruff/pull/20600))
+
+### Bug fixes
+
+- \[`cli`\] Add conflict between `--add-noqa` and `--diff` options ([#20642](https://github.com/astral-sh/ruff/pull/20642))
+- \[`pylint`\] Exempt required imports from `PLR0402` ([#20381](https://github.com/astral-sh/ruff/pull/20381))
+- \[`pylint`\] Fix missing `max-nested-blocks` in settings display ([#20574](https://github.com/astral-sh/ruff/pull/20574))
+- \[`pyupgrade`\] Prevent infinite loop with `I002` and `UP026` ([#20634](https://github.com/astral-sh/ruff/pull/20634))
+
+### Rule changes
+
+- \[`flake8-simplify`\] Improve help message clarity (`SIM105`) ([#20548](https://github.com/astral-sh/ruff/pull/20548))
+
+### Documentation
+
+- Add the *The Basics* title back to CONTRIBUTING.md ([#20624](https://github.com/astral-sh/ruff/pull/20624))
+- Fixed documentation for try_consider_else ([#20587](https://github.com/astral-sh/ruff/pull/20587))
+- \[`isort`\] Clarify dependency between `order-by-type` and `case-sensitive` settings ([#20559](https://github.com/astral-sh/ruff/pull/20559))
+- \[`pylint`\] Clarify fix safety to include left-hand hashability (`PLR6201`) ([#20518](https://github.com/astral-sh/ruff/pull/20518))
+
+### Other changes
+
+- \[`playground`\] Fix quick fixes for empty ranges in playground ([#20599](https://github.com/astral-sh/ruff/pull/20599))
+
+### Contributors
+
+- [@TaKO8Ki](https://github.com/TaKO8Ki)
+- [@ntBre](https://github.com/ntBre)
+- [@dylwil3](https://github.com/dylwil3)
+- [@MichaReiser](https://github.com/MichaReiser)
+- [@danparizher](https://github.com/danparizher)
+- [@LilMonk](https://github.com/LilMonk)
+- [@mgiovani](https://github.com/mgiovani)
+- [@IDrokin117](https://github.com/IDrokin117)
+
 ## 0.13.2
 
 Released on 2025-09-25.

Cargo.lock

@@ -2738,7 +2738,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.13.2"
+version = "0.13.3"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2994,7 +2994,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.13.2"
+version = "0.13.3"
 dependencies = [
  "aho-corasick",
  "anyhow",
@@ -3348,7 +3348,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.13.2"
+version = "0.13.3"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -4449,6 +4449,7 @@ dependencies = [
  "ruff_source_file",
  "ruff_text_size",
  "serde-wasm-bindgen",
+ "tracing",
  "ty_ide",
  "ty_project",
  "ty_python_semantic",

README.md

@@ -148,8 +148,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.13.2/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.13.2/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.13.3/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.13.3/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -182,7 +182,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.13.2
+  rev: v0.13.3
   hooks:
     # Run the linter.
     - id: ruff-check

_typos.toml

@@ -31,6 +31,7 @@ extend-ignore-re = [
     "typ",
     # TODO: Remove this once the `TYP` redirects are removed from `rule_redirects.rs`
     "TYP",
+    "ntBre"
 ]
 
 [default.extend-identifiers]

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.13.2"
+version = "0.13.3"
 publish = true
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff/src/main.rs

@@ -1,6 +1,7 @@
 use std::io::Write;
 use std::process::ExitCode;
 
+use anyhow::Context;
 use clap::Parser;
 use colored::Colorize;
 
@@ -39,39 +40,46 @@ pub fn main() -> ExitCode {
     }
 
     let args = wild::args_os();
-    let args = argfile::expand_args_from(args, argfile::parse_fromfile, argfile::PREFIX).unwrap();
+    let args = match argfile::expand_args_from(args, argfile::parse_fromfile, argfile::PREFIX)
+        .context("Failed to read CLI arguments from files")
+    {
+        Ok(args) => args,
+        Err(err) => return report_error(&err),
+    };
 
     let args = Args::parse_from(args);
 
     match run(args) {
         Ok(code) => code.into(),
-        Err(err) => {
-            {
-                // Exit "gracefully" on broken pipe errors.
-                //
-                // See: https://github.com/BurntSushi/ripgrep/blob/bf63fe8f258afc09bae6caa48f0ae35eaf115005/crates/core/main.rs#L47C1-L61C14
-                for cause in err.chain() {
-                    if let Some(ioerr) = cause.downcast_ref::<std::io::Error>() {
-                        if ioerr.kind() == std::io::ErrorKind::BrokenPipe {
-                            return ExitCode::from(0);
-                        }
-                    }
-                }
-
-                // Use `writeln` instead of `eprintln` to avoid panicking when the stderr pipe is broken.
-                let mut stderr = std::io::stderr().lock();
-
-                // This communicates that this isn't a linter error but ruff itself hard-errored for
-                // some reason (e.g. failed to resolve the configuration)
-                writeln!(stderr, "{}", "ruff failed".red().bold()).ok();
-                // Currently we generally only see one error, but e.g. with io errors when resolving
-                // the configuration it is help to chain errors ("resolving configuration failed" ->
-                // "failed to read file: subdir/pyproject.toml")
-                for cause in err.chain() {
-                    writeln!(stderr, "  {} {cause}", "Cause:".bold()).ok();
-                }
-            }
-            ExitStatus::Error.into()
-        }
+        Err(err) => report_error(&err),
     }
 }
+
+fn report_error(err: &anyhow::Error) -> ExitCode {
+    {
+        // Exit "gracefully" on broken pipe errors.
+        //
+        // See: https://github.com/BurntSushi/ripgrep/blob/bf63fe8f258afc09bae6caa48f0ae35eaf115005/crates/core/main.rs#L47C1-L61C14
+        for cause in err.chain() {
+            if let Some(ioerr) = cause.downcast_ref::<std::io::Error>() {
+                if ioerr.kind() == std::io::ErrorKind::BrokenPipe {
+                    return ExitCode::from(0);
+                }
+            }
+        }
+
+        // Use `writeln` instead of `eprintln` to avoid panicking when the stderr pipe is broken.
+        let mut stderr = std::io::stderr().lock();
+
+        // This communicates that this isn't a linter error but ruff itself hard-errored for
+        // some reason (e.g. failed to resolve the configuration)
+        writeln!(stderr, "{}", "ruff failed".red().bold()).ok();
+        // Currently we generally only see one error, but e.g. with io errors when resolving
+        // the configuration it is help to chain errors ("resolving configuration failed" ->
+        // "failed to read file: subdir/pyproject.toml")
+        for cause in err.chain() {
+            writeln!(stderr, "  {} {cause}", "Cause:".bold()).ok();
+        }
+    }
+    ExitStatus::Error.into()
+}

crates/ruff/tests/integration_test.rs

@@ -1688,6 +1688,27 @@ fn check_input_from_argfile() -> Result<()> {
     Ok(())
 }
 
+#[test]
+// Regression test for https://github.com/astral-sh/ruff/issues/20655
+fn missing_argfile_reports_error() {
+    let mut cmd = RuffCheck::default().filename("@!.txt").build();
+    insta::with_settings!({filters => vec![
+        ("The system cannot find the file specified.", "No such file or directory")
+    ]}, {
+        assert_cmd_snapshot!(cmd, @r"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    ruff failed
+      Cause: Failed to read CLI arguments from files
+      Cause: failed to open file `!.txt`
+      Cause: No such file or directory (os error 2)
+    ");
+    });
+}
+
 #[test]
 fn check_hints_hidden_unsafe_fixes() {
     let mut cmd = RuffCheck::default()

crates/ruff_db/src/files/file_root.rs

@@ -95,7 +95,10 @@ impl FileRoots {
         self.by_path.insert(route.clone(), root).unwrap();
 
         // Insert a path that matches all subdirectories and files
-        route.push_str("/{*filepath}");
+        if !route.ends_with("/") {
+            route.push('/');
+        }
+        route.push_str("{*filepath}");
 
         self.by_path.insert(route, root).unwrap();
         self.roots.push(root);

crates/ruff_linter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.13.2"
+version = "0.13.3"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff_linter/resources/test/fixtures/flake8_annotations/shadowed_builtins.py

@@ -0,0 +1,21 @@
+from collections import UserString as str
+from typing import override
+
+def foo():
+    return "!"
+
+def _foo():
+    return "!"
+
+class C:
+    @override
+    def __str__(self):
+        return "!"
+    
+    @staticmethod
+    def foo():
+        return "!"
+    
+    @classmethod
+    def bar(cls):
+        return "!"

crates/ruff_linter/resources/test/fixtures/flake8_future_annotations/no_future_import_uses_preview_generics.py

@@ -0,0 +1,91 @@
+import asyncio
+import collections
+import contextlib
+import dataclasses
+import functools
+import os
+import queue
+import re
+import shelve
+import types
+import weakref
+from collections.abc import (
+    AsyncGenerator,
+    AsyncIterable,
+    AsyncIterator,
+    Awaitable,
+    ByteString,
+    Callable,
+    Collection,
+    Container,
+    Coroutine,
+    Generator,
+    Iterable,
+    Iterator,
+    ItemsView,
+    KeysView,
+    Mapping,
+    MappingView,
+    MutableMapping,
+    MutableSequence,
+    MutableSet,
+    Reversible,
+    Sequence,
+    Set,
+    ValuesView,
+)
+
+
+def takes_preview_generics(
+    future: asyncio.Future[int],
+    task: asyncio.Task[str],
+    deque_object: collections.deque[int],
+    defaultdict_object: collections.defaultdict[str, int],
+    ordered_dict: collections.OrderedDict[str, int],
+    counter_obj: collections.Counter[str],
+    chain_map: collections.ChainMap[str, int],
+    context_manager: contextlib.AbstractContextManager[str],
+    async_context_manager: contextlib.AbstractAsyncContextManager[int],
+    dataclass_field: dataclasses.Field[int],
+    cached_prop: functools.cached_property[int],
+    partial_method: functools.partialmethod[int],
+    path_like: os.PathLike[str],
+    lifo_queue: queue.LifoQueue[int],
+    regular_queue: queue.Queue[int],
+    priority_queue: queue.PriorityQueue[int],
+    simple_queue: queue.SimpleQueue[int],
+    regex_pattern: re.Pattern[str],
+    regex_match: re.Match[str],
+    bsd_db_shelf: shelve.BsdDbShelf[str, int],
+    db_filename_shelf: shelve.DbfilenameShelf[str, int],
+    shelf_obj: shelve.Shelf[str, int],
+    mapping_proxy: types.MappingProxyType[str, int],
+    weak_key_dict: weakref.WeakKeyDictionary[object, int],
+    weak_method: weakref.WeakMethod[int],
+    weak_set: weakref.WeakSet[int],
+    weak_value_dict: weakref.WeakValueDictionary[object, int],
+    awaitable: Awaitable[int],
+    coroutine: Coroutine[int, None, str],
+    async_iterable: AsyncIterable[int],
+    async_iterator: AsyncIterator[int],
+    async_generator: AsyncGenerator[int, None],
+    iterable: Iterable[int],
+    iterator: Iterator[int],
+    generator: Generator[int, None, None],
+    reversible: Reversible[int],
+    container: Container[int],
+    collection: Collection[int],
+    callable_obj: Callable[[int], str],
+    set_obj: Set[int],
+    mutable_set: MutableSet[int],
+    mapping: Mapping[str, int],
+    mutable_mapping: MutableMapping[str, int],
+    sequence: Sequence[int],
+    mutable_sequence: MutableSequence[int],
+    byte_string: ByteString[int],
+    mapping_view: MappingView[str, int],
+    keys_view: KeysView[str],
+    items_view: ItemsView[str, int],
+    values_view: ValuesView[int],
+) -> None:
+    ...

crates/ruff_linter/resources/test/fixtures/flynt/FLY002.py

@@ -23,3 +23,9 @@ nok9 = '\n'.join([r"raw string", '<""">', "<'''>"])  # Not OK (both triple-quote
 # Regression test for: https://github.com/astral-sh/ruff/issues/7197
 def create_file_public_url(url, filename):
     return''.join([url, filename])
+
+# Regression test for: https://github.com/astral-sh/ruff/issues/19837
+nok10 = "".join((foo, '"'))
+nok11 = ''.join((foo, "'"))
+nok12 = ''.join([foo, "'", '"'])
+nok13 = "".join([foo, "'", '"'])

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -8,7 +8,8 @@ use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::preview::{
-    is_optional_as_none_in_union_enabled, is_unnecessary_default_type_args_stubs_enabled,
+    is_future_required_preview_generics_enabled, is_optional_as_none_in_union_enabled,
+    is_unnecessary_default_type_args_stubs_enabled,
 };
 use crate::registry::Rule;
 use crate::rules::{
@@ -69,7 +70,11 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
                     && checker.semantic.in_annotation()
                     && checker.semantic.in_runtime_evaluated_annotation()
                     && !checker.semantic.in_string_type_definition()
-                    && typing::is_pep585_generic(value, &checker.semantic)
+                    && typing::is_pep585_generic(
+                        value,
+                        &checker.semantic,
+                        is_future_required_preview_generics_enabled(checker.settings()),
+                    )
                 {
                     flake8_future_annotations::rules::future_required_type_annotation(
                         checker,

crates/ruff_linter/src/preview.rs

@@ -200,6 +200,11 @@ pub(crate) const fn is_optional_as_none_in_union_enabled(settings: &LinterSettin
     settings.preview.is_enabled()
 }
 
+// https://github.com/astral-sh/ruff/pull/20659
+pub(crate) const fn is_future_required_preview_generics_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
 // https://github.com/astral-sh/ruff/pull/18683
 pub(crate) const fn is_safe_super_call_with_parameters_fix_enabled(
     settings: &LinterSettings,

crates/ruff_linter/src/rules/flake8_annotations/helpers.rs

@@ -142,23 +142,25 @@ impl AutoPythonType {
                 });
                 Some((expr, vec![no_return_edit]))
             }
-            AutoPythonType::Atom(python_type) => {
-                let expr = type_expr(python_type)?;
-                Some((expr, vec![]))
-            }
+            AutoPythonType::Atom(python_type) => type_expr(python_type, checker, at),
             AutoPythonType::Union(python_types) => {
                 if target_version >= PythonVersion::PY310 {
                     // Aggregate all the individual types (e.g., `int`, `float`).
+                    let mut all_edits = Vec::new();
                     let names = python_types
                         .iter()
                         .sorted_unstable()
-                        .map(|python_type| type_expr(*python_type))
+                        .map(|python_type| {
+                            let (expr, mut edits) = type_expr(*python_type, checker, at)?;
+                            all_edits.append(&mut edits);
+                            Some(expr)
+                        })
                         .collect::<Option<Vec<_>>>()?;
 
                     // Wrap in a bitwise union (e.g., `int | float`).
                     let expr = pep_604_union(&names);
 
-                    Some((expr, vec![]))
+                    Some((expr, all_edits))
                 } else {
                     let python_types = python_types
                         .into_iter()
@@ -167,7 +169,7 @@ impl AutoPythonType {
 
                     match python_types.as_slice() {
                         [python_type, PythonType::None] | [PythonType::None, python_type] => {
-                            let element = type_expr(*python_type)?;
+                            let (element, mut edits) = type_expr(*python_type, checker, at)?;
 
                             // Ex) `Optional[int]`
                             let (optional_edit, binding) = checker
@@ -175,12 +177,18 @@ impl AutoPythonType {
                                 .import(at)
                                 .ok()?;
                             let expr = typing_optional(element, Name::from(binding));
-                            Some((expr, vec![optional_edit]))
+                            edits.push(optional_edit);
+                            Some((expr, edits))
                         }
                         _ => {
+                            let mut all_edits = Vec::new();
                             let elements = python_types
                                 .into_iter()
-                                .map(type_expr)
+                                .map(|python_type| {
+                                    let (expr, mut edits) = type_expr(python_type, checker, at)?;
+                                    all_edits.append(&mut edits);
+                                    Some(expr)
+                                })
                                 .collect::<Option<Vec<_>>>()?;
 
                             // Ex) `Union[int, str]`
@@ -189,7 +197,8 @@ impl AutoPythonType {
                                 .import(at)
                                 .ok()?;
                             let expr = typing_union(&elements, Name::from(binding));
-                            Some((expr, vec![union_edit]))
+                            all_edits.push(union_edit);
+                            Some((expr, all_edits))
                         }
                     }
                 }
@@ -199,26 +208,44 @@ impl AutoPythonType {
 }
 
 /// Given a [`PythonType`], return an [`Expr`] that resolves to that type.
-fn type_expr(python_type: PythonType) -> Option<Expr> {
-    fn name(name: &str) -> Expr {
-        Expr::Name(ast::ExprName {
-            id: name.into(),
+///
+/// If the [`Expr`] relies on importing any external symbols, those imports will be returned as
+/// additional edits.
+pub(crate) fn type_expr(
+    python_type: PythonType,
+    checker: &Checker,
+    at: TextSize,
+) -> Option<(Expr, Vec<Edit>)> {
+    fn name(name: &str, checker: &Checker, at: TextSize) -> Option<(Expr, Vec<Edit>)> {
+        let (edit, binding) = checker
+            .importer()
+            .get_or_import_builtin_symbol(name, at, checker.semantic())
+            .ok()?;
+        let expr = Expr::Name(ast::ExprName {
+            id: binding.into(),
             range: TextRange::default(),
             node_index: ruff_python_ast::AtomicNodeIndex::NONE,
             ctx: ExprContext::Load,
-        })
+        });
+        Some((expr, edit.map_or_else(Vec::new, |edit| vec![edit])))
     }
 
     match python_type {
-        PythonType::String => Some(name("str")),
-        PythonType::Bytes => Some(name("bytes")),
-        PythonType::Number(number) => match number {
-            NumberLike::Integer => Some(name("int")),
-            NumberLike::Float => Some(name("float")),
-            NumberLike::Complex => Some(name("complex")),
-            NumberLike::Bool => Some(name("bool")),
-        },
-        PythonType::None => Some(name("None")),
+        PythonType::String => name("str", checker, at),
+        PythonType::Bytes => name("bytes", checker, at),
+        PythonType::Number(number) => {
+            let symbol = match number {
+                NumberLike::Integer => "int",
+                NumberLike::Float => "float",
+                NumberLike::Complex => "complex",
+                NumberLike::Bool => "bool",
+            };
+            name(symbol, checker, at)
+        }
+        PythonType::None => {
+            let expr = Expr::NoneLiteral(ast::ExprNoneLiteral::default());
+            Some((expr, vec![]))
+        }
         PythonType::Ellipsis => None,
         PythonType::Dict => None,
         PythonType::List => None,

crates/ruff_linter/src/rules/flake8_annotations/mod.rs

@@ -229,4 +229,20 @@ mod tests {
         assert_diagnostics!(diagnostics);
         Ok(())
     }
+
+    #[test]
+    fn shadowed_builtins() -> Result<()> {
+        let diagnostics = test_path(
+            Path::new("flake8_annotations/shadowed_builtins.py"),
+            &LinterSettings::for_rules(vec![
+                Rule::MissingReturnTypeUndocumentedPublicFunction,
+                Rule::MissingReturnTypePrivateFunction,
+                Rule::MissingReturnTypeSpecialMethod,
+                Rule::MissingReturnTypeStaticMethod,
+                Rule::MissingReturnTypeClassMethod,
+            ]),
+        )?;
+        assert_diagnostics!(diagnostics);
+        Ok(())
+    }
 }

crates/ruff_linter/src/rules/flake8_annotations/rules/definition.rs

@@ -4,13 +4,14 @@ use ruff_python_ast::identifier::Identifier;
 use ruff_python_ast::visitor::Visitor;
 use ruff_python_ast::{self as ast, Expr, Stmt};
 use ruff_python_semantic::Definition;
+use ruff_python_semantic::analyze::type_inference::{NumberLike, PythonType};
 use ruff_python_semantic::analyze::visibility;
 use ruff_python_stdlib::typing::simple_magic_return_type;
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::{Checker, DiagnosticGuard};
 use crate::registry::Rule;
-use crate::rules::flake8_annotations::helpers::auto_return_type;
+use crate::rules::flake8_annotations::helpers::{auto_return_type, type_expr};
 use crate::rules::ruff::typing::type_hint_resolves_to_any;
 use crate::{Edit, Fix, FixAvailability, Violation};
 
@@ -825,11 +826,31 @@ pub(crate) fn definition(
                     },
                     function.identifier(),
                 );
-                if let Some(return_type) = return_type {
-                    diagnostic.set_fix(Fix::unsafe_edit(Edit::insertion(
-                        format!(" -> {return_type}"),
-                        function.parameters.end(),
-                    )));
+                if let Some(return_type_str) = return_type {
+                    // Convert the simple return type to a proper expression that handles shadowed builtins
+                    let python_type = match return_type_str {
+                        "str" => PythonType::String,
+                        "bytes" => PythonType::Bytes,
+                        "int" => PythonType::Number(NumberLike::Integer),
+                        "float" => PythonType::Number(NumberLike::Float),
+                        "complex" => PythonType::Number(NumberLike::Complex),
+                        "bool" => PythonType::Number(NumberLike::Bool),
+                        "None" => PythonType::None,
+                        _ => return, // Unknown type, skip
+                    };
+
+                    if let Some((expr, edits)) =
+                        type_expr(python_type, checker, function.parameters.start())
+                    {
+                        let return_type_expr = checker.generator().expr(&expr);
+                        diagnostic.set_fix(Fix::unsafe_edits(
+                            Edit::insertion(
+                                format!(" -> {return_type_expr}"),
+                                function.parameters.end(),
+                            ),
+                            edits,
+                        ));
+                    }
                 }
                 diagnostics.push(diagnostic);
             }

crates/ruff_linter/src/rules/flake8_annotations/snapshots/ruff_linter__rules__flake8_annotations__tests__shadowed_builtins.snap

@@ -0,0 +1,124 @@
+---
+source: crates/ruff_linter/src/rules/flake8_annotations/mod.rs
+---
+ANN201 [*] Missing return type annotation for public function `foo`
+ --> shadowed_builtins.py:4:5
+  |
+2 | from typing import override
+3 |
+4 | def foo():
+  |     ^^^
+5 |     return "!"
+  |
+help: Add return type annotation: `builtins.str`
+1 | from collections import UserString as str
+2 | from typing import override
+3 + import builtins
+4 | 
+  - def foo():
+5 + def foo() -> builtins.str:
+6 |     return "!"
+7 | 
+8 | def _foo():
+note: This is an unsafe fix and may change runtime behavior
+
+ANN202 [*] Missing return type annotation for private function `_foo`
+ --> shadowed_builtins.py:7:5
+  |
+5 |     return "!"
+6 |
+7 | def _foo():
+  |     ^^^^
+8 |     return "!"
+  |
+help: Add return type annotation: `builtins.str`
+1  | from collections import UserString as str
+2  | from typing import override
+3  + import builtins
+4  | 
+5  | def foo():
+6  |     return "!"
+7  | 
+   - def _foo():
+8  + def _foo() -> builtins.str:
+9  |     return "!"
+10 | 
+11 | class C:
+note: This is an unsafe fix and may change runtime behavior
+
+ANN204 [*] Missing return type annotation for special method `__str__`
+  --> shadowed_builtins.py:12:9
+   |
+10 | class C:
+11 |     @override
+12 |     def __str__(self):
+   |         ^^^^^^^
+13 |         return "!"
+   |
+help: Add return type annotation: `str`
+1  | from collections import UserString as str
+2  | from typing import override
+3  + import builtins
+4  | 
+5  | def foo():
+6  |     return "!"
+--------------------------------------------------------------------------------
+10 | 
+11 | class C:
+12 |     @override
+   -     def __str__(self):
+13 +     def __str__(self) -> builtins.str:
+14 |         return "!"
+15 |     
+16 |     @staticmethod
+note: This is an unsafe fix and may change runtime behavior
+
+ANN205 [*] Missing return type annotation for staticmethod `foo`
+  --> shadowed_builtins.py:16:9
+   |
+15 |     @staticmethod
+16 |     def foo():
+   |         ^^^
+17 |         return "!"
+   |
+help: Add return type annotation: `builtins.str`
+1  | from collections import UserString as str
+2  | from typing import override
+3  + import builtins
+4  | 
+5  | def foo():
+6  |     return "!"
+--------------------------------------------------------------------------------
+14 |         return "!"
+15 |     
+16 |     @staticmethod
+   -     def foo():
+17 +     def foo() -> builtins.str:
+18 |         return "!"
+19 |     
+20 |     @classmethod
+note: This is an unsafe fix and may change runtime behavior
+
+ANN206 [*] Missing return type annotation for classmethod `bar`
+  --> shadowed_builtins.py:20:9
+   |
+19 |     @classmethod
+20 |     def bar(cls):
+   |         ^^^
+21 |         return "!"
+   |
+help: Add return type annotation: `builtins.str`
+1  | from collections import UserString as str
+2  | from typing import override
+3  + import builtins
+4  | 
+5  | def foo():
+6  |     return "!"
+--------------------------------------------------------------------------------
+18 |         return "!"
+19 |     
+20 |     @classmethod
+   -     def bar(cls):
+21 +     def bar(cls) -> builtins.str:
+22 |         return "!"
+note: This is an unsafe fix and may change runtime behavior

crates/ruff_linter/src/rules/flake8_future_annotations/mod.rs

@@ -9,6 +9,7 @@ mod tests {
     use test_case::test_case;
 
     use crate::registry::Rule;
+    use crate::settings::types::PreviewMode;
     use crate::test::test_path;
     use crate::{assert_diagnostics, settings};
     use ruff_python_ast::PythonVersion;
@@ -39,6 +40,7 @@ mod tests {
     }
 
     #[test_case(Path::new("no_future_import_uses_lowercase.py"))]
+    #[test_case(Path::new("no_future_import_uses_preview_generics.py"))]
     #[test_case(Path::new("no_future_import_uses_union.py"))]
     #[test_case(Path::new("no_future_import_uses_union_inner.py"))]
     #[test_case(Path::new("ok_no_types.py"))]
@@ -56,4 +58,19 @@ mod tests {
         assert_diagnostics!(snapshot, diagnostics);
         Ok(())
     }
+
+    #[test_case(Path::new("no_future_import_uses_preview_generics.py"))]
+    fn fa102_preview(path: &Path) -> Result<()> {
+        let snapshot = format!("fa102_preview_{}", path.to_string_lossy());
+        let diagnostics = test_path(
+            Path::new("flake8_future_annotations").join(path).as_path(),
+            &settings::LinterSettings {
+                unresolved_target_version: PythonVersion::PY37.into(),
+                preview: PreviewMode::Enabled,
+                ..settings::LinterSettings::for_rule(Rule::FutureRequiredTypeAnnotation)
+            },
+        )?;
+        assert_diagnostics!(snapshot, diagnostics);
+        Ok(())
+    }
 }

crates/ruff_linter/src/rules/flake8_future_annotations/snapshots/ruff_linter__rules__flake8_future_annotations__tests__fa102_no_future_import_uses_preview_generics.py.snap

@@ -0,0 +1,36 @@
+---
+source: crates/ruff_linter/src/rules/flake8_future_annotations/mod.rs
+---
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:42:19
+   |
+40 |     future: asyncio.Future[int],
+41 |     task: asyncio.Task[str],
+42 |     deque_object: collections.deque[int],
+   |                   ^^^^^^^^^^^^^^^^^^^^^^
+43 |     defaultdict_object: collections.defaultdict[str, int],
+44 |     ordered_dict: collections.OrderedDict[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:43:25
+   |
+41 |     task: asyncio.Task[str],
+42 |     deque_object: collections.deque[int],
+43 |     defaultdict_object: collections.defaultdict[str, int],
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+44 |     ordered_dict: collections.OrderedDict[str, int],
+45 |     counter_obj: collections.Counter[str],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior

crates/ruff_linter/src/rules/flake8_future_annotations/snapshots/ruff_linter__rules__flake8_future_annotations__tests__fa102_preview_no_future_import_uses_preview_generics.py.snap

@@ -0,0 +1,851 @@
+---
+source: crates/ruff_linter/src/rules/flake8_future_annotations/mod.rs
+---
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:40:13
+   |
+39 | def takes_preview_generics(
+40 |     future: asyncio.Future[int],
+   |             ^^^^^^^^^^^^^^^^^^^
+41 |     task: asyncio.Task[str],
+42 |     deque_object: collections.deque[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:41:11
+   |
+39 | def takes_preview_generics(
+40 |     future: asyncio.Future[int],
+41 |     task: asyncio.Task[str],
+   |           ^^^^^^^^^^^^^^^^^
+42 |     deque_object: collections.deque[int],
+43 |     defaultdict_object: collections.defaultdict[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:42:19
+   |
+40 |     future: asyncio.Future[int],
+41 |     task: asyncio.Task[str],
+42 |     deque_object: collections.deque[int],
+   |                   ^^^^^^^^^^^^^^^^^^^^^^
+43 |     defaultdict_object: collections.defaultdict[str, int],
+44 |     ordered_dict: collections.OrderedDict[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:43:25
+   |
+41 |     task: asyncio.Task[str],
+42 |     deque_object: collections.deque[int],
+43 |     defaultdict_object: collections.defaultdict[str, int],
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+44 |     ordered_dict: collections.OrderedDict[str, int],
+45 |     counter_obj: collections.Counter[str],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:44:19
+   |
+42 |     deque_object: collections.deque[int],
+43 |     defaultdict_object: collections.defaultdict[str, int],
+44 |     ordered_dict: collections.OrderedDict[str, int],
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+45 |     counter_obj: collections.Counter[str],
+46 |     chain_map: collections.ChainMap[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:45:18
+   |
+43 |     defaultdict_object: collections.defaultdict[str, int],
+44 |     ordered_dict: collections.OrderedDict[str, int],
+45 |     counter_obj: collections.Counter[str],
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^
+46 |     chain_map: collections.ChainMap[str, int],
+47 |     context_manager: contextlib.AbstractContextManager[str],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:46:16
+   |
+44 |     ordered_dict: collections.OrderedDict[str, int],
+45 |     counter_obj: collections.Counter[str],
+46 |     chain_map: collections.ChainMap[str, int],
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+47 |     context_manager: contextlib.AbstractContextManager[str],
+48 |     async_context_manager: contextlib.AbstractAsyncContextManager[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:47:22
+   |
+45 |     counter_obj: collections.Counter[str],
+46 |     chain_map: collections.ChainMap[str, int],
+47 |     context_manager: contextlib.AbstractContextManager[str],
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+48 |     async_context_manager: contextlib.AbstractAsyncContextManager[int],
+49 |     dataclass_field: dataclasses.Field[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:48:28
+   |
+46 |     chain_map: collections.ChainMap[str, int],
+47 |     context_manager: contextlib.AbstractContextManager[str],
+48 |     async_context_manager: contextlib.AbstractAsyncContextManager[int],
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+49 |     dataclass_field: dataclasses.Field[int],
+50 |     cached_prop: functools.cached_property[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:49:22
+   |
+47 |     context_manager: contextlib.AbstractContextManager[str],
+48 |     async_context_manager: contextlib.AbstractAsyncContextManager[int],
+49 |     dataclass_field: dataclasses.Field[int],
+   |                      ^^^^^^^^^^^^^^^^^^^^^^
+50 |     cached_prop: functools.cached_property[int],
+51 |     partial_method: functools.partialmethod[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:50:18
+   |
+48 |     async_context_manager: contextlib.AbstractAsyncContextManager[int],
+49 |     dataclass_field: dataclasses.Field[int],
+50 |     cached_prop: functools.cached_property[int],
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+51 |     partial_method: functools.partialmethod[int],
+52 |     path_like: os.PathLike[str],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:51:21
+   |
+49 |     dataclass_field: dataclasses.Field[int],
+50 |     cached_prop: functools.cached_property[int],
+51 |     partial_method: functools.partialmethod[int],
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+52 |     path_like: os.PathLike[str],
+53 |     lifo_queue: queue.LifoQueue[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:52:16
+   |
+50 |     cached_prop: functools.cached_property[int],
+51 |     partial_method: functools.partialmethod[int],
+52 |     path_like: os.PathLike[str],
+   |                ^^^^^^^^^^^^^^^^
+53 |     lifo_queue: queue.LifoQueue[int],
+54 |     regular_queue: queue.Queue[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:53:17
+   |
+51 |     partial_method: functools.partialmethod[int],
+52 |     path_like: os.PathLike[str],
+53 |     lifo_queue: queue.LifoQueue[int],
+   |                 ^^^^^^^^^^^^^^^^^^^^
+54 |     regular_queue: queue.Queue[int],
+55 |     priority_queue: queue.PriorityQueue[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:54:20
+   |
+52 |     path_like: os.PathLike[str],
+53 |     lifo_queue: queue.LifoQueue[int],
+54 |     regular_queue: queue.Queue[int],
+   |                    ^^^^^^^^^^^^^^^^
+55 |     priority_queue: queue.PriorityQueue[int],
+56 |     simple_queue: queue.SimpleQueue[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:55:21
+   |
+53 |     lifo_queue: queue.LifoQueue[int],
+54 |     regular_queue: queue.Queue[int],
+55 |     priority_queue: queue.PriorityQueue[int],
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^
+56 |     simple_queue: queue.SimpleQueue[int],
+57 |     regex_pattern: re.Pattern[str],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:56:19
+   |
+54 |     regular_queue: queue.Queue[int],
+55 |     priority_queue: queue.PriorityQueue[int],
+56 |     simple_queue: queue.SimpleQueue[int],
+   |                   ^^^^^^^^^^^^^^^^^^^^^^
+57 |     regex_pattern: re.Pattern[str],
+58 |     regex_match: re.Match[str],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:57:20
+   |
+55 |     priority_queue: queue.PriorityQueue[int],
+56 |     simple_queue: queue.SimpleQueue[int],
+57 |     regex_pattern: re.Pattern[str],
+   |                    ^^^^^^^^^^^^^^^
+58 |     regex_match: re.Match[str],
+59 |     bsd_db_shelf: shelve.BsdDbShelf[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:58:18
+   |
+56 |     simple_queue: queue.SimpleQueue[int],
+57 |     regex_pattern: re.Pattern[str],
+58 |     regex_match: re.Match[str],
+   |                  ^^^^^^^^^^^^^
+59 |     bsd_db_shelf: shelve.BsdDbShelf[str, int],
+60 |     db_filename_shelf: shelve.DbfilenameShelf[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:59:19
+   |
+57 |     regex_pattern: re.Pattern[str],
+58 |     regex_match: re.Match[str],
+59 |     bsd_db_shelf: shelve.BsdDbShelf[str, int],
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+60 |     db_filename_shelf: shelve.DbfilenameShelf[str, int],
+61 |     shelf_obj: shelve.Shelf[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:60:24
+   |
+58 |     regex_match: re.Match[str],
+59 |     bsd_db_shelf: shelve.BsdDbShelf[str, int],
+60 |     db_filename_shelf: shelve.DbfilenameShelf[str, int],
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+61 |     shelf_obj: shelve.Shelf[str, int],
+62 |     mapping_proxy: types.MappingProxyType[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:61:16
+   |
+59 |     bsd_db_shelf: shelve.BsdDbShelf[str, int],
+60 |     db_filename_shelf: shelve.DbfilenameShelf[str, int],
+61 |     shelf_obj: shelve.Shelf[str, int],
+   |                ^^^^^^^^^^^^^^^^^^^^^^
+62 |     mapping_proxy: types.MappingProxyType[str, int],
+63 |     weak_key_dict: weakref.WeakKeyDictionary[object, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:62:20
+   |
+60 |     db_filename_shelf: shelve.DbfilenameShelf[str, int],
+61 |     shelf_obj: shelve.Shelf[str, int],
+62 |     mapping_proxy: types.MappingProxyType[str, int],
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+63 |     weak_key_dict: weakref.WeakKeyDictionary[object, int],
+64 |     weak_method: weakref.WeakMethod[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:63:20
+   |
+61 |     shelf_obj: shelve.Shelf[str, int],
+62 |     mapping_proxy: types.MappingProxyType[str, int],
+63 |     weak_key_dict: weakref.WeakKeyDictionary[object, int],
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+64 |     weak_method: weakref.WeakMethod[int],
+65 |     weak_set: weakref.WeakSet[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:64:18
+   |
+62 |     mapping_proxy: types.MappingProxyType[str, int],
+63 |     weak_key_dict: weakref.WeakKeyDictionary[object, int],
+64 |     weak_method: weakref.WeakMethod[int],
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^
+65 |     weak_set: weakref.WeakSet[int],
+66 |     weak_value_dict: weakref.WeakValueDictionary[object, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:65:15
+   |
+63 |     weak_key_dict: weakref.WeakKeyDictionary[object, int],
+64 |     weak_method: weakref.WeakMethod[int],
+65 |     weak_set: weakref.WeakSet[int],
+   |               ^^^^^^^^^^^^^^^^^^^^
+66 |     weak_value_dict: weakref.WeakValueDictionary[object, int],
+67 |     awaitable: Awaitable[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:66:22
+   |
+64 |     weak_method: weakref.WeakMethod[int],
+65 |     weak_set: weakref.WeakSet[int],
+66 |     weak_value_dict: weakref.WeakValueDictionary[object, int],
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+67 |     awaitable: Awaitable[int],
+68 |     coroutine: Coroutine[int, None, str],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:67:16
+   |
+65 |     weak_set: weakref.WeakSet[int],
+66 |     weak_value_dict: weakref.WeakValueDictionary[object, int],
+67 |     awaitable: Awaitable[int],
+   |                ^^^^^^^^^^^^^^
+68 |     coroutine: Coroutine[int, None, str],
+69 |     async_iterable: AsyncIterable[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:68:16
+   |
+66 |     weak_value_dict: weakref.WeakValueDictionary[object, int],
+67 |     awaitable: Awaitable[int],
+68 |     coroutine: Coroutine[int, None, str],
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^
+69 |     async_iterable: AsyncIterable[int],
+70 |     async_iterator: AsyncIterator[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:69:21
+   |
+67 |     awaitable: Awaitable[int],
+68 |     coroutine: Coroutine[int, None, str],
+69 |     async_iterable: AsyncIterable[int],
+   |                     ^^^^^^^^^^^^^^^^^^
+70 |     async_iterator: AsyncIterator[int],
+71 |     async_generator: AsyncGenerator[int, None],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:70:21
+   |
+68 |     coroutine: Coroutine[int, None, str],
+69 |     async_iterable: AsyncIterable[int],
+70 |     async_iterator: AsyncIterator[int],
+   |                     ^^^^^^^^^^^^^^^^^^
+71 |     async_generator: AsyncGenerator[int, None],
+72 |     iterable: Iterable[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:71:22
+   |
+69 |     async_iterable: AsyncIterable[int],
+70 |     async_iterator: AsyncIterator[int],
+71 |     async_generator: AsyncGenerator[int, None],
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
+72 |     iterable: Iterable[int],
+73 |     iterator: Iterator[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:72:15
+   |
+70 |     async_iterator: AsyncIterator[int],
+71 |     async_generator: AsyncGenerator[int, None],
+72 |     iterable: Iterable[int],
+   |               ^^^^^^^^^^^^^
+73 |     iterator: Iterator[int],
+74 |     generator: Generator[int, None, None],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:73:15
+   |
+71 |     async_generator: AsyncGenerator[int, None],
+72 |     iterable: Iterable[int],
+73 |     iterator: Iterator[int],
+   |               ^^^^^^^^^^^^^
+74 |     generator: Generator[int, None, None],
+75 |     reversible: Reversible[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:74:16
+   |
+72 |     iterable: Iterable[int],
+73 |     iterator: Iterator[int],
+74 |     generator: Generator[int, None, None],
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^
+75 |     reversible: Reversible[int],
+76 |     container: Container[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:75:17
+   |
+73 |     iterator: Iterator[int],
+74 |     generator: Generator[int, None, None],
+75 |     reversible: Reversible[int],
+   |                 ^^^^^^^^^^^^^^^
+76 |     container: Container[int],
+77 |     collection: Collection[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:76:16
+   |
+74 |     generator: Generator[int, None, None],
+75 |     reversible: Reversible[int],
+76 |     container: Container[int],
+   |                ^^^^^^^^^^^^^^
+77 |     collection: Collection[int],
+78 |     callable_obj: Callable[[int], str],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:77:17
+   |
+75 |     reversible: Reversible[int],
+76 |     container: Container[int],
+77 |     collection: Collection[int],
+   |                 ^^^^^^^^^^^^^^^
+78 |     callable_obj: Callable[[int], str],
+79 |     set_obj: Set[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:78:19
+   |
+76 |     container: Container[int],
+77 |     collection: Collection[int],
+78 |     callable_obj: Callable[[int], str],
+   |                   ^^^^^^^^^^^^^^^^^^^^
+79 |     set_obj: Set[int],
+80 |     mutable_set: MutableSet[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:79:14
+   |
+77 |     collection: Collection[int],
+78 |     callable_obj: Callable[[int], str],
+79 |     set_obj: Set[int],
+   |              ^^^^^^^^
+80 |     mutable_set: MutableSet[int],
+81 |     mapping: Mapping[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:80:18
+   |
+78 |     callable_obj: Callable[[int], str],
+79 |     set_obj: Set[int],
+80 |     mutable_set: MutableSet[int],
+   |                  ^^^^^^^^^^^^^^^
+81 |     mapping: Mapping[str, int],
+82 |     mutable_mapping: MutableMapping[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:81:14
+   |
+79 |     set_obj: Set[int],
+80 |     mutable_set: MutableSet[int],
+81 |     mapping: Mapping[str, int],
+   |              ^^^^^^^^^^^^^^^^^
+82 |     mutable_mapping: MutableMapping[str, int],
+83 |     sequence: Sequence[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:82:22
+   |
+80 |     mutable_set: MutableSet[int],
+81 |     mapping: Mapping[str, int],
+82 |     mutable_mapping: MutableMapping[str, int],
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^
+83 |     sequence: Sequence[int],
+84 |     mutable_sequence: MutableSequence[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:83:15
+   |
+81 |     mapping: Mapping[str, int],
+82 |     mutable_mapping: MutableMapping[str, int],
+83 |     sequence: Sequence[int],
+   |               ^^^^^^^^^^^^^
+84 |     mutable_sequence: MutableSequence[int],
+85 |     byte_string: ByteString[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:84:23
+   |
+82 |     mutable_mapping: MutableMapping[str, int],
+83 |     sequence: Sequence[int],
+84 |     mutable_sequence: MutableSequence[int],
+   |                       ^^^^^^^^^^^^^^^^^^^^
+85 |     byte_string: ByteString[int],
+86 |     mapping_view: MappingView[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:85:18
+   |
+83 |     sequence: Sequence[int],
+84 |     mutable_sequence: MutableSequence[int],
+85 |     byte_string: ByteString[int],
+   |                  ^^^^^^^^^^^^^^^
+86 |     mapping_view: MappingView[str, int],
+87 |     keys_view: KeysView[str],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:86:19
+   |
+84 |     mutable_sequence: MutableSequence[int],
+85 |     byte_string: ByteString[int],
+86 |     mapping_view: MappingView[str, int],
+   |                   ^^^^^^^^^^^^^^^^^^^^^
+87 |     keys_view: KeysView[str],
+88 |     items_view: ItemsView[str, int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:87:16
+   |
+85 |     byte_string: ByteString[int],
+86 |     mapping_view: MappingView[str, int],
+87 |     keys_view: KeysView[str],
+   |                ^^^^^^^^^^^^^
+88 |     items_view: ItemsView[str, int],
+89 |     values_view: ValuesView[int],
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:88:17
+   |
+86 |     mapping_view: MappingView[str, int],
+87 |     keys_view: KeysView[str],
+88 |     items_view: ItemsView[str, int],
+   |                 ^^^^^^^^^^^^^^^^^^^
+89 |     values_view: ValuesView[int],
+90 | ) -> None:
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior
+
+FA102 [*] Missing `from __future__ import annotations`, but uses PEP 585 collection
+  --> no_future_import_uses_preview_generics.py:89:18
+   |
+87 |     keys_view: KeysView[str],
+88 |     items_view: ItemsView[str, int],
+89 |     values_view: ValuesView[int],
+   |                  ^^^^^^^^^^^^^^^
+90 | ) -> None:
+91 |     ...
+   |
+help: Add `from __future__ import annotations`
+1 + from __future__ import annotations
+2 | import asyncio
+3 | import collections
+4 | import contextlib
+note: This is an unsafe fix and may change runtime behavior

crates/ruff_linter/src/rules/flynt/rules/static_join_to_fstring.rs

@@ -2,7 +2,7 @@ use ast::FStringFlags;
 use itertools::Itertools;
 
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-use ruff_python_ast::{self as ast, Arguments, Expr, StringFlags};
+use ruff_python_ast::{self as ast, Arguments, Expr, StringFlags, str::Quote};
 use ruff_text_size::{Ranged, TextRange};
 
 use crate::checkers::ast::Checker;
@@ -115,6 +115,8 @@ fn build_fstring(joiner: &str, joinees: &[Expr], flags: FStringFlags) -> Option<
     }
 
     let mut f_string_elements = Vec::with_capacity(joinees.len() * 2);
+    let mut has_single_quote = joiner.contains('\'');
+    let mut has_double_quote = joiner.contains('"');
     let mut first = true;
 
     for expr in joinees {
@@ -126,14 +128,31 @@ fn build_fstring(joiner: &str, joinees: &[Expr], flags: FStringFlags) -> Option<
         if !std::mem::take(&mut first) {
             f_string_elements.push(helpers::to_interpolated_string_literal_element(joiner));
         }
-        f_string_elements.push(helpers::to_interpolated_string_element(expr)?);
+        let element = helpers::to_interpolated_string_element(expr)?;
+        if let ast::InterpolatedStringElement::Literal(ast::InterpolatedStringLiteralElement {
+            value,
+            ..
+        }) = &element
+        {
+            has_single_quote |= value.contains('\'');
+            has_double_quote |= value.contains('"');
+        }
+        f_string_elements.push(element);
     }
 
+    let quote = flags.quote_style();
+    let adjusted_quote = match quote {
+        Quote::Single if has_single_quote && !has_double_quote => quote.opposite(),
+        Quote::Double if has_double_quote && !has_single_quote => quote.opposite(),
+        _ if has_double_quote && has_single_quote => return None,
+        _ => quote,
+    };
+
     let node = ast::FString {
         elements: f_string_elements.into(),
         range: TextRange::default(),
         node_index: ruff_python_ast::AtomicNodeIndex::NONE,
-        flags,
+        flags: flags.with_quote_style(adjusted_quote),
     };
     Some(node.into())
 }

crates/ruff_linter/src/rules/flynt/snapshots/ruff_linter__rules__flynt__tests__FLY002_FLY002.py.snap

@@ -153,6 +153,8 @@ FLY002 [*] Consider `f"{url}{filename}"` instead of string join
 24 | def create_file_public_url(url, filename):
 25 |     return''.join([url, filename])
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
+26 |
+27 | # Regression test for: https://github.com/astral-sh/ruff/issues/19837
    |
 help: Replace with `f"{url}{filename}"`
 22 | 
@@ -160,4 +162,47 @@ help: Replace with `f"{url}{filename}"`
 24 | def create_file_public_url(url, filename):
    -     return''.join([url, filename])
 25 +     return f"{url}{filename}"
+26 | 
+27 | # Regression test for: https://github.com/astral-sh/ruff/issues/19837
+28 | nok10 = "".join((foo, '"'))
+note: This is an unsafe fix and may change runtime behavior
+
+FLY002 [*] Consider `f'{foo}"'` instead of string join
+  --> FLY002.py:28:9
+   |
+27 | # Regression test for: https://github.com/astral-sh/ruff/issues/19837
+28 | nok10 = "".join((foo, '"'))
+   |         ^^^^^^^^^^^^^^^^^^^
+29 | nok11 = ''.join((foo, "'"))
+30 | nok12 = ''.join([foo, "'", '"'])
+   |
+help: Replace with `f'{foo}"'`
+25 |     return''.join([url, filename])
+26 | 
+27 | # Regression test for: https://github.com/astral-sh/ruff/issues/19837
+   - nok10 = "".join((foo, '"'))
+28 + nok10 = f'{foo}"'
+29 | nok11 = ''.join((foo, "'"))
+30 | nok12 = ''.join([foo, "'", '"'])
+31 | nok13 = "".join([foo, "'", '"'])
+note: This is an unsafe fix and may change runtime behavior
+
+FLY002 [*] Consider `f"{foo}'"` instead of string join
+  --> FLY002.py:29:9
+   |
+27 | # Regression test for: https://github.com/astral-sh/ruff/issues/19837
+28 | nok10 = "".join((foo, '"'))
+29 | nok11 = ''.join((foo, "'"))
+   |         ^^^^^^^^^^^^^^^^^^^
+30 | nok12 = ''.join([foo, "'", '"'])
+31 | nok13 = "".join([foo, "'", '"'])
+   |
+help: Replace with `f"{foo}'"`
+26 | 
+27 | # Regression test for: https://github.com/astral-sh/ruff/issues/19837
+28 | nok10 = "".join((foo, '"'))
+   - nok11 = ''.join((foo, "'"))
+29 + nok11 = f"{foo}'"
+30 | nok12 = ''.join([foo, "'", '"'])
+31 | nok13 = "".join([foo, "'", '"'])
 note: This is an unsafe fix and may change runtime behavior

crates/ruff_python_semantic/src/analyze/typing.rs

@@ -8,11 +8,10 @@ use ruff_python_ast::{
     StmtAssign,
 };
 use ruff_python_stdlib::typing::{
-    as_pep_585_generic, has_pep_585_generic, is_immutable_generic_type,
-    is_immutable_non_generic_type, is_immutable_return_type, is_literal_member,
-    is_mutable_return_type, is_pep_593_generic_member, is_pep_593_generic_type,
-    is_standard_library_generic, is_standard_library_generic_member, is_standard_library_literal,
-    is_typed_dict, is_typed_dict_member,
+    as_pep_585_generic, is_immutable_generic_type, is_immutable_non_generic_type,
+    is_immutable_return_type, is_literal_member, is_mutable_return_type, is_pep_593_generic_member,
+    is_pep_593_generic_type, is_standard_library_generic, is_standard_library_generic_member,
+    is_standard_library_literal, is_typed_dict, is_typed_dict_member,
 };
 use ruff_text_size::Ranged;
 use smallvec::{SmallVec, smallvec};
@@ -148,14 +147,46 @@ pub fn to_pep585_generic(expr: &Expr, semantic: &SemanticModel) -> Option<Module
 }
 
 /// Return whether a given expression uses a PEP 585 standard library generic.
-pub fn is_pep585_generic(expr: &Expr, semantic: &SemanticModel) -> bool {
+pub fn is_pep585_generic(
+    expr: &Expr,
+    semantic: &SemanticModel,
+    include_preview_generics: bool,
+) -> bool {
     semantic
         .resolve_qualified_name(expr)
-        .is_some_and(|qualified_name| {
-            let [module, name] = qualified_name.segments() else {
-                return false;
-            };
-            has_pep_585_generic(module, name)
+        .is_some_and(|qualified_name| match qualified_name.segments() {
+            ["", "dict" | "frozenset" | "list" | "set" | "tuple" | "type"]
+            | ["collections", "deque" | "defaultdict"] => true,
+            ["asyncio", "Future" | "Task"]
+            | ["collections", "ChainMap" | "Counter" | "OrderedDict"]
+            | [
+                "contextlib",
+                "AbstractAsyncContextManager" | "AbstractContextManager",
+            ]
+            | ["dataclasses", "Field"]
+            | ["functools", "cached_property" | "partialmethod"]
+            | ["os", "PathLike"]
+            | [
+                "queue",
+                "LifoQueue" | "PriorityQueue" | "Queue" | "SimpleQueue",
+            ]
+            | ["re", "Match" | "Pattern"]
+            | ["shelve", "BsdDbShelf" | "DbfilenameShelf" | "Shelf"]
+            | ["types", "MappingProxyType"]
+            | [
+                "weakref",
+                "WeakKeyDictionary" | "WeakMethod" | "WeakSet" | "WeakValueDictionary",
+            ]
+            | [
+                "collections",
+                "abc",
+                "AsyncGenerator" | "AsyncIterable" | "AsyncIterator" | "Awaitable" | "ByteString"
+                | "Callable" | "Collection" | "Container" | "Coroutine" | "Generator" | "ItemsView"
+                | "Iterable" | "Iterator" | "KeysView" | "Mapping" | "MappingView"
+                | "MutableMapping" | "MutableSequence" | "MutableSet" | "Reversible" | "Sequence"
+                | "Set" | "ValuesView",
+            ] => include_preview_generics,
+            _ => false,
         })
 }
 

crates/ruff_python_stdlib/src/typing.rs

@@ -354,20 +354,6 @@ pub fn as_pep_585_generic(module: &str, member: &str) -> Option<ModuleMember> {
     }
 }
 
-/// Given a typing member, returns `true` if a generic equivalent exists in the Python standard
-/// library (e.g., `list` for `typing.List`), as introduced by [PEP 585].
-///
-/// [PEP 585]: https://peps.python.org/pep-0585/
-pub fn has_pep_585_generic(module: &str, member: &str) -> bool {
-    // Constructed by taking every pattern from `as_pep_585_generic`, removing all but
-    // the last element in each pattern, and de-duplicating the values.
-    matches!(
-        (module, member),
-        ("", "dict" | "frozenset" | "list" | "set" | "tuple" | "type")
-            | ("collections", "deque" | "defaultdict")
-    )
-}
-
 /// Returns the expected return type for a magic method.
 ///
 /// See: <https://github.com/JelleZijlstra/autotyping/blob/0adba5ba0eee33c1de4ad9d0c79acfd737321dd9/autotyping/autotyping.py#L69-L91>

crates/ruff_wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_wasm"
-version = "0.13.2"
+version = "0.13.3"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

crates/ty_python_semantic/resources/mdtest/call/overloads.md

@@ -139,8 +139,7 @@ reveal_type(f(A()))  # revealed: A
 reveal_type(f(*(A(),)))  # revealed: A
 
 reveal_type(f(B()))  # revealed: A
-# TODO: revealed: A
-reveal_type(f(*(B(),)))  # revealed: Unknown
+reveal_type(f(*(B(),)))  # revealed: A
 
 # But, in this case, the arity check filters out the first overload, so we only have one match:
 reveal_type(f(B(), 1))  # revealed: B
@@ -551,16 +550,13 @@ from overloaded import MyEnumSubclass, ActualEnum, f
 
 def _(actual_enum: ActualEnum, my_enum_instance: MyEnumSubclass):
     reveal_type(f(actual_enum))  # revealed: Both
-    # TODO: revealed: Both
-    reveal_type(f(*(actual_enum,)))  # revealed: Unknown
+    reveal_type(f(*(actual_enum,)))  # revealed: Both
 
     reveal_type(f(ActualEnum.A))  # revealed: OnlyA
-    # TODO: revealed: OnlyA
-    reveal_type(f(*(ActualEnum.A,)))  # revealed: Unknown
+    reveal_type(f(*(ActualEnum.A,)))  # revealed: OnlyA
 
     reveal_type(f(ActualEnum.B))  # revealed: OnlyB
-    # TODO: revealed: OnlyB
-    reveal_type(f(*(ActualEnum.B,)))  # revealed: Unknown
+    reveal_type(f(*(ActualEnum.B,)))  # revealed: OnlyB
 
     reveal_type(f(my_enum_instance))  # revealed: MyEnumSubclass
     reveal_type(f(*(my_enum_instance,)))  # revealed: MyEnumSubclass
@@ -1097,12 +1093,10 @@ reveal_type(f(*(1,)))  # revealed: str
 
 def _(list_int: list[int], list_any: list[Any]):
     reveal_type(f(list_int))  # revealed: int
-    # TODO: revealed: int
-    reveal_type(f(*(list_int,)))  # revealed: Unknown
+    reveal_type(f(*(list_int,)))  # revealed: int
 
     reveal_type(f(list_any))  # revealed: int
-    # TODO: revealed: int
-    reveal_type(f(*(list_any,)))  # revealed: Unknown
+    reveal_type(f(*(list_any,)))  # revealed: int
 ```
 
 ### Single list argument (ambiguous)
@@ -1136,8 +1130,7 @@ def _(list_int: list[int], list_any: list[Any]):
     # All materializations of `list[int]` are assignable to `list[int]`, so it matches the first
     # overload.
     reveal_type(f(list_int))  # revealed: int
-    # TODO: revealed: int
-    reveal_type(f(*(list_int,)))  # revealed: Unknown
+    reveal_type(f(*(list_int,)))  # revealed: int
 
     # All materializations of `list[Any]` are assignable to `list[int]` and `list[Any]`, but the
     # return type of first and second overloads are not equivalent, so the overload matching
@@ -1170,25 +1163,21 @@ reveal_type(f("a"))  # revealed: str
 reveal_type(f(*("a",)))  # revealed: str
 
 reveal_type(f((1, "b")))  # revealed: int
-# TODO: revealed: int
-reveal_type(f(*((1, "b"),)))  # revealed: Unknown
+reveal_type(f(*((1, "b"),)))  # revealed: int
 
 reveal_type(f((1, 2)))  # revealed: int
-# TODO: revealed: int
-reveal_type(f(*((1, 2),)))  # revealed: Unknown
+reveal_type(f(*((1, 2),)))  # revealed: int
 
 def _(int_str: tuple[int, str], int_any: tuple[int, Any], any_any: tuple[Any, Any]):
     # All materializations are assignable to first overload, so second and third overloads are
     # eliminated
     reveal_type(f(int_str))  # revealed: int
-    # TODO: revealed: int
-    reveal_type(f(*(int_str,)))  # revealed: Unknown
+    reveal_type(f(*(int_str,)))  # revealed: int
 
     # All materializations are assignable to second overload, so the third overload is eliminated;
     # the return type of first and second overload is equivalent
     reveal_type(f(int_any))  # revealed: int
-    # TODO: revealed: int
-    reveal_type(f(*(int_any,)))  # revealed: Unknown
+    reveal_type(f(*(int_any,)))  # revealed: int
 
     # All materializations of `tuple[Any, Any]` are assignable to the parameters of all the
     # overloads, but the return types aren't equivalent, so the overload matching is ambiguous
@@ -1266,26 +1255,22 @@ def _(list_int: list[int], list_any: list[Any], int_str: tuple[int, str], int_an
     # All materializations of both argument types are assignable to the first overload, so the
     # second and third overloads are filtered out
     reveal_type(f(list_int, int_str))  # revealed: A
-    # TODO: revealed: A
-    reveal_type(f(*(list_int, int_str)))  # revealed: Unknown
+    reveal_type(f(*(list_int, int_str)))  # revealed: A
 
     # All materialization of first argument is assignable to first overload and for the second
     # argument, they're assignable to the second overload, so the third overload is filtered out
     reveal_type(f(list_int, int_any))  # revealed: A
-    # TODO: revealed: A
-    reveal_type(f(*(list_int, int_any)))  # revealed: Unknown
+    reveal_type(f(*(list_int, int_any)))  # revealed: A
 
     # All materialization of first argument is assignable to second overload and for the second
     # argument, they're assignable to the first overload, so the third overload is filtered out
     reveal_type(f(list_any, int_str))  # revealed: A
-    # TODO: revealed: A
-    reveal_type(f(*(list_any, int_str)))  # revealed: Unknown
+    reveal_type(f(*(list_any, int_str)))  # revealed: A
 
     # All materializations of both arguments are assignable to the second overload, so the third
     # overload is filtered out
     reveal_type(f(list_any, int_any))  # revealed: A
-    # TODO: revealed: A
-    reveal_type(f(*(list_any, int_any)))  # revealed: Unknown
+    reveal_type(f(*(list_any, int_any)))  # revealed: A
 
     # All materializations of first argument is assignable to the second overload and for the second
     # argument, they're assignable to the third overload, so no overloads are filtered out; the
@@ -1316,8 +1301,7 @@ from overloaded import f
 
 def _(literal: LiteralString, string: str, any: Any):
     reveal_type(f(literal))  # revealed: LiteralString
-    # TODO: revealed: LiteralString
-    reveal_type(f(*(literal,)))  # revealed: Unknown
+    reveal_type(f(*(literal,)))  # revealed: LiteralString
 
     reveal_type(f(string))  # revealed: str
     reveal_type(f(*(string,)))  # revealed: str
@@ -1355,12 +1339,10 @@ from overloaded import f
 
 def _(list_int: list[int], list_str: list[str], list_any: list[Any], any: Any):
     reveal_type(f(list_int))  # revealed: A
-    # TODO: revealed: A
-    reveal_type(f(*(list_int,)))  # revealed: Unknown
+    reveal_type(f(*(list_int,)))  # revealed: A
 
     reveal_type(f(list_str))  # revealed: str
-    # TODO: Should be `str`
-    reveal_type(f(*(list_str,)))  # revealed: Unknown
+    reveal_type(f(*(list_str,)))  # revealed: str
 
     reveal_type(f(list_any))  # revealed: Unknown
     reveal_type(f(*(list_any,)))  # revealed: Unknown
@@ -1561,12 +1543,10 @@ def _(any: Any):
     reveal_type(f(*(any,), flag=False))  # revealed: str
 
 def _(args: tuple[Any, Literal[True]]):
-    # TODO: revealed: int
-    reveal_type(f(*args))  # revealed: Unknown
+    reveal_type(f(*args))  # revealed: int
 
 def _(args: tuple[Any, Literal[False]]):
-    # TODO: revealed: str
-    reveal_type(f(*args))  # revealed: Unknown
+    reveal_type(f(*args))  # revealed: str
 ```
 
 ### Argument type expansion

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

@@ -1963,6 +1963,10 @@ static_assert(not is_subtype_of(type[A], Callable[[int], A]))
 
 ### Bound methods
 
+The bound `self` or `cls` parameter of a bound method has been curried away, and is no longer
+available as a parameter when calling it. It therefore is not considered when checking subtyping
+involving the bound method.
+
 ```py
 from typing import Callable
 from ty_extensions import TypeOf, static_assert, is_subtype_of
@@ -1981,12 +1985,131 @@ static_assert(is_subtype_of(TypeOf[a.f], Callable[[int], int]))
 static_assert(is_subtype_of(TypeOf[a.g], Callable[[int], int]))
 static_assert(is_subtype_of(TypeOf[A.g], Callable[[int], int]))
 
-static_assert(not is_subtype_of(TypeOf[a.f], Callable[[float], int]))
 static_assert(not is_subtype_of(TypeOf[A.g], Callable[[], int]))
 
 static_assert(is_subtype_of(TypeOf[A.f], Callable[[A, int], int]))
 ```
 
+Return types are in covariant position:
+
+```py
+static_assert(is_subtype_of(TypeOf[a.f], Callable[[int], object]))
+static_assert(is_subtype_of(TypeOf[a.g], Callable[[int], object]))
+static_assert(is_subtype_of(TypeOf[A.g], Callable[[int], object]))
+
+static_assert(not is_subtype_of(TypeOf[a.f], Callable[[int], bool]))
+static_assert(not is_subtype_of(TypeOf[a.g], Callable[[int], bool]))
+static_assert(not is_subtype_of(TypeOf[A.g], Callable[[int], bool]))
+```
+
+Parameter types are in contravariant position:
+
+```py
+static_assert(not is_subtype_of(TypeOf[a.f], Callable[[object], int]))
+static_assert(not is_subtype_of(TypeOf[a.g], Callable[[object], int]))
+static_assert(not is_subtype_of(TypeOf[A.g], Callable[[object], int]))
+
+static_assert(is_subtype_of(TypeOf[a.f], Callable[[bool], int]))
+static_assert(is_subtype_of(TypeOf[a.g], Callable[[bool], int]))
+static_assert(is_subtype_of(TypeOf[A.g], Callable[[bool], int]))
+```
+
+We should get the same results when comparing with a bound method of a different class.
+
+```py
+class B:
+    def returns_int(self, a: int) -> int:
+        return 0
+
+    def returns_object(self, a: int) -> object:
+        return a
+
+    def returns_bool(self, a: int) -> bool:
+        return True
+
+    def takes_object(self, a: object) -> int:
+        return 0
+
+    def takes_bool(self, a: bool) -> int:
+        return 0
+
+    @classmethod
+    def class_returns_int(cls, a: int) -> int:
+        return 0
+
+    @classmethod
+    def class_returns_object(cls, a: int) -> object:
+        return a
+
+    @classmethod
+    def class_returns_bool(cls, a: int) -> bool:
+        return True
+
+    @classmethod
+    def class_takes_object(cls, a: object) -> int:
+        return 0
+
+    @classmethod
+    def class_takes_bool(cls, a: bool) -> int:
+        return 0
+
+b = B()
+
+static_assert(is_subtype_of(TypeOf[a.f], TypeOf[b.returns_object]))
+static_assert(is_subtype_of(TypeOf[a.f], TypeOf[b.returns_int]))
+static_assert(not is_subtype_of(TypeOf[a.f], TypeOf[b.returns_bool]))
+static_assert(not is_subtype_of(TypeOf[a.f], TypeOf[b.takes_object]))
+static_assert(is_subtype_of(TypeOf[a.f], TypeOf[b.takes_bool]))
+
+static_assert(is_subtype_of(TypeOf[a.f], TypeOf[b.class_returns_object]))
+static_assert(is_subtype_of(TypeOf[a.f], TypeOf[b.class_returns_int]))
+static_assert(not is_subtype_of(TypeOf[a.f], TypeOf[b.class_returns_bool]))
+static_assert(not is_subtype_of(TypeOf[a.f], TypeOf[b.class_takes_object]))
+static_assert(is_subtype_of(TypeOf[a.f], TypeOf[b.class_takes_bool]))
+
+static_assert(is_subtype_of(TypeOf[a.f], TypeOf[B.class_returns_object]))
+static_assert(is_subtype_of(TypeOf[a.f], TypeOf[B.class_returns_int]))
+static_assert(not is_subtype_of(TypeOf[a.f], TypeOf[B.class_returns_bool]))
+static_assert(not is_subtype_of(TypeOf[a.f], TypeOf[B.class_takes_object]))
+static_assert(is_subtype_of(TypeOf[a.f], TypeOf[B.class_takes_bool]))
+
+static_assert(is_subtype_of(TypeOf[a.g], TypeOf[b.returns_object]))
+static_assert(is_subtype_of(TypeOf[a.g], TypeOf[b.returns_int]))
+static_assert(not is_subtype_of(TypeOf[a.g], TypeOf[b.returns_bool]))
+static_assert(not is_subtype_of(TypeOf[a.g], TypeOf[b.takes_object]))
+static_assert(is_subtype_of(TypeOf[a.g], TypeOf[b.takes_bool]))
+
+static_assert(is_subtype_of(TypeOf[a.g], TypeOf[b.class_returns_object]))
+static_assert(is_subtype_of(TypeOf[a.g], TypeOf[b.class_returns_int]))
+static_assert(not is_subtype_of(TypeOf[a.g], TypeOf[b.class_returns_bool]))
+static_assert(not is_subtype_of(TypeOf[a.g], TypeOf[b.class_takes_object]))
+static_assert(is_subtype_of(TypeOf[a.g], TypeOf[b.class_takes_bool]))
+
+static_assert(is_subtype_of(TypeOf[a.g], TypeOf[B.class_returns_object]))
+static_assert(is_subtype_of(TypeOf[a.g], TypeOf[B.class_returns_int]))
+static_assert(not is_subtype_of(TypeOf[a.g], TypeOf[B.class_returns_bool]))
+static_assert(not is_subtype_of(TypeOf[a.g], TypeOf[B.class_takes_object]))
+static_assert(is_subtype_of(TypeOf[a.g], TypeOf[B.class_takes_bool]))
+
+static_assert(is_subtype_of(TypeOf[A.g], TypeOf[b.returns_object]))
+static_assert(is_subtype_of(TypeOf[A.g], TypeOf[b.returns_int]))
+static_assert(not is_subtype_of(TypeOf[A.g], TypeOf[b.returns_bool]))
+static_assert(not is_subtype_of(TypeOf[A.g], TypeOf[b.takes_object]))
+static_assert(is_subtype_of(TypeOf[A.g], TypeOf[b.takes_bool]))
+
+static_assert(is_subtype_of(TypeOf[A.g], TypeOf[b.class_returns_object]))
+static_assert(is_subtype_of(TypeOf[A.g], TypeOf[b.class_returns_int]))
+static_assert(not is_subtype_of(TypeOf[A.g], TypeOf[b.class_returns_bool]))
+static_assert(not is_subtype_of(TypeOf[A.g], TypeOf[b.class_takes_object]))
+static_assert(is_subtype_of(TypeOf[A.g], TypeOf[b.class_takes_bool]))
+
+static_assert(is_subtype_of(TypeOf[A.g], TypeOf[B.class_returns_object]))
+static_assert(is_subtype_of(TypeOf[A.g], TypeOf[B.class_returns_int]))
+static_assert(not is_subtype_of(TypeOf[A.g], TypeOf[B.class_returns_bool]))
+static_assert(not is_subtype_of(TypeOf[A.g], TypeOf[B.class_takes_object]))
+static_assert(is_subtype_of(TypeOf[A.g], TypeOf[B.class_takes_bool]))
+```
+
 ### Overloads
 
 #### Subtype overloaded

crates/ty_python_semantic/src/module_resolver/list.rs

@@ -1765,4 +1765,45 @@ not_a_directory
         "#,
         );
     }
+
+    /// This is a regression test for mishandling of file root matching.
+    ///
+    /// In particular, in some cases, `/` is added as a search root. This
+    /// should in turn match everything. But the way we were setting up the
+    /// wildcard for matching was incorrect for this one specific case. That in
+    /// turn meant that the module resolver couldn't find an appropriate file
+    /// root which in turn caused a panic.
+    ///
+    /// See: <https://github.com/astral-sh/ty/issues/1277>
+    #[test]
+    fn root_directory_for_search_path_is_okay() {
+        let project_directory = SystemPathBuf::from("/project");
+        let installed_foo_module = project_directory.join("foo/__init__.py");
+
+        let mut db = TestDb::new();
+        db.write_file(&installed_foo_module, "").unwrap();
+
+        db.files()
+            .try_add_root(&db, SystemPath::new("/"), FileRootKind::Project);
+
+        Program::from_settings(
+            &db,
+            ProgramSettings {
+                python_version: PythonVersionWithSource::default(),
+                python_platform: PythonPlatform::default(),
+                search_paths: SearchPathSettings::new(vec![project_directory])
+                    .to_search_paths(db.system(), db.vendored())
+                    .unwrap(),
+            },
+        );
+
+        insta::assert_debug_snapshot!(
+            list_snapshot_filter(&db, |m| m.name(&db).as_str() == "foo"),
+            @r#"
+        [
+            Module::File("foo", "first-party", "/project/foo/__init__.py", Package, None),
+        ]
+        "#,
+        );
+    }
 }

crates/ty_python_semantic/src/types.rs

@@ -9165,20 +9165,16 @@ impl<'db> BoundMethodType<'db> {
         relation: TypeRelation,
         visitor: &HasRelationToVisitor<'db>,
     ) -> ConstraintSet<'db> {
-        // A bound method is a typically a subtype of itself. However, we must explicitly verify
-        // the subtyping of the underlying function signatures (since they might be specialized
-        // differently), and of the bound self parameter (taking care that parameters, including a
-        // bound self parameter, are contravariant.)
-        self.function(db)
-            .has_relation_to_impl(db, other.function(db), relation, visitor)
-            .and(db, || {
-                other.self_instance(db).has_relation_to_impl(
-                    db,
-                    self.self_instance(db),
-                    relation,
-                    visitor,
-                )
-            })
+        // Note that we do not consider `self_instance`, and we use `into_callable_type` to compare
+        // the signatures of the bound methods _after_ the `self` parameter has been bound. The
+        // bound `self` is no longer available as a parameter to callers, and should therefore not
+        // influence the result of the check.
+        self.into_callable_type(db).has_relation_to_impl(
+            db,
+            other.into_callable_type(db),
+            relation,
+            visitor,
+        )
     }
 
     fn is_equivalent_to_impl(
@@ -9187,13 +9183,12 @@ impl<'db> BoundMethodType<'db> {
         other: Self,
         visitor: &IsEquivalentVisitor<'db>,
     ) -> ConstraintSet<'db> {
-        self.function(db)
-            .is_equivalent_to_impl(db, other.function(db), visitor)
-            .and(db, || {
-                other
-                    .self_instance(db)
-                    .is_equivalent_to_impl(db, self.self_instance(db), visitor)
-            })
+        // Note that we do not consider `self_instance`, and we use `into_callable_type` to compare
+        // the signatures of the bound methods _after_ the `self` parameter has been bound. The
+        // bound `self` is no longer available as a parameter to callers, and should therefore not
+        // influence the result of the check.
+        self.into_callable_type(db)
+            .is_equivalent_to_impl(db, other.into_callable_type(db), visitor)
     }
 }
 

crates/ty_python_semantic/src/types/call/bind.rs

@@ -32,7 +32,7 @@ use crate::types::tuple::{TupleLength, TupleType};
 use crate::types::{
     BoundMethodType, ClassLiteral, DataclassParams, FieldInstance, KnownBoundMethodType,
     KnownClass, KnownInstanceType, MemberLookupPolicy, PropertyInstanceType, SpecialFormType,
-    TrackedConstraintSet, TypeAliasType, TypeContext, TypeMapping, UnionType,
+    TrackedConstraintSet, TypeAliasType, TypeContext, TypeMapping, UnionBuilder, UnionType,
     WrapperDescriptorKind, enums, ide_support, todo_type,
 };
 use ruff_db::diagnostic::{Annotation, Diagnostic, SubDiagnostic, SubDiagnosticSeverity};
@@ -1588,6 +1588,14 @@ impl<'db> CallableBinding<'db> {
         arguments: &CallArguments<'_, 'db>,
         matching_overload_indexes: &[usize],
     ) {
+        // The maximum number of parameters across all the overloads that are being considered
+        // for filtering.
+        let max_parameter_count = matching_overload_indexes
+            .iter()
+            .map(|&index| self.overloads[index].signature.parameters().len())
+            .max()
+            .unwrap_or(0);
+
         // These are the parameter indexes that matches the arguments that participate in the
         // filtering process.
         //
@@ -1595,41 +1603,67 @@ impl<'db> CallableBinding<'db> {
         // gradual equivalent to the parameter types at the same index for other overloads.
         let mut participating_parameter_indexes = HashSet::new();
 
-        // These only contain the top materialized argument types for the corresponding
-        // participating parameter indexes.
-        let mut top_materialized_argument_types = vec![];
+        // The parameter types at each index for the first overload containing a parameter at
+        // that index.
+        let mut first_parameter_types: Vec<Option<Type<'db>>> = vec![None; max_parameter_count];
 
-        for (argument_index, argument_type) in arguments.iter_types().enumerate() {
-            let mut first_parameter_type: Option<Type<'db>> = None;
-            let mut participating_parameter_index = None;
-
-            'overload: for overload_index in matching_overload_indexes {
+        for argument_index in 0..arguments.len() {
+            for overload_index in matching_overload_indexes {
                 let overload = &self.overloads[*overload_index];
-                for parameter_index in &overload.argument_matches[argument_index].parameters {
+                for &parameter_index in &overload.argument_matches[argument_index].parameters {
                     // TODO: For an unannotated `self` / `cls` parameter, the type should be
                     // `typing.Self` / `type[typing.Self]`
-                    let current_parameter_type = overload.signature.parameters()[*parameter_index]
+                    let current_parameter_type = overload.signature.parameters()[parameter_index]
                         .annotated_type()
                         .unwrap_or(Type::unknown());
+                    let first_parameter_type = &mut first_parameter_types[parameter_index];
                     if let Some(first_parameter_type) = first_parameter_type {
                         if !first_parameter_type.is_equivalent_to(db, current_parameter_type) {
-                            participating_parameter_index = Some(*parameter_index);
-                            break 'overload;
+                            participating_parameter_indexes.insert(parameter_index);
                         }
                     } else {
-                        first_parameter_type = Some(current_parameter_type);
+                        *first_parameter_type = Some(current_parameter_type);
                     }
                 }
             }
+        }
 
-            if let Some(parameter_index) = participating_parameter_index {
-                participating_parameter_indexes.insert(parameter_index);
-                top_materialized_argument_types.push(argument_type.top_materialization(db));
+        let mut union_argument_type_builders = std::iter::repeat_with(|| UnionBuilder::new(db))
+            .take(max_parameter_count)
+            .collect::<Vec<_>>();
+
+        for (argument_index, argument_type) in arguments.iter_types().enumerate() {
+            for overload_index in matching_overload_indexes {
+                let overload = &self.overloads[*overload_index];
+                for (parameter_index, variadic_argument_type) in
+                    overload.argument_matches[argument_index].iter()
+                {
+                    if !participating_parameter_indexes.contains(&parameter_index) {
+                        continue;
+                    }
+                    union_argument_type_builders[parameter_index].add_in_place(
+                        variadic_argument_type
+                            .unwrap_or(argument_type)
+                            .top_materialization(db),
+                    );
+                }
             }
         }
 
-        let top_materialized_argument_type =
-            Type::heterogeneous_tuple(db, top_materialized_argument_types);
+        // These only contain the top materialized argument types for the corresponding
+        // participating parameter indexes.
+        let top_materialized_argument_type = Type::heterogeneous_tuple(
+            db,
+            union_argument_type_builders
+                .into_iter()
+                .filter_map(|builder| {
+                    if builder.is_empty() {
+                        None
+                    } else {
+                        Some(builder.build())
+                    }
+                }),
+        );
 
         // A flag to indicate whether we've found the overload that makes the remaining overloads
         // unmatched for the given argument types.
@@ -1640,15 +1674,22 @@ impl<'db> CallableBinding<'db> {
                 self.overloads[*current_index].mark_as_unmatched_overload();
                 continue;
             }
-            let mut parameter_types = Vec::with_capacity(arguments.len());
+
+            let mut union_parameter_types = std::iter::repeat_with(|| UnionBuilder::new(db))
+                .take(max_parameter_count)
+                .collect::<Vec<_>>();
+
+            // The number of parameters that have been skipped because they don't participate in
+            // the filtering process. This is used to make sure the types are added to the
+            // corresponding parameter index in `union_parameter_types`.
+            let mut skipped_parameters = 0;
+
             for argument_index in 0..arguments.len() {
-                // The parameter types at the current argument index.
-                let mut current_parameter_types = vec![];
                 for overload_index in &matching_overload_indexes[..=upto] {
                     let overload = &self.overloads[*overload_index];
                     for parameter_index in &overload.argument_matches[argument_index].parameters {
                         if !participating_parameter_indexes.contains(parameter_index) {
-                            // This parameter doesn't participate in the filtering process.
+                            skipped_parameters += 1;
                             continue;
                         }
                         // TODO: For an unannotated `self` / `cls` parameter, the type should be
@@ -1664,17 +1705,24 @@ impl<'db> CallableBinding<'db> {
                             parameter_type =
                                 parameter_type.apply_specialization(db, inherited_specialization);
                         }
-                        current_parameter_types.push(parameter_type);
+                        union_parameter_types[parameter_index.saturating_sub(skipped_parameters)]
+                            .add_in_place(parameter_type);
                     }
                 }
-                if current_parameter_types.is_empty() {
-                    continue;
-                }
-                parameter_types.push(UnionType::from_elements(db, current_parameter_types));
             }
-            if top_materialized_argument_type
-                .is_assignable_to(db, Type::heterogeneous_tuple(db, parameter_types))
-            {
+
+            let parameter_types = Type::heterogeneous_tuple(
+                db,
+                union_parameter_types.into_iter().filter_map(|builder| {
+                    if builder.is_empty() {
+                        None
+                    } else {
+                        Some(builder.build())
+                    }
+                }),
+            );
+
+            if top_materialized_argument_type.is_assignable_to(db, parameter_types) {
                 filter_remaining_overloads = true;
             }
         }

crates/ty_wasm/Cargo.toml

@@ -40,6 +40,7 @@ log = { workspace = true }
 # See https://docs.rs/getrandom/latest/getrandom/#webassembly-support
 getrandom = { workspace = true, features = ["wasm_js"] }
 serde-wasm-bindgen = { workspace = true }
+tracing = { workspace = true, features = ["log"] }
 # Not a direct dependency but required to compile for Wasm.
 uuid = { workspace = true, features = ["js"] }
 
@@ -50,3 +51,7 @@ wasm-bindgen-test = { workspace = true }
 
 [lints]
 workspace = true
+
+[package.metadata.cargo-shear]
+# Depended on only to enable `log` feature as of 2025-10-03.
+ignored = ["tracing"]

docs/integrations.md

@@ -80,7 +80,7 @@ You can add the following configuration to `.gitlab-ci.yml` to run a `ruff forma
   stage: build
   interruptible: true
   image:
-    name: ghcr.io/astral-sh/ruff:0.13.2-alpine
+    name: ghcr.io/astral-sh/ruff:0.13.3-alpine
   before_script:
     - cd $CI_PROJECT_DIR
     - ruff --version
@@ -106,7 +106,7 @@ Ruff can be used as a [pre-commit](https://pre-commit.com) hook via [`ruff-pre-c
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.13.2
+  rev: v0.13.3
   hooks:
     # Run the linter.
     - id: ruff-check
@@ -119,7 +119,7 @@ To enable lint fixes, add the `--fix` argument to the lint hook:
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.13.2
+  rev: v0.13.3
   hooks:
     # Run the linter.
     - id: ruff-check
@@ -133,7 +133,7 @@ To avoid running on Jupyter Notebooks, remove `jupyter` from the list of allowed
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.13.2
+  rev: v0.13.3
   hooks:
     # Run the linter.
     - id: ruff-check

docs/tutorial.md

@@ -369,7 +369,7 @@ This tutorial has focused on Ruff's command-line interface, but Ruff can also be
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.13.2
+  rev: v0.13.3
   hooks:
     # Run the linter.
     - id: ruff

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ruff"
-version = "0.13.2"
+version = "0.13.3"
 description = "An extremely fast Python linter and code formatter, written in Rust."
 authors = [{ name = "Astral Software Inc.", email = "hey@astral.sh" }]
 readme = "README.md"

scripts/benchmarks/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scripts"
-version = "0.13.2"
+version = "0.13.3"
 description = ""
 authors = ["Charles Marsh <charlie.r.marsh@gmail.com>"]