[ty] Experiment: Remove infer_expression_type query

This PR extends the "go to declaration" and "go to definition"
functionality to support import statements — both standard imports and
"from" import forms.

---------

Co-authored-by: UnboundVariable <unbound@gmail.com>

CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 0.12.4
+
+### Preview features
+
+- \[`flake8-type-checking`, `pyupgrade`, `ruff`\] Add `from __future__ import annotations` when it would allow new fixes (`TC001`, `TC002`, `TC003`, `UP037`, `RUF013`) ([#19100](https://github.com/astral-sh/ruff/pull/19100))
+- \[`flake8-use-pathlib`\] Add autofix for `PTH109` ([#19245](https://github.com/astral-sh/ruff/pull/19245))
+- \[`pylint`\] Detect indirect `pathlib.Path` usages for `unspecified-encoding` (`PLW1514`) ([#19304](https://github.com/astral-sh/ruff/pull/19304))
+
+### Bug fixes
+
+- \[`flake8-bugbear`\] Fix `B017` false negatives for keyword exception arguments ([#19217](https://github.com/astral-sh/ruff/pull/19217))
+- \[`flake8-use-pathlib`\] Fix false negative on direct `Path()` instantiation (`PTH210`) ([#19388](https://github.com/astral-sh/ruff/pull/19388))
+- \[`flake8-django`\] Fix `DJ008` false positive for abstract models with type-annotated `abstract` field ([#19221](https://github.com/astral-sh/ruff/pull/19221))
+- \[`isort`\] Fix `I002` import insertion after docstring with multiple string statements ([#19222](https://github.com/astral-sh/ruff/pull/19222))
+- \[`isort`\] Treat form feed as valid whitespace before a semicolon ([#19343](https://github.com/astral-sh/ruff/pull/19343))
+- \[`pydoclint`\] Fix `SyntaxError` from fixes with line continuations (`D201`, `D202`) ([#19246](https://github.com/astral-sh/ruff/pull/19246))
+- \[`refurb`\] `FURB164` fix should validate arguments and should usually be marked unsafe ([#19136](https://github.com/astral-sh/ruff/pull/19136))
+
+### Rule changes
+
+- \[`flake8-use-pathlib`\] Skip single dots for `invalid-pathlib-with-suffix` (`PTH210`) on versions >= 3.14 ([#19331](https://github.com/astral-sh/ruff/pull/19331))
+- \[`pep8_naming`\] Avoid false positives on standard library functions with uppercase names (`N802`) ([#18907](https://github.com/astral-sh/ruff/pull/18907))
+- \[`pycodestyle`\] Handle brace escapes for t-strings in logical lines ([#19358](https://github.com/astral-sh/ruff/pull/19358))
+- \[`pylint`\] Extend invalid string character rules to include t-strings ([#19355](https://github.com/astral-sh/ruff/pull/19355))
+- \[`ruff`\] Allow `strict` kwarg when checking for `starmap-zip` (`RUF058`) in Python 3.14+ ([#19333](https://github.com/astral-sh/ruff/pull/19333))
+
+### Documentation
+
+- \[`flake8-type-checking`\] Make `TC010` docs example more realistic ([#19356](https://github.com/astral-sh/ruff/pull/19356))
+- Make more documentation examples error out-of-the-box ([#19288](https://github.com/astral-sh/ruff/pull/19288),[#19272](https://github.com/astral-sh/ruff/pull/19272),[#19291](https://github.com/astral-sh/ruff/pull/19291),[#19296](https://github.com/astral-sh/ruff/pull/19296),[#19292](https://github.com/astral-sh/ruff/pull/19292),[#19295](https://github.com/astral-sh/ruff/pull/19295),[#19297](https://github.com/astral-sh/ruff/pull/19297),[#19309](https://github.com/astral-sh/ruff/pull/19309))
+
 ## 0.12.3
 
 ### Preview features

CONTRIBUTING.md

@@ -266,6 +266,13 @@ Finally, regenerate the documentation and generated code with `cargo dev generat
 
 ## MkDocs
 
+> [!NOTE]
+>
+> The documentation uses Material for MkDocs Insiders, which is closed-source software.
+> This means only members of the Astral organization can preview the documentation exactly as it
+> will appear in production.
+> Outside contributors can still preview the documentation, but there will be some differences. Consult [the Material for MkDocs documentation](https://squidfunk.github.io/mkdocs-material/insiders/benefits/#features) for which features are exclusively available in the insiders version.
+
 To preview any changes to the documentation locally:
 
 1. Install the [Rust toolchain](https://www.rust-lang.org/tools/install).

Cargo.lock

@@ -1557,6 +1557,15 @@ dependencies = [
  "memoffset",
 ]
 
+[[package]]
+name = "inventory"
+version = "0.3.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab08d7cd2c5897f2c949e5383ea7c7db03fb19130ffcfbf7eda795137ae3cb83"
+dependencies = [
+ "rustversion",
+]
+
 [[package]]
 name = "is-docker"
 version = "0.2.0"
@@ -2123,16 +2132,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
-[[package]]
-name = "papaya"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f92dd0b07c53a0a0c764db2ace8c541dc47320dad97c2200c2a637ab9dd2328f"
-dependencies = [
- "equivalent",
- "seize",
-]
-
 [[package]]
 name = "parking_lot"
 version = "0.12.3"
@@ -2711,7 +2710,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.12.3"
+version = "0.12.4"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2839,6 +2838,7 @@ dependencies = [
  "insta",
  "matchit",
  "path-slash",
+ "quick-junit",
  "ruff_annotate_snippets",
  "ruff_cache",
  "ruff_diagnostics",
@@ -2962,7 +2962,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.12.3"
+version = "0.12.4"
 dependencies = [
  "aho-corasick",
  "anyhow",
@@ -2987,7 +2987,6 @@ dependencies = [
  "pathdiff",
  "pep440_rs",
  "pyproject-toml",
- "quick-junit",
  "regex",
  "ruff_annotate_snippets",
  "ruff_cache",
@@ -3295,7 +3294,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.12.3"
+version = "0.12.4"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -3409,7 +3408,7 @@ checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 [[package]]
 name = "salsa"
 version = "0.23.0"
-source = "git+https://github.com/salsa-rs/salsa?rev=fc00eba89e5dcaa5edba51c41aa5f309b5cb126b#fc00eba89e5dcaa5edba51c41aa5f309b5cb126b"
+source = "git+https://github.com/salsa-rs/salsa?rev=dba66f1a37acca014c2402f231ed5b361bd7d8fe#dba66f1a37acca014c2402f231ed5b361bd7d8fe"
 dependencies = [
  "boxcar",
  "compact_str",
@@ -3419,7 +3418,7 @@ dependencies = [
  "hashlink",
  "indexmap",
  "intrusive-collections",
- "papaya",
+ "inventory",
  "parking_lot",
  "portable-atomic",
  "rayon",
@@ -3434,12 +3433,12 @@ dependencies = [
 [[package]]
 name = "salsa-macro-rules"
 version = "0.23.0"
-source = "git+https://github.com/salsa-rs/salsa?rev=fc00eba89e5dcaa5edba51c41aa5f309b5cb126b#fc00eba89e5dcaa5edba51c41aa5f309b5cb126b"
+source = "git+https://github.com/salsa-rs/salsa?rev=dba66f1a37acca014c2402f231ed5b361bd7d8fe#dba66f1a37acca014c2402f231ed5b361bd7d8fe"
 
 [[package]]
 name = "salsa-macros"
 version = "0.23.0"
-source = "git+https://github.com/salsa-rs/salsa?rev=fc00eba89e5dcaa5edba51c41aa5f309b5cb126b#fc00eba89e5dcaa5edba51c41aa5f309b5cb126b"
+source = "git+https://github.com/salsa-rs/salsa?rev=dba66f1a37acca014c2402f231ed5b361bd7d8fe#dba66f1a37acca014c2402f231ed5b361bd7d8fe"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3492,16 +3491,6 @@ version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
 
-[[package]]
-name = "seize"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4b8d813387d566f627f3ea1b914c068aac94c40ae27ec43f5f33bde65abefe7"
-dependencies = [
- "libc",
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "serde"
 version = "1.0.219"
@@ -4300,6 +4289,7 @@ name = "ty_server"
 version = "0.0.0"
 dependencies = [
  "anyhow",
+ "bitflags 2.9.1",
  "crossbeam",
  "jod-thread",
  "libc",

Cargo.toml

@@ -138,7 +138,7 @@ regex-automata = { version = "0.4.9" }
 rustc-hash = { version = "2.0.0" }
 rustc-stable-hash = { version = "0.1.2" }
 # When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
-salsa = { git = "https://github.com/salsa-rs/salsa", rev = "fc00eba89e5dcaa5edba51c41aa5f309b5cb126b" }
+salsa = { git = "https://github.com/salsa-rs/salsa", rev = "dba66f1a37acca014c2402f231ed5b361bd7d8fe" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }
@@ -150,7 +150,7 @@ serde_with = { version = "3.6.0", default-features = false, features = [
 ] }
 shellexpand = { version = "3.0.0" }
 similar = { version = "2.4.0", features = ["inline"] }
-smallvec = { version = "1.13.2" }
+smallvec = { version = "1.13.2", features = ["union", "const_generics", "const_new"] }
 snapbox = { version = "0.6.0", features = [
     "diff",
     "term-svg",

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.12.3/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.12.3/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.12.4/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.12.4/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.12.3
+  rev: v0.12.4
   hooks:
     # Run the linter.
     - id: ruff-check

crates/ruff/Cargo.toml

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

crates/ruff/src/printer.rs

@@ -15,8 +15,8 @@ use ruff_db::diagnostic::{
 use ruff_linter::fs::relativize_path;
 use ruff_linter::logging::LogLevel;
 use ruff_linter::message::{
-    Emitter, EmitterContext, GithubEmitter, GitlabEmitter, GroupedEmitter, JunitEmitter,
-    SarifEmitter, TextEmitter,
+    Emitter, EmitterContext, GithubEmitter, GitlabEmitter, GroupedEmitter, SarifEmitter,
+    TextEmitter,
 };
 use ruff_linter::notify_user;
 use ruff_linter::settings::flags::{self};
@@ -252,7 +252,11 @@ impl Printer {
                 write!(writer, "{value}")?;
             }
             OutputFormat::Junit => {
-                JunitEmitter.emit(writer, &diagnostics.inner, &context)?;
+                let config = DisplayDiagnosticConfig::default()
+                    .format(DiagnosticFormat::Junit)
+                    .preview(preview);
+                let value = DisplayDiagnostics::new(&context, &config, &diagnostics.inner);
+                write!(writer, "{value}")?;
             }
             OutputFormat::Concise | OutputFormat::Full => {
                 TextEmitter::default()

crates/ruff/tests/lint.rs

@@ -993,6 +993,7 @@ fn value_given_to_table_key_is_not_inline_table_2() {
     - `lint.exclude`
     - `lint.preview`
     - `lint.typing-extensions`
+    - `lint.future-annotations`
 
     For more information, try '--help'.
     ");
@@ -5717,8 +5718,11 @@ match 42:  # invalid-syntax
 
     let snapshot = format!("output_format_{output_format}");
 
+    let project_dir = dunce::canonicalize(tempdir.path())?;
+
     insta::with_settings!({
         filters => vec![
+            (tempdir_filter(&project_dir).as_str(), "[TMP]/"),
             (tempdir_filter(&tempdir).as_str(), "[TMP]/"),
             (r#""[^"]+\\?/?input.py"#, r#""[TMP]/input.py"#),
             (ruff_linter::VERSION, "[VERSION]"),
@@ -5744,3 +5748,25 @@ match 42:  # invalid-syntax
 
     Ok(())
 }
+
+#[test]
+fn future_annotations_preview_warning() {
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+            .args(STDIN_BASE_OPTIONS)
+            .args(["--config", "lint.future-annotations = true"])
+            .args(["--select", "F"])
+            .arg("--no-preview")
+            .arg("-")
+            .pass_stdin("1"),
+        @r"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    All checks passed!
+
+    ----- stderr -----
+    warning: The `lint.future-annotations` setting will have no effect because `preview` is disabled
+    ",
+    );
+}

crates/ruff/tests/snapshots/lint__output_format_junit.snap

@@ -25,7 +25,7 @@ exit_code: 1
         <testcase name="org.ruff.F821" classname="[TMP]/input" line="2" column="5">
             <failure message="Undefined name `y`">line 2, col 5, Undefined name `y`</failure>
         </testcase>
-        <testcase name="org.ruff" classname="[TMP]/input" line="3" column="1">
+        <testcase name="org.ruff.invalid-syntax" classname="[TMP]/input" line="3" column="1">
             <failure message="SyntaxError: Cannot use `match` statement on Python 3.9 (syntax was added in Python 3.10)">line 3, col 1, SyntaxError: Cannot use `match` statement on Python 3.9 (syntax was added in Python 3.10)</failure>
         </testcase>
     </testsuite>

crates/ruff_benchmark/benches/ty.rs

@@ -18,7 +18,7 @@ use ruff_python_ast::PythonVersion;
 use ty_project::metadata::options::{EnvironmentOptions, Options};
 use ty_project::metadata::value::{RangedValue, RelativePathBuf};
 use ty_project::watch::{ChangeEvent, ChangedKind};
-use ty_project::{Db, ProjectDatabase, ProjectMetadata};
+use ty_project::{CheckMode, Db, ProjectDatabase, ProjectMetadata};
 
 struct Case {
     db: ProjectDatabase,
@@ -102,6 +102,7 @@ fn setup_tomllib_case() -> Case {
 
     let re = re.unwrap();
 
+    db.set_check_mode(CheckMode::OpenFiles);
     db.project().set_open_files(&mut db, tomllib_files);
 
     let re_path = re.path(&db).as_system_path().unwrap().to_owned();
@@ -237,6 +238,7 @@ fn setup_micro_case(code: &str) -> Case {
     let mut db = ProjectDatabase::new(metadata, system).unwrap();
     let file = system_path_to_file(&db, SystemPathBuf::from(file_path)).unwrap();
 
+    db.set_check_mode(CheckMode::OpenFiles);
     db.project()
         .set_open_files(&mut db, FxHashSet::from_iter([file]));
 
@@ -525,14 +527,21 @@ impl<'a> ProjectBenchmark<'a> {
 
 #[track_caller]
 fn bench_project(benchmark: &ProjectBenchmark, criterion: &mut Criterion) {
-    fn check_project(db: &mut ProjectDatabase, max_diagnostics: usize) {
+    fn check_project(db: &mut ProjectDatabase, project_name: &str, max_diagnostics: usize) {
         let result = db.check();
         let diagnostics = result.len();
 
-        assert!(
-            diagnostics <= max_diagnostics,
-            "Expected <={max_diagnostics} diagnostics but got {diagnostics}"
-        );
+        if diagnostics > max_diagnostics {
+            let details = result
+                .into_iter()
+                .map(|diagnostic| diagnostic.concise_message().to_string())
+                .collect::<Vec<_>>()
+                .join("\n  ");
+            assert!(
+                diagnostics <= max_diagnostics,
+                "{project_name}: Expected <={max_diagnostics} diagnostics but got {diagnostics}:\n  {details}",
+            );
+        }
     }
 
     setup_rayon();
@@ -542,7 +551,7 @@ fn bench_project(benchmark: &ProjectBenchmark, criterion: &mut Criterion) {
     group.bench_function(benchmark.project.config.name, |b| {
         b.iter_batched_ref(
             || benchmark.setup_iteration(),
-            |db| check_project(db, benchmark.max_diagnostics),
+            |db| check_project(db, benchmark.project.config.name, benchmark.max_diagnostics),
             BatchSize::SmallInput,
         );
     });
@@ -610,7 +619,7 @@ fn datetype(criterion: &mut Criterion) {
             max_dep_date: "2025-07-04",
             python_version: PythonVersion::PY313,
         },
-        0,
+        2,
     );
 
     bench_project(&benchmark, criterion);

crates/ruff_db/Cargo.toml

@@ -34,6 +34,7 @@ glob = { workspace = true }
 ignore = { workspace = true, optional = true }
 matchit = { workspace = true }
 path-slash = { workspace = true }
+quick-junit = { workspace = true, optional = true }
 rustc-hash = { workspace = true }
 salsa = { workspace = true }
 schemars = { workspace = true, optional = true }
@@ -56,6 +57,7 @@ tempfile = { workspace = true }
 
 [features]
 cache = ["ruff_cache"]
+junit = ["dep:quick-junit"]
 os = ["ignore", "dep:etcetera"]
 serde = ["camino/serde1", "dep:serde", "dep:serde_json", "ruff_diagnostics/serde"]
 # Exposes testing utilities.

crates/ruff_db/src/diagnostic/mod.rs

@@ -1282,6 +1282,9 @@ pub enum DiagnosticFormat {
     Rdjson,
     /// Print diagnostics in the format emitted by Pylint.
     Pylint,
+    /// Print diagnostics in the format expected by JUnit.
+    #[cfg(feature = "junit")]
+    Junit,
 }
 
 /// A representation of the kinds of messages inside a diagnostic.

crates/ruff_db/src/diagnostic/render.rs

@@ -30,6 +30,8 @@ mod azure;
 mod json;
 #[cfg(feature = "serde")]
 mod json_lines;
+#[cfg(feature = "junit")]
+mod junit;
 mod pylint;
 #[cfg(feature = "serde")]
 mod rdjson;
@@ -156,7 +158,8 @@ impl std::fmt::Display for DisplayDiagnostics<'_> {
                     AnnotateRenderer::styled()
                 } else {
                     AnnotateRenderer::plain()
-                };
+                }
+                .cut_indicator("…");
 
                 renderer = renderer
                     .error(stylesheet.error)
@@ -196,6 +199,10 @@ impl std::fmt::Display for DisplayDiagnostics<'_> {
             DiagnosticFormat::Pylint => {
                 PylintRenderer::new(self.resolver).render(f, self.diagnostics)?;
             }
+            #[cfg(feature = "junit")]
+            DiagnosticFormat::Junit => {
+                junit::JunitRenderer::new(self.resolver).render(f, self.diagnostics)?;
+            }
         }
 
         Ok(())

crates/ruff_db/src/diagnostic/render/junit.rs

@@ -0,0 +1,195 @@
+use std::{collections::BTreeMap, ops::Deref, path::Path};
+
+use quick_junit::{NonSuccessKind, Report, TestCase, TestCaseStatus, TestSuite, XmlString};
+
+use ruff_source_file::LineColumn;
+
+use crate::diagnostic::{Diagnostic, SecondaryCode, render::FileResolver};
+
+/// A renderer for diagnostics in the [JUnit] format.
+///
+/// See [`junit.xsd`] for the specification in the JUnit repository and an annotated [version]
+/// linked from the [`quick_junit`] docs.
+///
+/// [JUnit]: https://junit.org/
+/// [`junit.xsd`]: https://github.com/junit-team/junit-framework/blob/2870b7d8fd5bf7c1efe489d3991d3ed3900e82bb/platform-tests/src/test/resources/jenkins-junit.xsd
+/// [version]: https://llg.cubic.org/docs/junit/
+/// [`quick_junit`]: https://docs.rs/quick-junit/latest/quick_junit/
+pub struct JunitRenderer<'a> {
+    resolver: &'a dyn FileResolver,
+}
+
+impl<'a> JunitRenderer<'a> {
+    pub fn new(resolver: &'a dyn FileResolver) -> Self {
+        Self { resolver }
+    }
+
+    pub(super) fn render(
+        &self,
+        f: &mut std::fmt::Formatter,
+        diagnostics: &[Diagnostic],
+    ) -> std::fmt::Result {
+        let mut report = Report::new("ruff");
+
+        if diagnostics.is_empty() {
+            let mut test_suite = TestSuite::new("ruff");
+            test_suite
+                .extra
+                .insert(XmlString::new("package"), XmlString::new("org.ruff"));
+            let mut case = TestCase::new("No errors found", TestCaseStatus::success());
+            case.set_classname("ruff");
+            test_suite.add_test_case(case);
+            report.add_test_suite(test_suite);
+        } else {
+            for (filename, diagnostics) in group_diagnostics_by_filename(diagnostics, self.resolver)
+            {
+                let mut test_suite = TestSuite::new(filename);
+                test_suite
+                    .extra
+                    .insert(XmlString::new("package"), XmlString::new("org.ruff"));
+
+                let classname = Path::new(filename).with_extension("");
+
+                for diagnostic in diagnostics {
+                    let DiagnosticWithLocation {
+                        diagnostic,
+                        start_location: location,
+                    } = diagnostic;
+                    let mut status = TestCaseStatus::non_success(NonSuccessKind::Failure);
+                    status.set_message(diagnostic.body());
+
+                    if let Some(location) = location {
+                        status.set_description(format!(
+                            "line {row}, col {col}, {body}",
+                            row = location.line,
+                            col = location.column,
+                            body = diagnostic.body()
+                        ));
+                    } else {
+                        status.set_description(diagnostic.body());
+                    }
+
+                    let code = diagnostic
+                        .secondary_code()
+                        .map_or_else(|| diagnostic.name(), SecondaryCode::as_str);
+                    let mut case = TestCase::new(format!("org.ruff.{code}"), status);
+                    case.set_classname(classname.to_str().unwrap());
+
+                    if let Some(location) = location {
+                        case.extra.insert(
+                            XmlString::new("line"),
+                            XmlString::new(location.line.to_string()),
+                        );
+                        case.extra.insert(
+                            XmlString::new("column"),
+                            XmlString::new(location.column.to_string()),
+                        );
+                    }
+
+                    test_suite.add_test_case(case);
+                }
+                report.add_test_suite(test_suite);
+            }
+        }
+
+        let adapter = FmtAdapter { fmt: f };
+        report.serialize(adapter).map_err(|_| std::fmt::Error)
+    }
+}
+
+// TODO(brent) this and `group_diagnostics_by_filename` are also used by the `grouped` output
+// format. I think they'd make more sense in that file, but I started here first. I'll move them to
+// that module when adding the `grouped` output format.
+struct DiagnosticWithLocation<'a> {
+    diagnostic: &'a Diagnostic,
+    start_location: Option<LineColumn>,
+}
+
+impl Deref for DiagnosticWithLocation<'_> {
+    type Target = Diagnostic;
+
+    fn deref(&self) -> &Self::Target {
+        self.diagnostic
+    }
+}
+
+fn group_diagnostics_by_filename<'a>(
+    diagnostics: &'a [Diagnostic],
+    resolver: &'a dyn FileResolver,
+) -> BTreeMap<&'a str, Vec<DiagnosticWithLocation<'a>>> {
+    let mut grouped_diagnostics = BTreeMap::default();
+    for diagnostic in diagnostics {
+        let (filename, start_location) = diagnostic
+            .primary_span_ref()
+            .map(|span| {
+                let file = span.file();
+                let start_location =
+                    span.range()
+                        .filter(|_| !resolver.is_notebook(file))
+                        .map(|range| {
+                            file.diagnostic_source(resolver)
+                                .as_source_code()
+                                .line_column(range.start())
+                        });
+
+                (span.file().path(resolver), start_location)
+            })
+            .unwrap_or_default();
+
+        grouped_diagnostics
+            .entry(filename)
+            .or_insert_with(Vec::new)
+            .push(DiagnosticWithLocation {
+                diagnostic,
+                start_location,
+            });
+    }
+    grouped_diagnostics
+}
+
+struct FmtAdapter<'a> {
+    fmt: &'a mut dyn std::fmt::Write,
+}
+
+impl std::io::Write for FmtAdapter<'_> {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        self.fmt
+            .write_str(std::str::from_utf8(buf).map_err(|_| {
+                std::io::Error::new(
+                    std::io::ErrorKind::InvalidData,
+                    "Invalid UTF-8 in JUnit report",
+                )
+            })?)
+            .map_err(std::io::Error::other)?;
+
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+
+    fn write_fmt(&mut self, args: std::fmt::Arguments<'_>) -> std::io::Result<()> {
+        self.fmt.write_fmt(args).map_err(std::io::Error::other)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::diagnostic::{
+        DiagnosticFormat,
+        render::tests::{create_diagnostics, create_syntax_error_diagnostics},
+    };
+
+    #[test]
+    fn output() {
+        let (env, diagnostics) = create_diagnostics(DiagnosticFormat::Junit);
+        insta::assert_snapshot!(env.render_diagnostics(&diagnostics));
+    }
+
+    #[test]
+    fn syntax_errors() {
+        let (env, diagnostics) = create_syntax_error_diagnostics(DiagnosticFormat::Junit);
+        insta::assert_snapshot!(env.render_diagnostics(&diagnostics));
+    }
+}

crates/ruff_db/src/diagnostic/render/snapshots/ruff_db__diagnostic__render__junit__tests__output.snap

@@ -1,7 +1,6 @@
 ---
-source: crates/ruff_linter/src/message/junit.rs
-expression: content
-snapshot_kind: text
+source: crates/ruff_db/src/diagnostic/render/junit.rs
+expression: env.render_diagnostics(&diagnostics)
 ---
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuites name="ruff" tests="3" failures="3" errors="0">

crates/ruff_db/src/diagnostic/render/snapshots/ruff_db__diagnostic__render__junit__tests__syntax_errors.snap

@@ -1,15 +1,14 @@
 ---
-source: crates/ruff_linter/src/message/junit.rs
-expression: content
-snapshot_kind: text
+source: crates/ruff_db/src/diagnostic/render/junit.rs
+expression: env.render_diagnostics(&diagnostics)
 ---
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuites name="ruff" tests="2" failures="2" errors="0">
     <testsuite name="syntax_errors.py" tests="2" disabled="0" errors="0" failures="2" package="org.ruff">
-        <testcase name="org.ruff" classname="syntax_errors" line="1" column="15">
+        <testcase name="org.ruff.invalid-syntax" classname="syntax_errors" line="1" column="15">
             <failure message="SyntaxError: Expected one or more symbol names after import">line 1, col 15, SyntaxError: Expected one or more symbol names after import</failure>
         </testcase>
-        <testcase name="org.ruff" classname="syntax_errors" line="3" column="12">
+        <testcase name="org.ruff.invalid-syntax" classname="syntax_errors" line="3" column="12">
             <failure message="SyntaxError: Expected &apos;)&apos;, found newline">line 3, col 12, SyntaxError: Expected &apos;)&apos;, found newline</failure>
         </testcase>
     </testsuite>

crates/ruff_db/src/files.rs

@@ -232,7 +232,7 @@ impl Files {
         let roots = inner.roots.read().unwrap();
 
         for root in roots.all() {
-            if root.path(db).starts_with(&path) {
+            if path.starts_with(root.path(db)) {
                 root.set_revision(db).to(FileRevision::now());
             }
         }
@@ -375,12 +375,25 @@ impl File {
     }
 
     /// Refreshes the file metadata by querying the file system if needed.
+    ///
+    /// This also "touches" the file root associated with the given path.
+    /// This means that any Salsa queries that depend on the corresponding
+    /// root's revision will become invalidated.
     pub fn sync_path(db: &mut dyn Db, path: &SystemPath) {
         let absolute = SystemPath::absolute(path, db.system().current_directory());
         Files::touch_root(db, &absolute);
         Self::sync_system_path(db, &absolute, None);
     }
 
+    /// Refreshes *only* the file metadata by querying the file system if needed.
+    ///
+    /// This specifically does not touch any file root associated with the
+    /// given file path.
+    pub fn sync_path_only(db: &mut dyn Db, path: &SystemPath) {
+        let absolute = SystemPath::absolute(path, db.system().current_directory());
+        Self::sync_system_path(db, &absolute, None);
+    }
+
     /// Increments the revision for the virtual file at `path`.
     pub fn sync_virtual_path(db: &mut dyn Db, path: &SystemVirtualPath) {
         if let Some(virtual_file) = db.files().try_virtual_file(path) {
@@ -486,7 +499,7 @@ impl fmt::Debug for File {
 ///
 /// This is a wrapper around a [`File`] that provides additional methods to interact with a virtual
 /// file.
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub struct VirtualFile(File);
 
 impl VirtualFile {

crates/ruff_db/src/files/file_root.rs

@@ -23,7 +23,7 @@ pub struct FileRoot {
     pub path: SystemPathBuf,
 
     /// The kind of the root at the time of its creation.
-    kind_at_time_of_creation: FileRootKind,
+    pub kind_at_time_of_creation: FileRootKind,
 
     /// A revision that changes when the contents of the source root change.
     ///

crates/ruff_graph/src/db.rs

@@ -87,7 +87,7 @@ impl SourceDb for ModuleDb {
 
 #[salsa::db]
 impl Db for ModuleDb {
-    fn is_file_open(&self, file: File) -> bool {
+    fn should_check_file(&self, file: File) -> bool {
         !file.path(self).is_vendored_path()
     }
 

crates/ruff_linter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.12.3"
+version = "0.12.4"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -15,7 +15,7 @@ license = { workspace = true }
 [dependencies]
 ruff_annotate_snippets = { workspace = true }
 ruff_cache = { workspace = true }
-ruff_db = { workspace = true, features = ["serde"] }
+ruff_db = { workspace = true, features = ["junit", "serde"] }
 ruff_diagnostics = { workspace = true, features = ["serde"] }
 ruff_notebook = { workspace = true }
 ruff_macros = { workspace = true }
@@ -55,7 +55,6 @@ path-absolutize = { workspace = true, features = [
 pathdiff = { workspace = true }
 pep440_rs = { workspace = true }
 pyproject-toml = { workspace = true }
-quick-junit = { workspace = true }
 regex = { workspace = true }
 rustc-hash = { workspace = true }
 schemars = { workspace = true, optional = true }

crates/ruff_linter/resources/test/fixtures/flake8_type_checking/TC001-3_future.py

@@ -0,0 +1,10 @@
+from collections import Counter
+
+from elsewhere import third_party
+
+from . import first_party
+
+
+def f(x: first_party.foo): ...
+def g(x: third_party.bar): ...
+def h(x: Counter): ...

crates/ruff_linter/resources/test/fixtures/flake8_type_checking/TC001_future.py

@@ -0,0 +1,68 @@
+def f():
+    from . import first_party
+
+    def f(x: first_party.foo): ...
+
+
+# Type parameter bounds
+def g():
+    from . import foo
+
+    class C[T: foo.Ty]: ...
+
+
+def h():
+    from . import foo
+
+    def f[T: foo.Ty](x: T): ...
+
+
+def i():
+    from . import foo
+
+    type Alias[T: foo.Ty] = list[T]
+
+
+# Type parameter defaults
+def j():
+    from . import foo
+
+    class C[T = foo.Ty]: ...
+
+
+def k():
+    from . import foo
+
+    def f[T = foo.Ty](x: T): ...
+
+
+def l():
+    from . import foo
+
+    type Alias[T = foo.Ty] = list[T]
+
+
+# non-generic type alias
+def m():
+    from . import foo
+
+    type Alias = foo.Ty
+
+
+# unions
+from typing import Union
+
+
+def n():
+    from . import foo
+
+    def f(x: Union[foo.Ty, int]): ...
+    def g(x: foo.Ty | int): ...
+
+
+# runtime and typing usage
+def o():
+    from . import foo
+
+    def f(x: foo.Ty):
+        return foo.Ty()

crates/ruff_linter/resources/test/fixtures/flake8_type_checking/TC001_future_present.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from . import first_party
+
+
+def f(x: first_party.foo): ...

crates/ruff_linter/resources/test/fixtures/flake8_use_pathlib/PTH210.py

@@ -54,6 +54,13 @@ windows_path.with_suffix(r"s")
 windows_path.with_suffix(u'' "json")
 windows_path.with_suffix(suffix="js")
 
+Path().with_suffix(".")
+Path().with_suffix("py")
+PosixPath().with_suffix("py")
+PurePath().with_suffix("py")
+PurePosixPath().with_suffix("py")
+PureWindowsPath().with_suffix("py")
+WindowsPath().with_suffix("py")
 
 ### No errors
 path.with_suffix()

crates/ruff_linter/resources/test/fixtures/flake8_use_pathlib/full_name.py

@@ -104,3 +104,6 @@ os.chmod(x)
 os.replace("src", "dst", src_dir_fd=1, dst_dir_fd=2)
 os.replace("src", "dst", src_dir_fd=1)
 os.replace("src", "dst", dst_dir_fd=2)
+
+os.getcwd()
+os.getcwdb()

crates/ruff_linter/resources/test/fixtures/isort/required_imports/whitespace.py

@@ -0,0 +1,5 @@
+# This is a regression test for https://github.com/astral-sh/ruff/issues/19310
+# there is a (potentially invisible) unicode formfeed character (000C) between "docstring" and the semicolon
+"docstring"; print(
+    f"{__doc__=}",
+)

crates/ruff_linter/resources/test/fixtures/pylint/unspecified_encoding.py

@@ -91,9 +91,16 @@ Path("foo.txt").write_text(text, encoding="utf-8")
 Path("foo.txt").write_text(text, *args)
 Path("foo.txt").write_text(text, **kwargs)
 
-# Violation but not detectable
+# https://github.com/astral-sh/ruff/issues/19294
 x = Path("foo.txt")
 x.open()
 
 # https://github.com/astral-sh/ruff/issues/18107
 codecs.open("plw1514.py", "r", "utf-8").close() # this is fine
+
+# function argument annotated as Path
+from pathlib import Path
+
+def format_file(file: Path):
+    with file.open() as f:
+        contents = f.read()

crates/ruff_linter/resources/test/fixtures/refurb/FURB164.py

@@ -27,7 +27,24 @@ _ = Decimal.from_float(float("   -inF\n \t"))
 _ = Decimal.from_float(float("  InfinIty \n\t "))
 _ = Decimal.from_float(float("   -InfinIty\n \t"))
 
-# OK
+# Cases with keyword arguments - should produce unsafe fixes
+_ = Fraction.from_decimal(dec=Decimal("4.2"))
+_ = Decimal.from_float(f=4.2)
+
+# Cases with invalid argument counts - should not get fixes
+_ = Fraction.from_decimal(Decimal("4.2"), 1)
+_ = Decimal.from_float(4.2, None)
+
+# Cases with wrong keyword arguments - should not get fixes  
+_ = Fraction.from_decimal(numerator=Decimal("4.2"))
+_ = Decimal.from_float(value=4.2)
+
+# Cases with type validation issues - should produce unsafe fixes
+_ = Decimal.from_float("4.2")  # Invalid type for from_float
+_ = Fraction.from_decimal(4.2)  # Invalid type for from_decimal
+_ = Fraction.from_float("4.2")  # Invalid type for from_float
+
+# OK - should not trigger the rule
 _ = Fraction(0.1)
 _ = Fraction(-0.5)
 _ = Fraction(5.0)

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

@@ -71,7 +71,7 @@ pub(crate) fn deferred_scopes(checker: &Checker) {
                         flake8_type_checking::helpers::is_valid_runtime_import(
                             binding,
                             &checker.semantic,
-                            &checker.settings().flake8_type_checking,
+                            checker.settings(),
                         )
                     })
                     .collect()

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

@@ -1044,7 +1044,6 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
                 Rule::OsMakedirs,
                 Rule::OsRename,
                 Rule::OsReplace,
-                Rule::OsGetcwd,
                 Rule::OsStat,
                 Rule::OsPathJoin,
                 Rule::OsPathSamefile,
@@ -1110,6 +1109,9 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
                 if checker.is_rule_enabled(Rule::OsReadlink) {
                     flake8_use_pathlib::rules::os_readlink(checker, call, segments);
                 }
+                if checker.is_rule_enabled(Rule::OsGetcwd) {
+                    flake8_use_pathlib::rules::os_getcwd(checker, call, segments);
+                }
                 if checker.is_rule_enabled(Rule::PathConstructorCurrentDirectory) {
                     flake8_use_pathlib::rules::path_constructor_current_directory(
                         checker, call, segments,

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -2770,11 +2770,10 @@ impl<'a> Checker<'a> {
 
                         self.semantic.restore(snapshot);
 
-                        if self.semantic.in_typing_only_annotation() {
-                            if self.is_rule_enabled(Rule::QuotedAnnotation) {
-                                pyupgrade::rules::quoted_annotation(self, annotation, range);
-                            }
+                        if self.is_rule_enabled(Rule::QuotedAnnotation) {
+                            pyupgrade::rules::quoted_annotation(self, annotation, range);
                         }
+
                         if self.source_type.is_stub() {
                             if self.is_rule_enabled(Rule::QuotedAnnotationInStub) {
                                 flake8_pyi::rules::quoted_annotation_in_stub(

crates/ruff_linter/src/codes.rs

@@ -928,7 +928,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8UsePathlib, "106") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsRmdir),
         (Flake8UsePathlib, "107") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsRemove),
         (Flake8UsePathlib, "108") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsUnlink),
-        (Flake8UsePathlib, "109") => (RuleGroup::Stable, rules::flake8_use_pathlib::violations::OsGetcwd),
+        (Flake8UsePathlib, "109") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsGetcwd),
         (Flake8UsePathlib, "110") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathExists),
         (Flake8UsePathlib, "111") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathExpanduser),
         (Flake8UsePathlib, "112") => (RuleGroup::Stable, rules::flake8_use_pathlib::rules::OsPathIsdir),

crates/ruff_linter/src/importer/insertion.rs

@@ -288,7 +288,7 @@ fn match_docstring_end(body: &[Stmt]) -> Option<TextSize> {
 fn match_semicolon(s: &str) -> Option<TextSize> {
     for (offset, c) in s.char_indices() {
         match c {
-            ' ' | '\t' => continue,
+            _ if is_python_whitespace(c) => continue,
             ';' => return Some(TextSize::try_from(offset).unwrap()),
             _ => break,
         }

crates/ruff_linter/src/importer/mod.rs

@@ -527,6 +527,17 @@ impl<'a> Importer<'a> {
             None
         }
     }
+
+    /// Add a `from __future__ import annotations` import.
+    pub(crate) fn add_future_import(&self) -> Edit {
+        let import = &NameImport::ImportFrom(MemberNameImport::member(
+            "__future__".to_string(),
+            "annotations".to_string(),
+        ));
+        // Note that `TextSize::default` should ensure that the import is added at the very
+        // beginning of the file via `Insertion::start_of_file`.
+        self.add_import(import, TextSize::default())
+    }
 }
 
 /// An edit to the top-level of a module, making it available at runtime.

crates/ruff_linter/src/message/junit.rs

@@ -1,117 +0,0 @@
-use std::io::Write;
-use std::path::Path;
-
-use quick_junit::{NonSuccessKind, Report, TestCase, TestCaseStatus, TestSuite, XmlString};
-
-use ruff_db::diagnostic::Diagnostic;
-use ruff_source_file::LineColumn;
-
-use crate::message::{Emitter, EmitterContext, MessageWithLocation, group_diagnostics_by_filename};
-
-#[derive(Default)]
-pub struct JunitEmitter;
-
-impl Emitter for JunitEmitter {
-    fn emit(
-        &mut self,
-        writer: &mut dyn Write,
-        diagnostics: &[Diagnostic],
-        context: &EmitterContext,
-    ) -> anyhow::Result<()> {
-        let mut report = Report::new("ruff");
-
-        if diagnostics.is_empty() {
-            let mut test_suite = TestSuite::new("ruff");
-            test_suite
-                .extra
-                .insert(XmlString::new("package"), XmlString::new("org.ruff"));
-            let mut case = TestCase::new("No errors found", TestCaseStatus::success());
-            case.set_classname("ruff");
-            test_suite.add_test_case(case);
-            report.add_test_suite(test_suite);
-        } else {
-            for (filename, messages) in group_diagnostics_by_filename(diagnostics) {
-                let mut test_suite = TestSuite::new(&filename);
-                test_suite
-                    .extra
-                    .insert(XmlString::new("package"), XmlString::new("org.ruff"));
-
-                for message in messages {
-                    let MessageWithLocation {
-                        message,
-                        start_location,
-                    } = message;
-                    let mut status = TestCaseStatus::non_success(NonSuccessKind::Failure);
-                    status.set_message(message.body());
-                    let location = if context.is_notebook(&message.expect_ruff_filename()) {
-                        // We can't give a reasonable location for the structured formats,
-                        // so we show one that's clearly a fallback
-                        LineColumn::default()
-                    } else {
-                        start_location
-                    };
-
-                    status.set_description(format!(
-                        "line {row}, col {col}, {body}",
-                        row = location.line,
-                        col = location.column,
-                        body = message.body()
-                    ));
-                    let mut case = TestCase::new(
-                        if let Some(code) = message.secondary_code() {
-                            format!("org.ruff.{code}")
-                        } else {
-                            "org.ruff".to_string()
-                        },
-                        status,
-                    );
-                    let file_path = Path::new(&*filename);
-                    let file_stem = file_path.file_stem().unwrap().to_str().unwrap();
-                    let classname = file_path.parent().unwrap().join(file_stem);
-                    case.set_classname(classname.to_str().unwrap());
-                    case.extra.insert(
-                        XmlString::new("line"),
-                        XmlString::new(location.line.to_string()),
-                    );
-                    case.extra.insert(
-                        XmlString::new("column"),
-                        XmlString::new(location.column.to_string()),
-                    );
-
-                    test_suite.add_test_case(case);
-                }
-                report.add_test_suite(test_suite);
-            }
-        }
-
-        report.serialize(writer)?;
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use insta::assert_snapshot;
-
-    use crate::message::JunitEmitter;
-    use crate::message::tests::{
-        capture_emitter_output, create_diagnostics, create_syntax_error_diagnostics,
-    };
-
-    #[test]
-    fn output() {
-        let mut emitter = JunitEmitter;
-        let content = capture_emitter_output(&mut emitter, &create_diagnostics());
-
-        assert_snapshot!(content);
-    }
-
-    #[test]
-    fn syntax_errors() {
-        let mut emitter = JunitEmitter;
-        let content = capture_emitter_output(&mut emitter, &create_syntax_error_diagnostics());
-
-        assert_snapshot!(content);
-    }
-}

crates/ruff_linter/src/message/mod.rs

@@ -14,7 +14,6 @@ use ruff_db::files::File;
 pub use github::GithubEmitter;
 pub use gitlab::GitlabEmitter;
 pub use grouped::GroupedEmitter;
-pub use junit::JunitEmitter;
 use ruff_notebook::NotebookIndex;
 use ruff_source_file::{LineColumn, SourceFile};
 use ruff_text_size::{Ranged, TextRange, TextSize};
@@ -28,7 +27,6 @@ mod diff;
 mod github;
 mod gitlab;
 mod grouped;
-mod junit;
 mod sarif;
 mod text;
 

crates/ruff_linter/src/preview.rs

@@ -134,6 +134,11 @@ pub(crate) const fn is_fix_os_path_dirname_enabled(settings: &LinterSettings) ->
     settings.preview.is_enabled()
 }
 
+// https://github.com/astral-sh/ruff/pull/19245
+pub(crate) const fn is_fix_os_getcwd_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}
+
 // https://github.com/astral-sh/ruff/pull/11436
 // https://github.com/astral-sh/ruff/pull/11168
 pub(crate) const fn is_dunder_init_fix_unused_import_enabled(settings: &LinterSettings) -> bool {
@@ -195,3 +200,8 @@ pub(crate) const fn is_safe_super_call_with_parameters_fix_enabled(
 pub(crate) const fn is_assert_raises_exception_call_enabled(settings: &LinterSettings) -> bool {
     settings.preview.is_enabled()
 }
+
+// https://github.com/astral-sh/ruff/pull/19100
+pub(crate) const fn is_add_future_annotations_imports_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}

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

@@ -2,8 +2,7 @@ use std::fmt;
 
 use ruff_macros::{ViolationMetadata, derive_message_formats};
 use ruff_python_ast::Expr;
-use ruff_python_semantic::{MemberNameImport, NameImport};
-use ruff_text_size::{Ranged, TextSize};
+use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::{AlwaysFixableViolation, Fix};
@@ -85,15 +84,7 @@ impl AlwaysFixableViolation for FutureRequiredTypeAnnotation {
 
 /// FA102
 pub(crate) fn future_required_type_annotation(checker: &Checker, expr: &Expr, reason: Reason) {
-    let mut diagnostic =
-        checker.report_diagnostic(FutureRequiredTypeAnnotation { reason }, expr.range());
-    let required_import = NameImport::ImportFrom(MemberNameImport::member(
-        "__future__".to_string(),
-        "annotations".to_string(),
-    ));
-    diagnostic.set_fix(Fix::unsafe_edit(
-        checker
-            .importer()
-            .add_import(&required_import, TextSize::default()),
-    ));
+    checker
+        .report_diagnostic(FutureRequiredTypeAnnotation { reason }, expr.range())
+        .set_fix(Fix::unsafe_edit(checker.importer().add_future_import()));
 }

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

@@ -1,12 +1,10 @@
-use ruff_diagnostics::Fix;
 use ruff_python_ast::Expr;
 
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-use ruff_python_semantic::{MemberNameImport, NameImport};
 use ruff_text_size::Ranged;
 
-use crate::AlwaysFixableViolation;
 use crate::checkers::ast::Checker;
+use crate::{AlwaysFixableViolation, Fix};
 
 /// ## What it does
 /// Checks for missing `from __future__ import annotations` imports upon
@@ -95,15 +93,7 @@ pub(crate) fn future_rewritable_type_annotation(checker: &Checker, expr: &Expr)
 
     let Some(name) = name else { return };
 
-    let import = &NameImport::ImportFrom(MemberNameImport::member(
-        "__future__".to_string(),
-        "annotations".to_string(),
-    ));
     checker
         .report_diagnostic(FutureRewritableTypeAnnotation { name }, expr.range())
-        .set_fix(Fix::unsafe_edit(
-            checker
-                .importer()
-                .add_import(import, ruff_text_size::TextSize::default()),
-        ));
+        .set_fix(Fix::unsafe_edit(checker.importer().add_future_import()));
 }

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

@@ -8,41 +8,110 @@ use ruff_python_ast::{self as ast, Decorator, Expr, StringLiteralFlags};
 use ruff_python_codegen::{Generator, Stylist};
 use ruff_python_parser::typing::parse_type_annotation;
 use ruff_python_semantic::{
-    Binding, BindingKind, Modules, NodeId, ResolvedReference, ScopeKind, SemanticModel, analyze,
+    Binding, BindingKind, Modules, NodeId, ScopeKind, SemanticModel, analyze,
 };
 use ruff_text_size::{Ranged, TextRange};
 
 use crate::Edit;
 use crate::Locator;
-use crate::rules::flake8_type_checking::settings::Settings;
+use crate::settings::LinterSettings;
 
-/// Returns `true` if the [`ResolvedReference`] is in a typing-only context _or_ a runtime-evaluated
-/// context (with quoting enabled).
-pub(crate) fn is_typing_reference(reference: &ResolvedReference, settings: &Settings) -> bool {
-    reference.in_type_checking_block()
-        // if we're not in a type checking block, we necessarily need to be within a
-        // type definition to be considered a typing reference
-        || (reference.in_type_definition()
-            && (reference.in_typing_only_annotation()
-                || reference.in_string_type_definition()
-                || (settings.quote_annotations && reference.in_runtime_evaluated_annotation())))
+/// Represents the kind of an existing or potential typing-only annotation.
+///
+/// Note that the order of variants is important here. `Runtime` has the highest precedence when
+/// calling [`TypingReference::combine`] on two references, followed by `Future`, `Quote`, and
+/// `TypingOnly` with the lowest precedence.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) enum TypingReference {
+    /// The reference is in a runtime-evaluated context.
+    Runtime,
+    /// The reference is in a runtime-evaluated context, but the
+    /// `lint.future-annotations` setting is enabled.
+    ///
+    /// This takes precedence if both quoting and future imports are enabled.
+    Future,
+    /// The reference is in a runtime-evaluated context, but the
+    /// `lint.flake8-type-checking.quote-annotations` setting is enabled.
+    Quote,
+    /// The reference is in a typing-only context.
+    TypingOnly,
+}
+
+impl TypingReference {
+    /// Determine the kind of [`TypingReference`] for all references to a binding.
+    pub(crate) fn from_references(
+        binding: &Binding,
+        semantic: &SemanticModel,
+        settings: &LinterSettings,
+    ) -> Self {
+        let references = binding
+            .references()
+            .map(|reference_id| semantic.reference(reference_id));
+        let mut kind = Self::TypingOnly;
+        for reference in references {
+            if reference.in_type_checking_block() {
+                kind = kind.combine(Self::TypingOnly);
+                continue;
+            }
+
+            // if we're not in a type checking block, we necessarily need to be within a
+            // type definition to be considered a typing reference
+            if !reference.in_type_definition() {
+                return Self::Runtime;
+            }
+
+            if reference.in_typing_only_annotation() || reference.in_string_type_definition() {
+                kind = kind.combine(Self::TypingOnly);
+                continue;
+            }
+
+            // prefer `from __future__ import annotations` to quoting
+            if settings.future_annotations()
+                && !reference.in_typing_only_annotation()
+                && reference.in_runtime_evaluated_annotation()
+            {
+                kind = kind.combine(Self::Future);
+                continue;
+            }
+
+            if settings.flake8_type_checking.quote_annotations
+                && reference.in_runtime_evaluated_annotation()
+            {
+                kind = kind.combine(Self::Quote);
+                continue;
+            }
+
+            return Self::Runtime;
+        }
+
+        kind
+    }
+
+    /// Logically combine two `TypingReference`s into one.
+    ///
+    /// `TypingReference::Runtime` has the highest precedence, followed by
+    /// `TypingReference::Future`, `TypingReference::Quote`, and then `TypingReference::TypingOnly`.
+    fn combine(self, other: TypingReference) -> TypingReference {
+        self.min(other)
+    }
+
+    fn is_runtime(self) -> bool {
+        matches!(self, Self::Runtime)
+    }
 }
 
 /// Returns `true` if the [`Binding`] represents a runtime-required import.
 pub(crate) fn is_valid_runtime_import(
     binding: &Binding,
     semantic: &SemanticModel,
-    settings: &Settings,
+    settings: &LinterSettings,
 ) -> bool {
     if matches!(
         binding.kind,
         BindingKind::Import(..) | BindingKind::FromImport(..) | BindingKind::SubmoduleImport(..)
     ) {
         binding.context.is_runtime()
-            && binding
-                .references()
-                .map(|reference_id| semantic.reference(reference_id))
-                .any(|reference| !is_typing_reference(reference, settings))
+            && TypingReference::from_references(binding, semantic, settings).is_runtime()
     } else {
         false
     }

crates/ruff_linter/src/rules/flake8_type_checking/imports.rs

@@ -13,6 +13,8 @@ pub(crate) struct ImportBinding<'a> {
     pub(crate) range: TextRange,
     /// The range of the import's parent statement.
     pub(crate) parent_range: Option<TextRange>,
+    /// Whether the binding needs `from __future__ import annotations` to be imported.
+    pub(crate) needs_future_import: bool,
 }
 
 impl Ranged for ImportBinding<'_> {

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

@@ -9,10 +9,12 @@ mod tests {
     use std::path::Path;
 
     use anyhow::Result;
+    use itertools::Itertools;
     use ruff_python_ast::PythonVersion;
     use test_case::test_case;
 
     use crate::registry::{Linter, Rule};
+    use crate::settings::types::PreviewMode;
     use crate::test::{test_path, test_snippet};
     use crate::{assert_diagnostics, settings};
 
@@ -64,6 +66,40 @@ mod tests {
         Ok(())
     }
 
+    #[test_case(&[Rule::TypingOnlyFirstPartyImport], Path::new("TC001.py"))]
+    #[test_case(&[Rule::TypingOnlyThirdPartyImport], Path::new("TC002.py"))]
+    #[test_case(&[Rule::TypingOnlyStandardLibraryImport], Path::new("TC003.py"))]
+    #[test_case(
+        &[
+            Rule::TypingOnlyFirstPartyImport,
+            Rule::TypingOnlyThirdPartyImport,
+            Rule::TypingOnlyStandardLibraryImport,
+        ],
+        Path::new("TC001-3_future.py")
+    )]
+    #[test_case(&[Rule::TypingOnlyFirstPartyImport], Path::new("TC001_future.py"))]
+    #[test_case(&[Rule::TypingOnlyFirstPartyImport], Path::new("TC001_future_present.py"))]
+    fn add_future_import(rules: &[Rule], path: &Path) -> Result<()> {
+        let name = rules.iter().map(Rule::noqa_code).join("-");
+        let snapshot = format!("add_future_import__{}_{}", name, path.to_string_lossy());
+        let diagnostics = test_path(
+            Path::new("flake8_type_checking").join(path).as_path(),
+            &settings::LinterSettings {
+                future_annotations: true,
+                preview: PreviewMode::Enabled,
+                // also enable quoting annotations to check the interaction. the future import
+                // should take precedence.
+                flake8_type_checking: super::settings::Settings {
+                    quote_annotations: true,
+                    ..Default::default()
+                },
+                ..settings::LinterSettings::for_rules(rules.iter().copied())
+            },
+        )?;
+        assert_diagnostics!(snapshot, diagnostics);
+        Ok(())
+    }
+
     // we test these rules as a pair, since they're opposites of one another
     // so we want to make sure their fixes are not going around in circles.
     #[test_case(Rule::UnquotedTypeAlias, Path::new("TC007.py"))]

crates/ruff_linter/src/rules/flake8_type_checking/rules/runtime_import_in_type_checking_block.rs

@@ -139,6 +139,7 @@ pub(crate) fn runtime_import_in_type_checking_block(checker: &Checker, scope: &S
                 binding,
                 range: binding.range(),
                 parent_range: binding.parent_range(checker.semantic()),
+                needs_future_import: false, // TODO(brent) See #19359.
             };
 
             if checker.rule_is_ignored(Rule::RuntimeImportInTypeCheckingBlock, import.start())

crates/ruff_linter/src/rules/flake8_type_checking/rules/typing_only_runtime_import.rs

@@ -13,7 +13,7 @@ use crate::fix;
 use crate::importer::ImportedMembers;
 use crate::preview::is_full_path_match_source_strategy_enabled;
 use crate::rules::flake8_type_checking::helpers::{
-    filter_contained, is_typing_reference, quote_annotation,
+    TypingReference, filter_contained, quote_annotation,
 };
 use crate::rules::flake8_type_checking::imports::ImportBinding;
 use crate::rules::isort::categorize::MatchSourceStrategy;
@@ -71,12 +71,19 @@ use crate::{Fix, FixAvailability, Violation};
 /// the criterion for determining whether an import is first-party
 /// is stricter, which could affect whether this lint is triggered vs [`TC001`](https://docs.astral.sh/ruff/rules/typing-only-third-party-import/). See [this FAQ section](https://docs.astral.sh/ruff/faq/#how-does-ruff-determine-which-of-my-imports-are-first-party-third-party-etc) for more details.
 ///
+/// If [`lint.future-annotations`] is set to `true`, `from __future__ import
+/// annotations` will be added if doing so would enable an import to be moved into an `if
+/// TYPE_CHECKING:` block. This takes precedence over the
+/// [`lint.flake8-type-checking.quote-annotations`] setting described above if both settings are
+/// enabled.
+///
 /// ## Options
 /// - `lint.flake8-type-checking.quote-annotations`
 /// - `lint.flake8-type-checking.runtime-evaluated-base-classes`
 /// - `lint.flake8-type-checking.runtime-evaluated-decorators`
 /// - `lint.flake8-type-checking.strict`
 /// - `lint.typing-modules`
+/// - `lint.future-annotations`
 ///
 /// ## References
 /// - [PEP 563: Runtime annotation resolution and `TYPE_CHECKING`](https://peps.python.org/pep-0563/#runtime-annotation-resolution-and-type-checking)
@@ -151,12 +158,19 @@ impl Violation for TypingOnlyFirstPartyImport {
 /// the criterion for determining whether an import is first-party
 /// is stricter, which could affect whether this lint is triggered vs [`TC001`](https://docs.astral.sh/ruff/rules/typing-only-first-party-import/). See [this FAQ section](https://docs.astral.sh/ruff/faq/#how-does-ruff-determine-which-of-my-imports-are-first-party-third-party-etc) for more details.
 ///
+/// If [`lint.future-annotations`] is set to `true`, `from __future__ import
+/// annotations` will be added if doing so would enable an import to be moved into an `if
+/// TYPE_CHECKING:` block. This takes precedence over the
+/// [`lint.flake8-type-checking.quote-annotations`] setting described above if both settings are
+/// enabled.
+///
 /// ## Options
 /// - `lint.flake8-type-checking.quote-annotations`
 /// - `lint.flake8-type-checking.runtime-evaluated-base-classes`
 /// - `lint.flake8-type-checking.runtime-evaluated-decorators`
 /// - `lint.flake8-type-checking.strict`
 /// - `lint.typing-modules`
+/// - `lint.future-annotations`
 ///
 /// ## References
 /// - [PEP 563: Runtime annotation resolution and `TYPE_CHECKING`](https://peps.python.org/pep-0563/#runtime-annotation-resolution-and-type-checking)
@@ -226,12 +240,22 @@ impl Violation for TypingOnlyThirdPartyImport {
 ///     return str(path)
 /// ```
 ///
+/// ## Preview
+///
+/// When [preview](https://docs.astral.sh/ruff/preview/) is enabled, if
+/// [`lint.future-annotations`] is set to `true`, `from __future__ import
+/// annotations` will be added if doing so would enable an import to be moved into an `if
+/// TYPE_CHECKING:` block. This takes precedence over the
+/// [`lint.flake8-type-checking.quote-annotations`] setting described above if both settings are
+/// enabled.
+///
 /// ## Options
 /// - `lint.flake8-type-checking.quote-annotations`
 /// - `lint.flake8-type-checking.runtime-evaluated-base-classes`
 /// - `lint.flake8-type-checking.runtime-evaluated-decorators`
 /// - `lint.flake8-type-checking.strict`
 /// - `lint.typing-modules`
+/// - `lint.future-annotations`
 ///
 /// ## References
 /// - [PEP 563: Runtime annotation resolution and `TYPE_CHECKING`](https://peps.python.org/pep-0563/#runtime-annotation-resolution-and-type-checking)
@@ -271,9 +295,10 @@ pub(crate) fn typing_only_runtime_import(
     for binding_id in scope.binding_ids() {
         let binding = checker.semantic().binding(binding_id);
 
-        // If we're in un-strict mode, don't flag typing-only imports that are
-        // implicitly loaded by way of a valid runtime import.
-        if !checker.settings().flake8_type_checking.strict
+        // If we can't add a `__future__` import and in un-strict mode, don't flag typing-only
+        // imports that are implicitly loaded by way of a valid runtime import.
+        if !checker.settings().future_annotations()
+            && !checker.settings().flake8_type_checking.strict
             && runtime_imports
                 .iter()
                 .any(|import| is_implicit_import(binding, import))
@@ -289,95 +314,102 @@ pub(crate) fn typing_only_runtime_import(
             continue;
         };
 
-        if binding.context.is_runtime()
-            && binding
-                .references()
-                .map(|reference_id| checker.semantic().reference(reference_id))
-                .all(|reference| {
-                    is_typing_reference(reference, &checker.settings().flake8_type_checking)
-                })
-        {
-            let qualified_name = import.qualified_name();
+        if !binding.context.is_runtime() {
+            continue;
+        }
 
-            if is_exempt(
-                &qualified_name.to_string(),
-                &checker
-                    .settings()
-                    .flake8_type_checking
-                    .exempt_modules
-                    .iter()
-                    .map(String::as_str)
-                    .collect::<Vec<_>>(),
-            ) {
-                continue;
-            }
+        let typing_reference =
+            TypingReference::from_references(binding, checker.semantic(), checker.settings());
 
-            let source_name = import.source_name().join(".");
+        let needs_future_import = match typing_reference {
+            TypingReference::Runtime => continue,
+            // We can only get the `Future` variant if `future_annotations` is
+            // enabled, so we can unconditionally set this here.
+            TypingReference::Future => true,
+            TypingReference::TypingOnly | TypingReference::Quote => false,
+        };
 
-            // Categorize the import, using coarse-grained categorization.
-            let match_source_strategy =
-                if is_full_path_match_source_strategy_enabled(checker.settings()) {
-                    MatchSourceStrategy::FullPath
-                } else {
-                    MatchSourceStrategy::Root
-                };
+        let qualified_name = import.qualified_name();
 
-            let import_type = match categorize(
-                &source_name,
-                qualified_name.is_unresolved_import(),
-                &checker.settings().src,
-                checker.package(),
-                checker.settings().isort.detect_same_package,
-                &checker.settings().isort.known_modules,
-                checker.target_version(),
-                checker.settings().isort.no_sections,
-                &checker.settings().isort.section_order,
-                &checker.settings().isort.default_section,
-                match_source_strategy,
-            ) {
-                ImportSection::Known(ImportType::LocalFolder | ImportType::FirstParty) => {
-                    ImportType::FirstParty
-                }
-                ImportSection::Known(ImportType::ThirdParty) | ImportSection::UserDefined(_) => {
-                    ImportType::ThirdParty
-                }
-                ImportSection::Known(ImportType::StandardLibrary) => ImportType::StandardLibrary,
-                ImportSection::Known(ImportType::Future) => {
-                    continue;
-                }
-            };
+        if is_exempt(
+            &qualified_name.to_string(),
+            &checker
+                .settings()
+                .flake8_type_checking
+                .exempt_modules
+                .iter()
+                .map(String::as_str)
+                .collect::<Vec<_>>(),
+        ) {
+            continue;
+        }
 
-            if !checker.is_rule_enabled(rule_for(import_type)) {
-                continue;
-            }
+        let source_name = import.source_name().join(".");
 
-            let Some(node_id) = binding.source else {
-                continue;
-            };
-
-            let import = ImportBinding {
-                import,
-                reference_id,
-                binding,
-                range: binding.range(),
-                parent_range: binding.parent_range(checker.semantic()),
-            };
-
-            if checker.rule_is_ignored(rule_for(import_type), import.start())
-                || import.parent_range.is_some_and(|parent_range| {
-                    checker.rule_is_ignored(rule_for(import_type), parent_range.start())
-                })
-            {
-                ignores_by_statement
-                    .entry((node_id, import_type))
-                    .or_default()
-                    .push(import);
+        // Categorize the import, using coarse-grained categorization.
+        let match_source_strategy =
+            if is_full_path_match_source_strategy_enabled(checker.settings()) {
+                MatchSourceStrategy::FullPath
             } else {
-                errors_by_statement
-                    .entry((node_id, import_type))
-                    .or_default()
-                    .push(import);
+                MatchSourceStrategy::Root
+            };
+
+        let import_type = match categorize(
+            &source_name,
+            qualified_name.is_unresolved_import(),
+            &checker.settings().src,
+            checker.package(),
+            checker.settings().isort.detect_same_package,
+            &checker.settings().isort.known_modules,
+            checker.target_version(),
+            checker.settings().isort.no_sections,
+            &checker.settings().isort.section_order,
+            &checker.settings().isort.default_section,
+            match_source_strategy,
+        ) {
+            ImportSection::Known(ImportType::LocalFolder | ImportType::FirstParty) => {
+                ImportType::FirstParty
             }
+            ImportSection::Known(ImportType::ThirdParty) | ImportSection::UserDefined(_) => {
+                ImportType::ThirdParty
+            }
+            ImportSection::Known(ImportType::StandardLibrary) => ImportType::StandardLibrary,
+            ImportSection::Known(ImportType::Future) => {
+                continue;
+            }
+        };
+
+        if !checker.is_rule_enabled(rule_for(import_type)) {
+            continue;
+        }
+
+        let Some(node_id) = binding.source else {
+            continue;
+        };
+
+        let import = ImportBinding {
+            import,
+            reference_id,
+            binding,
+            range: binding.range(),
+            parent_range: binding.parent_range(checker.semantic()),
+            needs_future_import,
+        };
+
+        if checker.rule_is_ignored(rule_for(import_type), import.start())
+            || import.parent_range.is_some_and(|parent_range| {
+                checker.rule_is_ignored(rule_for(import_type), parent_range.start())
+            })
+        {
+            ignores_by_statement
+                .entry((node_id, import_type))
+                .or_default()
+                .push(import);
+        } else {
+            errors_by_statement
+                .entry((node_id, import_type))
+                .or_default()
+                .push(import);
         }
     }
 
@@ -509,6 +541,8 @@ fn fix_imports(checker: &Checker, node_id: NodeId, imports: &[ImportBinding]) ->
         .min()
         .expect("Expected at least one import");
 
+    let add_future_import = imports.iter().any(|binding| binding.needs_future_import);
+
     // Step 1) Remove the import.
     let remove_import_edit = fix::edits::remove_unused_imports(
         member_names.iter().map(AsRef::as_ref),
@@ -532,37 +566,52 @@ fn fix_imports(checker: &Checker, node_id: NodeId, imports: &[ImportBinding]) ->
         )?
         .into_edits();
 
-    // Step 3) Quote any runtime usages of the referenced symbol.
-    let quote_reference_edits = filter_contained(
-        imports
-            .iter()
-            .flat_map(|ImportBinding { binding, .. }| {
-                binding.references.iter().filter_map(|reference_id| {
-                    let reference = checker.semantic().reference(*reference_id);
-                    if reference.in_runtime_context() {
-                        Some(quote_annotation(
-                            reference.expression_id()?,
-                            checker.semantic(),
-                            checker.stylist(),
-                            checker.locator(),
-                            checker.default_string_flags(),
-                        ))
-                    } else {
-                        None
-                    }
-                })
-            })
-            .collect::<Vec<_>>(),
-    );
+    // Step 3) Either add a `__future__` import or quote any runtime usages of the referenced
+    // symbol.
+    let fix = if add_future_import {
+        let future_import = checker.importer().add_future_import();
 
-    Ok(Fix::unsafe_edits(
-        type_checking_edit,
-        add_import_edit
-            .into_iter()
-            .chain(std::iter::once(remove_import_edit))
-            .chain(quote_reference_edits),
-    )
-    .isolate(Checker::isolation(
+        // The order here is very important. We first need to add the `__future__` import, if
+        // needed, since it's a syntax error to come later. Then `type_checking_edit` imports
+        // `TYPE_CHECKING`, if available. Then we can add and/or remove existing imports.
+        Fix::unsafe_edits(
+            future_import,
+            std::iter::once(type_checking_edit)
+                .chain(add_import_edit)
+                .chain(std::iter::once(remove_import_edit)),
+        )
+    } else {
+        let quote_reference_edits = filter_contained(
+            imports
+                .iter()
+                .flat_map(|ImportBinding { binding, .. }| {
+                    binding.references.iter().filter_map(|reference_id| {
+                        let reference = checker.semantic().reference(*reference_id);
+                        if reference.in_runtime_context() {
+                            Some(quote_annotation(
+                                reference.expression_id()?,
+                                checker.semantic(),
+                                checker.stylist(),
+                                checker.locator(),
+                                checker.default_string_flags(),
+                            ))
+                        } else {
+                            None
+                        }
+                    })
+                })
+                .collect::<Vec<_>>(),
+        );
+        Fix::unsafe_edits(
+            type_checking_edit,
+            add_import_edit
+                .into_iter()
+                .chain(std::iter::once(remove_import_edit))
+                .chain(quote_reference_edits),
+        )
+    };
+
+    Ok(fix.isolate(Checker::isolation(
         checker.semantic().parent_statement_id(node_id),
     )))
 }

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__add_future_import__TC001-TC002-TC003_TC001-3_future.py.snap

@@ -0,0 +1,76 @@
+---
+source: crates/ruff_linter/src/rules/flake8_type_checking/mod.rs
+---
+TC001-3_future.py:1:25: TC003 [*] Move standard library import `collections.Counter` into a type-checking block
+  |
+1 | from collections import Counter
+  |                         ^^^^^^^ TC003
+2 |
+3 | from elsewhere import third_party
+  |
+  = help: Move into type-checking block
+
+ℹ Unsafe fix
+1     |-from collections import Counter
+   1  |+from __future__ import annotations
+2  2  | 
+3  3  | from elsewhere import third_party
+4  4  | 
+5  5  | from . import first_party
+   6  |+from typing import TYPE_CHECKING
+   7  |+
+   8  |+if TYPE_CHECKING:
+   9  |+    from collections import Counter
+6  10 | 
+7  11 | 
+8  12 | def f(x: first_party.foo): ...
+
+TC001-3_future.py:3:23: TC002 [*] Move third-party import `elsewhere.third_party` into a type-checking block
+  |
+1 | from collections import Counter
+2 |
+3 | from elsewhere import third_party
+  |                       ^^^^^^^^^^^ TC002
+4 |
+5 | from . import first_party
+  |
+  = help: Move into type-checking block
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | from collections import Counter
+2  3  | 
+3     |-from elsewhere import third_party
+4  4  | 
+5  5  | from . import first_party
+   6  |+from typing import TYPE_CHECKING
+   7  |+
+   8  |+if TYPE_CHECKING:
+   9  |+    from elsewhere import third_party
+6  10 | 
+7  11 | 
+8  12 | def f(x: first_party.foo): ...
+
+TC001-3_future.py:5:15: TC001 [*] Move application import `.first_party` into a type-checking block
+  |
+3 | from elsewhere import third_party
+4 |
+5 | from . import first_party
+  |               ^^^^^^^^^^^ TC001
+  |
+  = help: Move into type-checking block
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | from collections import Counter
+2  3  | 
+3  4  | from elsewhere import third_party
+4  5  | 
+5     |-from . import first_party
+   6  |+from typing import TYPE_CHECKING
+   7  |+
+   8  |+if TYPE_CHECKING:
+   9  |+    from . import first_party
+6  10 | 
+7  11 | 
+8  12 | def f(x: first_party.foo): ...

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__add_future_import__TC001_TC001.py.snap

@@ -0,0 +1,32 @@
+---
+source: crates/ruff_linter/src/rules/flake8_type_checking/mod.rs
+---
+TC001.py:20:19: TC001 [*] Move application import `.TYP001` into a type-checking block
+   |
+19 | def f():
+20 |     from . import TYP001
+   |                   ^^^^^^ TC001
+21 |
+22 |     x: TYP001
+   |
+   = help: Move into type-checking block
+
+ℹ Unsafe fix
+2  2  | 
+3  3  | For typing-only import detection tests, see `TC002.py`.
+4  4  | """
+   5  |+from typing import TYPE_CHECKING
+   6  |+
+   7  |+if TYPE_CHECKING:
+   8  |+    from . import TYP001
+5  9  | 
+6  10 | 
+7  11 | def f():
+--------------------------------------------------------------------------------
+17 21 | 
+18 22 | 
+19 23 | def f():
+20    |-    from . import TYP001
+21 24 | 
+22 25 |     x: TYP001
+23 26 |

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__add_future_import__TC001_TC001_future.py.snap

@@ -0,0 +1,56 @@
+---
+source: crates/ruff_linter/src/rules/flake8_type_checking/mod.rs
+---
+TC001_future.py:2:19: TC001 [*] Move application import `.first_party` into a type-checking block
+  |
+1 | def f():
+2 |     from . import first_party
+  |                   ^^^^^^^^^^^ TC001
+3 |
+4 |     def f(x: first_party.foo): ...
+  |
+  = help: Move into type-checking block
+
+ℹ Unsafe fix
+1   |-def f():
+  1 |+from __future__ import annotations
+  2 |+from typing import TYPE_CHECKING
+  3 |+
+  4 |+if TYPE_CHECKING:
+2 5 |     from . import first_party
+  6 |+def f():
+3 7 | 
+4 8 |     def f(x: first_party.foo): ...
+5 9 | 
+
+TC001_future.py:57:19: TC001 [*] Move application import `.foo` into a type-checking block
+   |
+56 | def n():
+57 |     from . import foo
+   |                   ^^^ TC001
+58 |
+59 |     def f(x: Union[foo.Ty, int]): ...
+   |
+   = help: Move into type-checking block
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | def f():
+2  3  |     from . import first_party
+3  4  | 
+--------------------------------------------------------------------------------
+50 51 | 
+51 52 | 
+52 53 | # unions
+53    |-from typing import Union
+   54 |+from typing import Union, TYPE_CHECKING
+54 55 | 
+   56 |+if TYPE_CHECKING:
+   57 |+    from . import foo
+   58 |+
+55 59 | 
+56 60 | def n():
+57    |-    from . import foo
+58 61 | 
+59 62 |     def f(x: Union[foo.Ty, int]): ...
+60 63 |     def g(x: foo.Ty | int): ...

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__add_future_import__TC001_TC001_future_present.py.snap

@@ -0,0 +1,23 @@
+---
+source: crates/ruff_linter/src/rules/flake8_type_checking/mod.rs
+---
+TC001_future_present.py:3:15: TC001 [*] Move application import `.first_party` into a type-checking block
+  |
+1 | from __future__ import annotations
+2 |
+3 | from . import first_party
+  |               ^^^^^^^^^^^ TC001
+  |
+  = help: Move into type-checking block
+
+ℹ Unsafe fix
+1 1 | from __future__ import annotations
+2 2 | 
+3   |-from . import first_party
+  3 |+from typing import TYPE_CHECKING
+  4 |+
+  5 |+if TYPE_CHECKING:
+  6 |+    from . import first_party
+4 7 | 
+5 8 | 
+6 9 | def f(x: first_party.foo): ...

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__add_future_import__TC002_TC002.py.snap

@@ -0,0 +1,251 @@
+---
+source: crates/ruff_linter/src/rules/flake8_type_checking/mod.rs
+---
+TC002.py:5:22: TC002 [*] Move third-party import `pandas` into a type-checking block
+  |
+4 | def f():
+5 |     import pandas as pd  # TC002
+  |                      ^^ TC002
+6 |
+7 |     x: pd.DataFrame
+  |
+  = help: Move into type-checking block
+
+ℹ Unsafe fix
+1 1 | """Tests to determine accurate detection of typing-only imports."""
+  2 |+from typing import TYPE_CHECKING
+  3 |+
+  4 |+if TYPE_CHECKING:
+  5 |+    import pandas as pd
+2 6 | 
+3 7 | 
+4 8 | def f():
+5   |-    import pandas as pd  # TC002
+6 9 | 
+7 10 |     x: pd.DataFrame
+8 11 | 
+
+TC002.py:11:24: TC002 [*] Move third-party import `pandas.DataFrame` into a type-checking block
+   |
+10 | def f():
+11 |     from pandas import DataFrame  # TC002
+   |                        ^^^^^^^^^ TC002
+12 |
+13 |     x: DataFrame
+   |
+   = help: Move into type-checking block
+
+ℹ Unsafe fix
+1  1  | """Tests to determine accurate detection of typing-only imports."""
+   2  |+from typing import TYPE_CHECKING
+   3  |+
+   4  |+if TYPE_CHECKING:
+   5  |+    from pandas import DataFrame
+2  6  | 
+3  7  | 
+4  8  | def f():
+--------------------------------------------------------------------------------
+8  12 | 
+9  13 | 
+10 14 | def f():
+11    |-    from pandas import DataFrame  # TC002
+12 15 | 
+13 16 |     x: DataFrame
+14 17 | 
+
+TC002.py:17:37: TC002 [*] Move third-party import `pandas.DataFrame` into a type-checking block
+   |
+16 | def f():
+17 |     from pandas import DataFrame as df  # TC002
+   |                                     ^^ TC002
+18 |
+19 |     x: df
+   |
+   = help: Move into type-checking block
+
+ℹ Unsafe fix
+1  1  | """Tests to determine accurate detection of typing-only imports."""
+   2  |+from typing import TYPE_CHECKING
+   3  |+
+   4  |+if TYPE_CHECKING:
+   5  |+    from pandas import DataFrame as df
+2  6  | 
+3  7  | 
+4  8  | def f():
+--------------------------------------------------------------------------------
+14 18 | 
+15 19 | 
+16 20 | def f():
+17    |-    from pandas import DataFrame as df  # TC002
+18 21 | 
+19 22 |     x: df
+20 23 | 
+
+TC002.py:23:22: TC002 [*] Move third-party import `pandas` into a type-checking block
+   |
+22 | def f():
+23 |     import pandas as pd  # TC002
+   |                      ^^ TC002
+24 |
+25 |     x: pd.DataFrame = 1
+   |
+   = help: Move into type-checking block
+
+ℹ Unsafe fix
+1  1  | """Tests to determine accurate detection of typing-only imports."""
+   2  |+from typing import TYPE_CHECKING
+   3  |+
+   4  |+if TYPE_CHECKING:
+   5  |+    import pandas as pd
+2  6  | 
+3  7  | 
+4  8  | def f():
+--------------------------------------------------------------------------------
+20 24 | 
+21 25 | 
+22 26 | def f():
+23    |-    import pandas as pd  # TC002
+24 27 | 
+25 28 |     x: pd.DataFrame = 1
+26 29 | 
+
+TC002.py:29:24: TC002 [*] Move third-party import `pandas.DataFrame` into a type-checking block
+   |
+28 | def f():
+29 |     from pandas import DataFrame  # TC002
+   |                        ^^^^^^^^^ TC002
+30 |
+31 |     x: DataFrame = 2
+   |
+   = help: Move into type-checking block
+
+ℹ Unsafe fix
+1  1  | """Tests to determine accurate detection of typing-only imports."""
+   2  |+from typing import TYPE_CHECKING
+   3  |+
+   4  |+if TYPE_CHECKING:
+   5  |+    from pandas import DataFrame
+2  6  | 
+3  7  | 
+4  8  | def f():
+--------------------------------------------------------------------------------
+26 30 | 
+27 31 | 
+28 32 | def f():
+29    |-    from pandas import DataFrame  # TC002
+30 33 | 
+31 34 |     x: DataFrame = 2
+32 35 | 
+
+TC002.py:35:37: TC002 [*] Move third-party import `pandas.DataFrame` into a type-checking block
+   |
+34 | def f():
+35 |     from pandas import DataFrame as df  # TC002
+   |                                     ^^ TC002
+36 |
+37 |     x: df = 3
+   |
+   = help: Move into type-checking block
+
+ℹ Unsafe fix
+1  1  | """Tests to determine accurate detection of typing-only imports."""
+   2  |+from typing import TYPE_CHECKING
+   3  |+
+   4  |+if TYPE_CHECKING:
+   5  |+    from pandas import DataFrame as df
+2  6  | 
+3  7  | 
+4  8  | def f():
+--------------------------------------------------------------------------------
+32 36 | 
+33 37 | 
+34 38 | def f():
+35    |-    from pandas import DataFrame as df  # TC002
+36 39 | 
+37 40 |     x: df = 3
+38 41 | 
+
+TC002.py:41:22: TC002 [*] Move third-party import `pandas` into a type-checking block
+   |
+40 | def f():
+41 |     import pandas as pd  # TC002
+   |                      ^^ TC002
+42 |
+43 |     x: "pd.DataFrame" = 1
+   |
+   = help: Move into type-checking block
+
+ℹ Unsafe fix
+1  1  | """Tests to determine accurate detection of typing-only imports."""
+   2  |+from typing import TYPE_CHECKING
+   3  |+
+   4  |+if TYPE_CHECKING:
+   5  |+    import pandas as pd
+2  6  | 
+3  7  | 
+4  8  | def f():
+--------------------------------------------------------------------------------
+38 42 | 
+39 43 | 
+40 44 | def f():
+41    |-    import pandas as pd  # TC002
+42 45 | 
+43 46 |     x: "pd.DataFrame" = 1
+44 47 | 
+
+TC002.py:47:22: TC002 [*] Move third-party import `pandas` into a type-checking block
+   |
+46 | def f():
+47 |     import pandas as pd  # TC002
+   |                      ^^ TC002
+48 |
+49 |     x = dict["pd.DataFrame", "pd.DataFrame"]
+   |
+   = help: Move into type-checking block
+
+ℹ Unsafe fix
+1  1  | """Tests to determine accurate detection of typing-only imports."""
+   2  |+from typing import TYPE_CHECKING
+   3  |+
+   4  |+if TYPE_CHECKING:
+   5  |+    import pandas as pd
+2  6  | 
+3  7  | 
+4  8  | def f():
+--------------------------------------------------------------------------------
+44 48 | 
+45 49 | 
+46 50 | def f():
+47    |-    import pandas as pd  # TC002
+48 51 | 
+49 52 |     x = dict["pd.DataFrame", "pd.DataFrame"]
+50 53 | 
+
+TC002.py:172:24: TC002 [*] Move third-party import `module.Member` into a type-checking block
+    |
+170 |     global Member
+171 |
+172 |     from module import Member
+    |                        ^^^^^^ TC002
+173 |
+174 |     x: Member = 1
+    |
+    = help: Move into type-checking block
+
+ℹ Unsafe fix
+1   1   | """Tests to determine accurate detection of typing-only imports."""
+    2   |+from typing import TYPE_CHECKING
+    3   |+
+    4   |+if TYPE_CHECKING:
+    5   |+    from module import Member
+2   6   | 
+3   7   | 
+4   8   | def f():
+--------------------------------------------------------------------------------
+169 173 | def f():
+170 174 |     global Member
+171 175 | 
+172     |-    from module import Member
+173 176 | 
+174 177 |     x: Member = 1
+175 178 |

crates/ruff_linter/src/rules/flake8_type_checking/snapshots/ruff_linter__rules__flake8_type_checking__tests__add_future_import__TC003_TC003.py.snap

@@ -0,0 +1,28 @@
+---
+source: crates/ruff_linter/src/rules/flake8_type_checking/mod.rs
+---
+TC003.py:8:12: TC003 [*] Move standard library import `os` into a type-checking block
+   |
+ 7 | def f():
+ 8 |     import os
+   |            ^^ TC003
+ 9 |
+10 |     x: os
+   |
+   = help: Move into type-checking block
+
+ℹ Unsafe fix
+2  2  | 
+3  3  | For typing-only import detection tests, see `TC002.py`.
+4  4  | """
+   5  |+from typing import TYPE_CHECKING
+   6  |+
+   7  |+if TYPE_CHECKING:
+   8  |+    import os
+5  9  | 
+6  10 | 
+7  11 | def f():
+8     |-    import os
+9  12 | 
+10 13 |     x: os
+11 14 |

crates/ruff_linter/src/rules/flake8_use_pathlib/rules/invalid_pathlib_with_suffix.rs

@@ -3,7 +3,7 @@ use crate::{Edit, Fix, FixAvailability, Violation};
 use ruff_macros::{ViolationMetadata, derive_message_formats};
 use ruff_python_ast::{self as ast, PythonVersion, StringFlags};
 use ruff_python_semantic::SemanticModel;
-use ruff_python_semantic::analyze::typing;
+use ruff_python_semantic::analyze::typing::{self, PathlibPathChecker, TypeChecker};
 use ruff_text_size::Ranged;
 
 /// ## What it does
@@ -141,12 +141,13 @@ fn is_path_with_suffix_call(semantic: &SemanticModel, func: &ast::Expr) -> bool
         return false;
     }
 
-    let ast::Expr::Name(name) = &**value else {
-        return false;
-    };
-    let Some(binding) = semantic.only_binding(name).map(|id| semantic.binding(id)) else {
-        return false;
-    };
-
-    typing::is_pathlib_path(binding, semantic)
+    match &**value {
+        ast::Expr::Name(name) => {
+            let Some(binding) = semantic.only_binding(name).map(|id| semantic.binding(id)) else {
+                return false;
+            };
+            typing::is_pathlib_path(binding, semantic)
+        }
+        expr => PathlibPathChecker::match_initializer(expr, semantic),
+    }
 }

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

@@ -1,5 +1,6 @@
 pub(crate) use glob_rule::*;
 pub(crate) use invalid_pathlib_with_suffix::*;
+pub(crate) use os_getcwd::*;
 pub(crate) use os_path_abspath::*;
 pub(crate) use os_path_basename::*;
 pub(crate) use os_path_dirname::*;
@@ -23,6 +24,7 @@ pub(crate) use replaceable_by_pathlib::*;
 
 mod glob_rule;
 mod invalid_pathlib_with_suffix;
+mod os_getcwd;
 mod os_path_abspath;
 mod os_path_basename;
 mod os_path_dirname;

crates/ruff_linter/src/rules/flake8_use_pathlib/rules/os_getcwd.rs

@@ -0,0 +1,100 @@
+use crate::checkers::ast::Checker;
+use crate::importer::ImportRequest;
+use crate::preview::is_fix_os_getcwd_enabled;
+use crate::{FixAvailability, Violation};
+use ruff_diagnostics::{Applicability, Edit, Fix};
+use ruff_macros::{ViolationMetadata, derive_message_formats};
+use ruff_python_ast::ExprCall;
+use ruff_text_size::Ranged;
+
+/// ## What it does
+/// Checks for uses of `os.getcwd` and `os.getcwdb`.
+///
+/// ## Why is this bad?
+/// `pathlib` offers a high-level API for path manipulation, as compared to
+/// the lower-level API offered by `os`. When possible, using `Path` object
+/// methods such as `Path.cwd()` can improve readability over the `os`
+/// module's counterparts (e.g., `os.getcwd()`).
+///
+/// ## Examples
+/// ```python
+/// import os
+///
+/// cwd = os.getcwd()
+/// ```
+///
+/// Use instead:
+/// ```python
+/// from pathlib import Path
+///
+/// cwd = Path.cwd()
+/// ```
+///
+/// ## Known issues
+/// While using `pathlib` can improve the readability and type safety of your code,
+/// it can be less performant than the lower-level alternatives that work directly with strings,
+/// especially on older versions of Python.
+///
+/// ## Fix Safety
+/// This rule's fix is marked as unsafe if the replacement would remove comments attached to the original expression.
+///
+/// ## References
+/// - [Python documentation: `Path.cwd`](https://docs.python.org/3/library/pathlib.html#pathlib.Path.cwd)
+/// - [Python documentation: `os.getcwd`](https://docs.python.org/3/library/os.html#os.getcwd)
+/// - [Python documentation: `os.getcwdb`](https://docs.python.org/3/library/os.html#os.getcwdb)
+/// - [PEP 428 – The pathlib module – object-oriented filesystem paths](https://peps.python.org/pep-0428/)
+/// - [Correspondence between `os` and `pathlib`](https://docs.python.org/3/library/pathlib.html#correspondence-to-tools-in-the-os-module)
+/// - [Why you should be using pathlib](https://treyhunner.com/2018/12/why-you-should-be-using-pathlib/)
+/// - [No really, pathlib is great](https://treyhunner.com/2019/01/no-really-pathlib-is-great/)
+#[derive(ViolationMetadata)]
+pub(crate) struct OsGetcwd;
+
+impl Violation for OsGetcwd {
+    const FIX_AVAILABILITY: FixAvailability = FixAvailability::Sometimes;
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        "`os.getcwd()` should be replaced by `Path.cwd()`".to_string()
+    }
+
+    fn fix_title(&self) -> Option<String> {
+        Some("Replace with `Path.cwd()`".to_string())
+    }
+}
+
+/// PTH109
+pub(crate) fn os_getcwd(checker: &Checker, call: &ExprCall, segments: &[&str]) {
+    if !matches!(segments, ["os", "getcwd" | "getcwdb"]) {
+        return;
+    }
+
+    let range = call.range();
+    let mut diagnostic = checker.report_diagnostic(OsGetcwd, call.func.range());
+
+    if !call.arguments.is_empty() {
+        return;
+    }
+
+    if is_fix_os_getcwd_enabled(checker.settings()) {
+        diagnostic.try_set_fix(|| {
+            let (import_edit, binding) = checker.importer().get_or_import_symbol(
+                &ImportRequest::import("pathlib", "Path"),
+                call.start(),
+                checker.semantic(),
+            )?;
+
+            let applicability = if checker.comment_ranges().intersects(range) {
+                Applicability::Unsafe
+            } else {
+                Applicability::Safe
+            };
+
+            let replacement = format!("{binding}.cwd()");
+
+            Ok(Fix::applicable_edits(
+                Edit::range_replacement(replacement, range),
+                [import_edit],
+                applicability,
+            ))
+        });
+    }
+}

crates/ruff_linter/src/rules/flake8_use_pathlib/rules/replaceable_by_pathlib.rs

@@ -7,8 +7,8 @@ use crate::checkers::ast::Checker;
 use crate::rules::flake8_use_pathlib::helpers::is_keyword_only_argument_non_default;
 use crate::rules::flake8_use_pathlib::rules::Glob;
 use crate::rules::flake8_use_pathlib::violations::{
-    BuiltinOpen, Joiner, OsChmod, OsGetcwd, OsListdir, OsMakedirs, OsMkdir, OsPathJoin,
-    OsPathSamefile, OsPathSplitext, OsRename, OsReplace, OsStat, OsSymlink, PyPath,
+    BuiltinOpen, Joiner, OsChmod, OsListdir, OsMakedirs, OsMkdir, OsPathJoin, OsPathSamefile,
+    OsPathSplitext, OsRename, OsReplace, OsStat, OsSymlink, PyPath,
 };
 
 pub(crate) fn replaceable_by_pathlib(checker: &Checker, call: &ExprCall) {
@@ -83,10 +83,6 @@ pub(crate) fn replaceable_by_pathlib(checker: &Checker, call: &ExprCall) {
             }
             checker.report_diagnostic_if_enabled(OsReplace, range)
         }
-        // PTH109
-        ["os", "getcwd"] => checker.report_diagnostic_if_enabled(OsGetcwd, range),
-        ["os", "getcwdb"] => checker.report_diagnostic_if_enabled(OsGetcwd, range),
-
         // PTH116
         ["os", "stat"] => {
             // `dir_fd` is not supported by pathlib, so check if it's set to non-default values.

crates/ruff_linter/src/rules/flake8_use_pathlib/snapshots/ruff_linter__rules__flake8_use_pathlib__tests__PTH210_PTH210.py.snap

@@ -536,7 +536,7 @@ PTH210.py:54:1: PTH210 [*] Dotless suffix passed to `.with_suffix()`
    54 |+windows_path.with_suffix(u'.' "json")
 55 55 | windows_path.with_suffix(suffix="js")
 56 56 | 
-57 57 | 
+57 57 | Path().with_suffix(".")
 
 PTH210.py:55:1: PTH210 [*] Dotless suffix passed to `.with_suffix()`
    |
@@ -544,6 +544,8 @@ PTH210.py:55:1: PTH210 [*] Dotless suffix passed to `.with_suffix()`
 54 | windows_path.with_suffix(u'' "json")
 55 | windows_path.with_suffix(suffix="js")
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PTH210
+56 |
+57 | Path().with_suffix(".")
    |
    = help: Add a leading dot
 
@@ -554,5 +556,140 @@ PTH210.py:55:1: PTH210 [*] Dotless suffix passed to `.with_suffix()`
 55    |-windows_path.with_suffix(suffix="js")
    55 |+windows_path.with_suffix(suffix=".js")
 56 56 | 
-57 57 | 
-58 58 | ### No errors
+57 57 | Path().with_suffix(".")
+58 58 | Path().with_suffix("py")
+
+PTH210.py:57:1: PTH210 Invalid suffix passed to `.with_suffix()`
+   |
+55 | windows_path.with_suffix(suffix="js")
+56 |
+57 | Path().with_suffix(".")
+   | ^^^^^^^^^^^^^^^^^^^^^^^ PTH210
+58 | Path().with_suffix("py")
+59 | PosixPath().with_suffix("py")
+   |
+   = help: Remove "." or extend to valid suffix
+
+PTH210.py:58:1: PTH210 [*] Dotless suffix passed to `.with_suffix()`
+   |
+57 | Path().with_suffix(".")
+58 | Path().with_suffix("py")
+   | ^^^^^^^^^^^^^^^^^^^^^^^^ PTH210
+59 | PosixPath().with_suffix("py")
+60 | PurePath().with_suffix("py")
+   |
+   = help: Add a leading dot
+
+ℹ Unsafe fix
+55 55 | windows_path.with_suffix(suffix="js")
+56 56 | 
+57 57 | Path().with_suffix(".")
+58    |-Path().with_suffix("py")
+   58 |+Path().with_suffix(".py")
+59 59 | PosixPath().with_suffix("py")
+60 60 | PurePath().with_suffix("py")
+61 61 | PurePosixPath().with_suffix("py")
+
+PTH210.py:59:1: PTH210 [*] Dotless suffix passed to `.with_suffix()`
+   |
+57 | Path().with_suffix(".")
+58 | Path().with_suffix("py")
+59 | PosixPath().with_suffix("py")
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PTH210
+60 | PurePath().with_suffix("py")
+61 | PurePosixPath().with_suffix("py")
+   |
+   = help: Add a leading dot
+
+ℹ Unsafe fix
+56 56 | 
+57 57 | Path().with_suffix(".")
+58 58 | Path().with_suffix("py")
+59    |-PosixPath().with_suffix("py")
+   59 |+PosixPath().with_suffix(".py")
+60 60 | PurePath().with_suffix("py")
+61 61 | PurePosixPath().with_suffix("py")
+62 62 | PureWindowsPath().with_suffix("py")
+
+PTH210.py:60:1: PTH210 [*] Dotless suffix passed to `.with_suffix()`
+   |
+58 | Path().with_suffix("py")
+59 | PosixPath().with_suffix("py")
+60 | PurePath().with_suffix("py")
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PTH210
+61 | PurePosixPath().with_suffix("py")
+62 | PureWindowsPath().with_suffix("py")
+   |
+   = help: Add a leading dot
+
+ℹ Unsafe fix
+57 57 | Path().with_suffix(".")
+58 58 | Path().with_suffix("py")
+59 59 | PosixPath().with_suffix("py")
+60    |-PurePath().with_suffix("py")
+   60 |+PurePath().with_suffix(".py")
+61 61 | PurePosixPath().with_suffix("py")
+62 62 | PureWindowsPath().with_suffix("py")
+63 63 | WindowsPath().with_suffix("py")
+
+PTH210.py:61:1: PTH210 [*] Dotless suffix passed to `.with_suffix()`
+   |
+59 | PosixPath().with_suffix("py")
+60 | PurePath().with_suffix("py")
+61 | PurePosixPath().with_suffix("py")
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PTH210
+62 | PureWindowsPath().with_suffix("py")
+63 | WindowsPath().with_suffix("py")
+   |
+   = help: Add a leading dot
+
+ℹ Unsafe fix
+58 58 | Path().with_suffix("py")
+59 59 | PosixPath().with_suffix("py")
+60 60 | PurePath().with_suffix("py")
+61    |-PurePosixPath().with_suffix("py")
+   61 |+PurePosixPath().with_suffix(".py")
+62 62 | PureWindowsPath().with_suffix("py")
+63 63 | WindowsPath().with_suffix("py")
+64 64 | 
+
+PTH210.py:62:1: PTH210 [*] Dotless suffix passed to `.with_suffix()`
+   |
+60 | PurePath().with_suffix("py")
+61 | PurePosixPath().with_suffix("py")
+62 | PureWindowsPath().with_suffix("py")
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PTH210
+63 | WindowsPath().with_suffix("py")
+   |
+   = help: Add a leading dot
+
+ℹ Unsafe fix
+59 59 | PosixPath().with_suffix("py")
+60 60 | PurePath().with_suffix("py")
+61 61 | PurePosixPath().with_suffix("py")
+62    |-PureWindowsPath().with_suffix("py")
+   62 |+PureWindowsPath().with_suffix(".py")
+63 63 | WindowsPath().with_suffix("py")
+64 64 | 
+65 65 | ### No errors
+
+PTH210.py:63:1: PTH210 [*] Dotless suffix passed to `.with_suffix()`
+   |
+61 | PurePosixPath().with_suffix("py")
+62 | PureWindowsPath().with_suffix("py")
+63 | WindowsPath().with_suffix("py")
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ PTH210
+64 |
+65 | ### No errors
+   |
+   = help: Add a leading dot
+
+ℹ Unsafe fix
+60 60 | PurePath().with_suffix("py")
+61 61 | PurePosixPath().with_suffix("py")
+62 62 | PureWindowsPath().with_suffix("py")
+63    |-WindowsPath().with_suffix("py")
+   63 |+WindowsPath().with_suffix(".py")
+64 64 | 
+65 65 | ### No errors
+66 66 | path.with_suffix()

crates/ruff_linter/src/rules/flake8_use_pathlib/snapshots/ruff_linter__rules__flake8_use_pathlib__tests__full_name.py.snap

@@ -103,6 +103,7 @@ full_name.py:16:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
 17 | b = os.path.exists(p)
 18 | bb = os.path.expanduser(p)
    |
+   = help: Replace with `Path.cwd()`
 
 full_name.py:17:5: PTH110 `os.path.exists()` should be replaced by `Path.exists()`
    |
@@ -292,6 +293,7 @@ full_name.py:35:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
 36 | os.path.join(p, *q)
 37 | os.sep.join(p, *q)
    |
+   = help: Replace with `Path.cwd()`
 
 full_name.py:36:1: PTH118 `os.path.join()` should be replaced by `Path.joinpath()`
    |
@@ -360,3 +362,21 @@ full_name.py:71:1: PTH123 `open()` should be replaced by `Path.open()`
 72 |
 73 | # https://github.com/astral-sh/ruff/issues/17693
    |
+
+full_name.py:108:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
+    |
+106 | os.replace("src", "dst", dst_dir_fd=2)
+107 |
+108 | os.getcwd()
+    | ^^^^^^^^^ PTH109
+109 | os.getcwdb()
+    |
+    = help: Replace with `Path.cwd()`
+
+full_name.py:109:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
+    |
+108 | os.getcwd()
+109 | os.getcwdb()
+    | ^^^^^^^^^^ PTH109
+    |
+    = help: Replace with `Path.cwd()`

crates/ruff_linter/src/rules/flake8_use_pathlib/snapshots/ruff_linter__rules__flake8_use_pathlib__tests__import_as.py.snap

@@ -103,6 +103,7 @@ import_as.py:16:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
 17 | b = foo_p.exists(p)
 18 | bb = foo_p.expanduser(p)
    |
+   = help: Replace with `Path.cwd()`
 
 import_as.py:17:5: PTH110 `os.path.exists()` should be replaced by `Path.exists()`
    |

crates/ruff_linter/src/rules/flake8_use_pathlib/snapshots/ruff_linter__rules__flake8_use_pathlib__tests__import_from.py.snap

@@ -103,6 +103,7 @@ import_from.py:18:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
 19 | b = exists(p)
 20 | bb = expanduser(p)
    |
+   = help: Replace with `Path.cwd()`
 
 import_from.py:19:5: PTH110 `os.path.exists()` should be replaced by `Path.exists()`
    |

crates/ruff_linter/src/rules/flake8_use_pathlib/snapshots/ruff_linter__rules__flake8_use_pathlib__tests__import_from_as.py.snap

@@ -103,6 +103,7 @@ import_from_as.py:23:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
 24 | b = xexists(p)
 25 | bb = xexpanduser(p)
    |
+   = help: Replace with `Path.cwd()`
 
 import_from_as.py:24:5: PTH110 `os.path.exists()` should be replaced by `Path.exists()`
    |

crates/ruff_linter/src/rules/flake8_use_pathlib/snapshots/ruff_linter__rules__flake8_use_pathlib__tests__preview_full_name.py.snap

@@ -168,6 +168,7 @@ full_name.py:16:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
 17 | b = os.path.exists(p)
 18 | bb = os.path.expanduser(p)
    |
+   = help: Replace with `Path.cwd()`
 
 full_name.py:17:5: PTH110 [*] `os.path.exists()` should be replaced by `Path.exists()`
    |
@@ -510,6 +511,7 @@ full_name.py:35:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
 36 | os.path.join(p, *q)
 37 | os.sep.join(p, *q)
    |
+   = help: Replace with `Path.cwd()`
 
 full_name.py:36:1: PTH118 `os.path.join()` should be replaced by `Path.joinpath()`
    |
@@ -578,3 +580,50 @@ full_name.py:71:1: PTH123 `open()` should be replaced by `Path.open()`
 72 |
 73 | # https://github.com/astral-sh/ruff/issues/17693
    |
+
+full_name.py:108:1: PTH109 [*] `os.getcwd()` should be replaced by `Path.cwd()`
+    |
+106 | os.replace("src", "dst", dst_dir_fd=2)
+107 |
+108 | os.getcwd()
+    | ^^^^^^^^^ PTH109
+109 | os.getcwdb()
+    |
+    = help: Replace with `Path.cwd()`
+
+ℹ Safe fix
+1   1   | import os
+2   2   | import os.path
+    3   |+import pathlib
+3   4   | 
+4   5   | p = "/foo"
+5   6   | q = "bar"
+--------------------------------------------------------------------------------
+105 106 | os.replace("src", "dst", src_dir_fd=1)
+106 107 | os.replace("src", "dst", dst_dir_fd=2)
+107 108 | 
+108     |-os.getcwd()
+    109 |+pathlib.Path.cwd()
+109 110 | os.getcwdb()
+
+full_name.py:109:1: PTH109 [*] `os.getcwd()` should be replaced by `Path.cwd()`
+    |
+108 | os.getcwd()
+109 | os.getcwdb()
+    | ^^^^^^^^^^ PTH109
+    |
+    = help: Replace with `Path.cwd()`
+
+ℹ Safe fix
+1   1   | import os
+2   2   | import os.path
+    3   |+import pathlib
+3   4   | 
+4   5   | p = "/foo"
+5   6   | q = "bar"
+--------------------------------------------------------------------------------
+106 107 | os.replace("src", "dst", dst_dir_fd=2)
+107 108 | 
+108 109 | os.getcwd()
+109     |-os.getcwdb()
+    110 |+pathlib.Path.cwd()

crates/ruff_linter/src/rules/flake8_use_pathlib/snapshots/ruff_linter__rules__flake8_use_pathlib__tests__preview_import_as.py.snap

@@ -168,6 +168,7 @@ import_as.py:16:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
 17 | b = foo_p.exists(p)
 18 | bb = foo_p.expanduser(p)
    |
+   = help: Replace with `Path.cwd()`
 
 import_as.py:17:5: PTH110 [*] `os.path.exists()` should be replaced by `Path.exists()`
    |

crates/ruff_linter/src/rules/flake8_use_pathlib/snapshots/ruff_linter__rules__flake8_use_pathlib__tests__preview_import_from.py.snap

@@ -172,6 +172,7 @@ import_from.py:18:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
 19 | b = exists(p)
 20 | bb = expanduser(p)
    |
+   = help: Replace with `Path.cwd()`
 
 import_from.py:19:5: PTH110 [*] `os.path.exists()` should be replaced by `Path.exists()`
    |

crates/ruff_linter/src/rules/flake8_use_pathlib/snapshots/ruff_linter__rules__flake8_use_pathlib__tests__preview_import_from_as.py.snap

@@ -172,6 +172,7 @@ import_from_as.py:23:1: PTH109 `os.getcwd()` should be replaced by `Path.cwd()`
 24 | b = xexists(p)
 25 | bb = xexpanduser(p)
    |
+   = help: Replace with `Path.cwd()`
 
 import_from_as.py:24:5: PTH110 [*] `os.path.exists()` should be replaced by `Path.exists()`
    |

crates/ruff_linter/src/rules/flake8_use_pathlib/violations.rs

@@ -230,52 +230,6 @@ impl Violation for OsReplace {
     }
 }
 
-/// ## What it does
-/// Checks for uses of `os.getcwd` and `os.getcwdb`.
-///
-/// ## Why is this bad?
-/// `pathlib` offers a high-level API for path manipulation, as compared to
-/// the lower-level API offered by `os`. When possible, using `Path` object
-/// methods such as `Path.cwd()` can improve readability over the `os`
-/// module's counterparts (e.g., `os.getcwd()`).
-///
-/// ## Examples
-/// ```python
-/// import os
-///
-/// cwd = os.getcwd()
-/// ```
-///
-/// Use instead:
-/// ```python
-/// from pathlib import Path
-///
-/// cwd = Path.cwd()
-/// ```
-///
-/// ## Known issues
-/// While using `pathlib` can improve the readability and type safety of your code,
-/// it can be less performant than the lower-level alternatives that work directly with strings,
-/// especially on older versions of Python.
-///
-/// ## References
-/// - [Python documentation: `Path.cwd`](https://docs.python.org/3/library/pathlib.html#pathlib.Path.cwd)
-/// - [Python documentation: `os.getcwd`](https://docs.python.org/3/library/os.html#os.getcwd)
-/// - [Python documentation: `os.getcwdb`](https://docs.python.org/3/library/os.html#os.getcwdb)
-/// - [PEP 428 – The pathlib module – object-oriented filesystem paths](https://peps.python.org/pep-0428/)
-/// - [Correspondence between `os` and `pathlib`](https://docs.python.org/3/library/pathlib.html#correspondence-to-tools-in-the-os-module)
-/// - [Why you should be using pathlib](https://treyhunner.com/2018/12/why-you-should-be-using-pathlib/)
-/// - [No really, pathlib is great](https://treyhunner.com/2019/01/no-really-pathlib-is-great/)
-#[derive(ViolationMetadata)]
-pub(crate) struct OsGetcwd;
-
-impl Violation for OsGetcwd {
-    #[derive_message_formats]
-    fn message(&self) -> String {
-        "`os.getcwd()` should be replaced by `Path.cwd()`".to_string()
-    }
-}
-
 /// ## What it does
 /// Checks for uses of `os.stat`.
 ///

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

@@ -801,6 +801,7 @@ mod tests {
     #[test_case(Path::new("existing_import.py"))]
     #[test_case(Path::new("multiline_docstring.py"))]
     #[test_case(Path::new("off.py"))]
+    #[test_case(Path::new("whitespace.py"))]
     fn required_import(path: &Path) -> Result<()> {
         let snapshot = format!("required_import_{}", path.to_string_lossy());
         let diagnostics = test_path(

crates/ruff_linter/src/rules/isort/snapshots/ruff_linter__rules__isort__tests__required_import_whitespace.py.snap

@@ -0,0 +1,11 @@
+---
+source: crates/ruff_linter/src/rules/isort/mod.rs
+---
+whitespace.py:1:1: I002 [*] Missing required import: `from __future__ import annotations`
+ℹ Safe fix
+1 1 | # This is a regression test for https://github.com/astral-sh/ruff/issues/19310
+2 2 | # there is a (potentially invisible) unicode formfeed character (000C) between "docstring" and the semicolon
+3   |-"docstring"; print(
+  3 |+"docstring"; from __future__ import annotations; print(
+4 4 |     f"{__doc__=}",
+5 5 | )

crates/ruff_linter/src/rules/pylint/rules/unspecified_encoding.rs

@@ -4,6 +4,7 @@ use ruff_macros::{ViolationMetadata, derive_message_formats};
 use ruff_python_ast::name::QualifiedName;
 use ruff_python_ast::{self as ast, Expr};
 use ruff_python_semantic::SemanticModel;
+use ruff_python_semantic::analyze::typing;
 use ruff_text_size::{Ranged, TextRange};
 
 use crate::checkers::ast::Checker;
@@ -111,20 +112,34 @@ enum Callee<'a> {
 }
 
 impl<'a> Callee<'a> {
+    fn is_pathlib_path_call(expr: &Expr, semantic: &SemanticModel) -> bool {
+        if let Expr::Call(ast::ExprCall { func, .. }) = expr {
+            semantic
+                .resolve_qualified_name(func)
+                .is_some_and(|qualified_name| {
+                    matches!(qualified_name.segments(), ["pathlib", "Path"])
+                })
+        } else {
+            false
+        }
+    }
+
     fn try_from_call_expression(
         call: &'a ast::ExprCall,
         semantic: &'a SemanticModel,
     ) -> Option<Self> {
         if let Expr::Attribute(ast::ExprAttribute { attr, value, .. }) = call.func.as_ref() {
-            // Check for `pathlib.Path(...).open(...)` or equivalent
-            if let Expr::Call(ast::ExprCall { func, .. }) = value.as_ref() {
-                if semantic
-                    .resolve_qualified_name(func)
-                    .is_some_and(|qualified_name| {
-                        matches!(qualified_name.segments(), ["pathlib", "Path"])
-                    })
-                {
-                    return Some(Callee::Pathlib(attr));
+            // Direct: Path(...).open()
+            if Self::is_pathlib_path_call(value, semantic) {
+                return Some(Callee::Pathlib(attr));
+            }
+            // Indirect: x.open() where x = Path(...)
+            else if let Expr::Name(name) = value.as_ref() {
+                if let Some(binding_id) = semantic.only_binding(name) {
+                    let binding = semantic.binding(binding_id);
+                    if typing::is_pathlib_path(binding, semantic) {
+                        return Some(Callee::Pathlib(attr));
+                    }
                 }
             }
         }

crates/ruff_linter/src/rules/pylint/snapshots/ruff_linter__rules__pylint__tests__PLW1514_unspecified_encoding.py.snap

@@ -435,3 +435,41 @@ unspecified_encoding.py:80:1: PLW1514 [*] `pathlib.Path(...).write_text` without
 81 81 | 
 82 82 | # Non-errors.
 83 83 | Path("foo.txt").open(encoding="utf-8")
+
+unspecified_encoding.py:96:1: PLW1514 [*] `pathlib.Path(...).open` in text mode without explicit `encoding` argument
+   |
+94 | # https://github.com/astral-sh/ruff/issues/19294
+95 | x = Path("foo.txt")
+96 | x.open()
+   | ^^^^^^ PLW1514
+97 |
+98 | # https://github.com/astral-sh/ruff/issues/18107
+   |
+   = help: Add explicit `encoding` argument
+
+ℹ Unsafe fix
+93 93 | 
+94 94 | # https://github.com/astral-sh/ruff/issues/19294
+95 95 | x = Path("foo.txt")
+96    |-x.open()
+   96 |+x.open(encoding="utf-8")
+97 97 | 
+98 98 | # https://github.com/astral-sh/ruff/issues/18107
+99 99 | codecs.open("plw1514.py", "r", "utf-8").close() # this is fine
+
+unspecified_encoding.py:105:10: PLW1514 [*] `pathlib.Path(...).open` in text mode without explicit `encoding` argument
+    |
+104 | def format_file(file: Path):
+105 |     with file.open() as f:
+    |          ^^^^^^^^^ PLW1514
+106 |         contents = f.read()
+    |
+    = help: Add explicit `encoding` argument
+
+ℹ Unsafe fix
+102 102 | from pathlib import Path
+103 103 | 
+104 104 | def format_file(file: Path):
+105     |-    with file.open() as f:
+    105 |+    with file.open(encoding="utf-8") as f:
+106 106 |         contents = f.read()

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

@@ -136,6 +136,23 @@ mod tests {
         Ok(())
     }
 
+    #[test_case(Rule::QuotedAnnotation, Path::new("UP037_0.py"))]
+    #[test_case(Rule::QuotedAnnotation, Path::new("UP037_1.py"))]
+    #[test_case(Rule::QuotedAnnotation, Path::new("UP037_2.pyi"))]
+    fn up037_add_future_annotation(rule_code: Rule, path: &Path) -> Result<()> {
+        let snapshot = format!("add_future_annotation_{}", path.to_string_lossy());
+        let diagnostics = test_path(
+            Path::new("pyupgrade").join(path).as_path(),
+            &settings::LinterSettings {
+                preview: PreviewMode::Enabled,
+                future_annotations: true,
+                ..settings::LinterSettings::for_rule(rule_code)
+            },
+        )?;
+        assert_diagnostics!(snapshot, diagnostics);
+        Ok(())
+    }
+
     #[test]
     fn async_timeout_error_alias_not_applied_py310() -> Result<()> {
         let diagnostics = test_path(

crates/ruff_linter/src/rules/pyupgrade/rules/quoted_annotation.rs

@@ -57,6 +57,22 @@ use crate::{AlwaysFixableViolation, Edit, Fix};
 ///     bar: Bar
 /// ```
 ///
+/// ## Preview
+///
+/// When [preview] is enabled, if [`lint.future-annotations`] is set to `true`,
+/// `from __future__ import annotations` will be added if doing so would allow an annotation to be
+/// unquoted.
+///
+/// ## Fix safety
+///
+/// The rule's fix is marked as safe, unless [preview] and
+/// [`lint.future_annotations`] are enabled and a `from __future__ import
+/// annotations` import is added. Such an import may change the behavior of all annotations in the
+/// file.
+///
+/// ## Options
+/// - `lint.future-annotations`
+///
 /// ## See also
 /// - [`quoted-annotation-in-stub`][PYI020]: A rule that
 ///   removes all quoted annotations from stub files
@@ -69,6 +85,7 @@ use crate::{AlwaysFixableViolation, Edit, Fix};
 ///
 /// [PYI020]: https://docs.astral.sh/ruff/rules/quoted-annotation-in-stub/
 /// [TC008]: https://docs.astral.sh/ruff/rules/quoted-type-alias/
+/// [preview]: https://docs.astral.sh/ruff/preview/
 #[derive(ViolationMetadata)]
 pub(crate) struct QuotedAnnotation;
 
@@ -85,6 +102,13 @@ impl AlwaysFixableViolation for QuotedAnnotation {
 
 /// UP037
 pub(crate) fn quoted_annotation(checker: &Checker, annotation: &str, range: TextRange) {
+    let add_future_import = checker.settings().future_annotations()
+        && checker.semantic().in_runtime_evaluated_annotation();
+
+    if !(checker.semantic().in_typing_only_annotation() || add_future_import) {
+        return;
+    }
+
     let placeholder_range = TextRange::up_to(annotation.text_len());
     let spans_multiple_lines = annotation.contains_line_break(placeholder_range);
 
@@ -103,8 +127,14 @@ pub(crate) fn quoted_annotation(checker: &Checker, annotation: &str, range: Text
         (true, false) => format!("({annotation})"),
         (_, true) => format!("({annotation}\n)"),
     };
-    let edit = Edit::range_replacement(new_content, range);
-    let fix = Fix::safe_edit(edit);
+    let unquote_edit = Edit::range_replacement(new_content, range);
+
+    let fix = if add_future_import {
+        let import_edit = checker.importer().add_future_import();
+        Fix::unsafe_edits(unquote_edit, [import_edit])
+    } else {
+        Fix::safe_edit(unquote_edit)
+    };
 
     checker
         .report_diagnostic(QuotedAnnotation, range)

crates/ruff_linter/src/rules/pyupgrade/snapshots/ruff_linter__rules__pyupgrade__tests__add_future_annotation_UP037_0.py.snap

@@ -0,0 +1,625 @@
+---
+source: crates/ruff_linter/src/rules/pyupgrade/mod.rs
+---
+UP037_0.py:18:14: UP037 [*] Remove quotes from type annotation
+   |
+18 | def foo(var: "MyClass") -> "MyClass":
+   |              ^^^^^^^^^ UP037
+19 |     x: "MyClass"
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+15 15 | from mypy_extensions import Arg, DefaultArg, DefaultNamedArg, NamedArg, VarArg
+16 16 | 
+17 17 | 
+18    |-def foo(var: "MyClass") -> "MyClass":
+   18 |+def foo(var: MyClass) -> "MyClass":
+19 19 |     x: "MyClass"
+20 20 | 
+21 21 | 
+
+UP037_0.py:18:28: UP037 [*] Remove quotes from type annotation
+   |
+18 | def foo(var: "MyClass") -> "MyClass":
+   |                            ^^^^^^^^^ UP037
+19 |     x: "MyClass"
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+15 15 | from mypy_extensions import Arg, DefaultArg, DefaultNamedArg, NamedArg, VarArg
+16 16 | 
+17 17 | 
+18    |-def foo(var: "MyClass") -> "MyClass":
+   18 |+def foo(var: "MyClass") -> MyClass:
+19 19 |     x: "MyClass"
+20 20 | 
+21 21 | 
+
+UP037_0.py:19:8: UP037 [*] Remove quotes from type annotation
+   |
+18 | def foo(var: "MyClass") -> "MyClass":
+19 |     x: "MyClass"
+   |        ^^^^^^^^^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+16 16 | 
+17 17 | 
+18 18 | def foo(var: "MyClass") -> "MyClass":
+19    |-    x: "MyClass"
+   19 |+    x: MyClass
+20 20 | 
+21 21 | 
+22 22 | def foo(*, inplace: "bool"):
+
+UP037_0.py:22:21: UP037 [*] Remove quotes from type annotation
+   |
+22 | def foo(*, inplace: "bool"):
+   |                     ^^^^^^ UP037
+23 |     pass
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+19 19 |     x: "MyClass"
+20 20 | 
+21 21 | 
+22    |-def foo(*, inplace: "bool"):
+   22 |+def foo(*, inplace: bool):
+23 23 |     pass
+24 24 | 
+25 25 | 
+
+UP037_0.py:26:16: UP037 [*] Remove quotes from type annotation
+   |
+26 | def foo(*args: "str", **kwargs: "int"):
+   |                ^^^^^ UP037
+27 |     pass
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+23 23 |     pass
+24 24 | 
+25 25 | 
+26    |-def foo(*args: "str", **kwargs: "int"):
+   26 |+def foo(*args: str, **kwargs: "int"):
+27 27 |     pass
+28 28 | 
+29 29 | 
+
+UP037_0.py:26:33: UP037 [*] Remove quotes from type annotation
+   |
+26 | def foo(*args: "str", **kwargs: "int"):
+   |                                 ^^^^^ UP037
+27 |     pass
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+23 23 |     pass
+24 24 | 
+25 25 | 
+26    |-def foo(*args: "str", **kwargs: "int"):
+   26 |+def foo(*args: "str", **kwargs: int):
+27 27 |     pass
+28 28 | 
+29 29 | 
+
+UP037_0.py:30:10: UP037 [*] Remove quotes from type annotation
+   |
+30 | x: Tuple["MyClass"]
+   |          ^^^^^^^^^ UP037
+31 |
+32 | x: Callable[["MyClass"], None]
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+27 27 |     pass
+28 28 | 
+29 29 | 
+30    |-x: Tuple["MyClass"]
+   30 |+x: Tuple[MyClass]
+31 31 | 
+32 32 | x: Callable[["MyClass"], None]
+33 33 | 
+
+UP037_0.py:32:14: UP037 [*] Remove quotes from type annotation
+   |
+30 | x: Tuple["MyClass"]
+31 |
+32 | x: Callable[["MyClass"], None]
+   |              ^^^^^^^^^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+29 29 | 
+30 30 | x: Tuple["MyClass"]
+31 31 | 
+32    |-x: Callable[["MyClass"], None]
+   32 |+x: Callable[[MyClass], None]
+33 33 | 
+34 34 | 
+35 35 | class Foo(NamedTuple):
+
+UP037_0.py:36:8: UP037 [*] Remove quotes from type annotation
+   |
+35 | class Foo(NamedTuple):
+36 |     x: "MyClass"
+   |        ^^^^^^^^^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+33 33 | 
+34 34 | 
+35 35 | class Foo(NamedTuple):
+36    |-    x: "MyClass"
+   36 |+    x: MyClass
+37 37 | 
+38 38 | 
+39 39 | class D(TypedDict):
+
+UP037_0.py:40:27: UP037 [*] Remove quotes from type annotation
+   |
+39 | class D(TypedDict):
+40 |     E: TypedDict("E", foo="int", total=False)
+   |                           ^^^^^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+37 37 | 
+38 38 | 
+39 39 | class D(TypedDict):
+40    |-    E: TypedDict("E", foo="int", total=False)
+   40 |+    E: TypedDict("E", foo=int, total=False)
+41 41 | 
+42 42 | 
+43 43 | class D(TypedDict):
+
+UP037_0.py:44:31: UP037 [*] Remove quotes from type annotation
+   |
+43 | class D(TypedDict):
+44 |     E: TypedDict("E", {"foo": "int"})
+   |                               ^^^^^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+41 41 | 
+42 42 | 
+43 43 | class D(TypedDict):
+44    |-    E: TypedDict("E", {"foo": "int"})
+   44 |+    E: TypedDict("E", {"foo": int})
+45 45 | 
+46 46 | 
+47 47 | x: Annotated["str", "metadata"]
+
+UP037_0.py:47:14: UP037 [*] Remove quotes from type annotation
+   |
+47 | x: Annotated["str", "metadata"]
+   |              ^^^^^ UP037
+48 |
+49 | x: Arg("str", "name")
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+44 44 |     E: TypedDict("E", {"foo": "int"})
+45 45 | 
+46 46 | 
+47    |-x: Annotated["str", "metadata"]
+   47 |+x: Annotated[str, "metadata"]
+48 48 | 
+49 49 | x: Arg("str", "name")
+50 50 | 
+
+UP037_0.py:49:8: UP037 [*] Remove quotes from type annotation
+   |
+47 | x: Annotated["str", "metadata"]
+48 |
+49 | x: Arg("str", "name")
+   |        ^^^^^ UP037
+50 |
+51 | x: DefaultArg("str", "name")
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+46 46 | 
+47 47 | x: Annotated["str", "metadata"]
+48 48 | 
+49    |-x: Arg("str", "name")
+   49 |+x: Arg(str, "name")
+50 50 | 
+51 51 | x: DefaultArg("str", "name")
+52 52 | 
+
+UP037_0.py:51:15: UP037 [*] Remove quotes from type annotation
+   |
+49 | x: Arg("str", "name")
+50 |
+51 | x: DefaultArg("str", "name")
+   |               ^^^^^ UP037
+52 |
+53 | x: NamedArg("str", "name")
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+48 48 | 
+49 49 | x: Arg("str", "name")
+50 50 | 
+51    |-x: DefaultArg("str", "name")
+   51 |+x: DefaultArg(str, "name")
+52 52 | 
+53 53 | x: NamedArg("str", "name")
+54 54 | 
+
+UP037_0.py:53:13: UP037 [*] Remove quotes from type annotation
+   |
+51 | x: DefaultArg("str", "name")
+52 |
+53 | x: NamedArg("str", "name")
+   |             ^^^^^ UP037
+54 |
+55 | x: DefaultNamedArg("str", "name")
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+50 50 | 
+51 51 | x: DefaultArg("str", "name")
+52 52 | 
+53    |-x: NamedArg("str", "name")
+   53 |+x: NamedArg(str, "name")
+54 54 | 
+55 55 | x: DefaultNamedArg("str", "name")
+56 56 | 
+
+UP037_0.py:55:20: UP037 [*] Remove quotes from type annotation
+   |
+53 | x: NamedArg("str", "name")
+54 |
+55 | x: DefaultNamedArg("str", "name")
+   |                    ^^^^^ UP037
+56 |
+57 | x: DefaultNamedArg("str", name="name")
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+52 52 | 
+53 53 | x: NamedArg("str", "name")
+54 54 | 
+55    |-x: DefaultNamedArg("str", "name")
+   55 |+x: DefaultNamedArg(str, "name")
+56 56 | 
+57 57 | x: DefaultNamedArg("str", name="name")
+58 58 | 
+
+UP037_0.py:57:20: UP037 [*] Remove quotes from type annotation
+   |
+55 | x: DefaultNamedArg("str", "name")
+56 |
+57 | x: DefaultNamedArg("str", name="name")
+   |                    ^^^^^ UP037
+58 |
+59 | x: VarArg("str")
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+54 54 | 
+55 55 | x: DefaultNamedArg("str", "name")
+56 56 | 
+57    |-x: DefaultNamedArg("str", name="name")
+   57 |+x: DefaultNamedArg(str, name="name")
+58 58 | 
+59 59 | x: VarArg("str")
+60 60 | 
+
+UP037_0.py:59:11: UP037 [*] Remove quotes from type annotation
+   |
+57 | x: DefaultNamedArg("str", name="name")
+58 |
+59 | x: VarArg("str")
+   |           ^^^^^ UP037
+60 |
+61 | x: List[List[List["MyClass"]]]
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+56 56 | 
+57 57 | x: DefaultNamedArg("str", name="name")
+58 58 | 
+59    |-x: VarArg("str")
+   59 |+x: VarArg(str)
+60 60 | 
+61 61 | x: List[List[List["MyClass"]]]
+62 62 | 
+
+UP037_0.py:61:19: UP037 [*] Remove quotes from type annotation
+   |
+59 | x: VarArg("str")
+60 |
+61 | x: List[List[List["MyClass"]]]
+   |                   ^^^^^^^^^ UP037
+62 |
+63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+58 58 | 
+59 59 | x: VarArg("str")
+60 60 | 
+61    |-x: List[List[List["MyClass"]]]
+   61 |+x: List[List[List[MyClass]]]
+62 62 | 
+63 63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+64 64 | 
+
+UP037_0.py:63:29: UP037 [*] Remove quotes from type annotation
+   |
+61 | x: List[List[List["MyClass"]]]
+62 |
+63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+   |                             ^^^^^ UP037
+64 |
+65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+60 60 | 
+61 61 | x: List[List[List["MyClass"]]]
+62 62 | 
+63    |-x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+   63 |+x: NamedTuple("X", [("foo", int), ("bar", "str")])
+64 64 | 
+65 65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+66 66 | 
+
+UP037_0.py:63:45: UP037 [*] Remove quotes from type annotation
+   |
+61 | x: List[List[List["MyClass"]]]
+62 |
+63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+   |                                             ^^^^^ UP037
+64 |
+65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+60 60 | 
+61 61 | x: List[List[List["MyClass"]]]
+62 62 | 
+63    |-x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+   63 |+x: NamedTuple("X", [("foo", "int"), ("bar", str)])
+64 64 | 
+65 65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+66 66 | 
+
+UP037_0.py:65:29: UP037 [*] Remove quotes from type annotation
+   |
+63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+64 |
+65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+   |                             ^^^^^ UP037
+66 |
+67 | x: NamedTuple(typename="X", fields=[("foo", "int")])
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+62 62 | 
+63 63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+64 64 | 
+65    |-x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+   65 |+x: NamedTuple("X", fields=[(foo, "int"), ("bar", "str")])
+66 66 | 
+67 67 | x: NamedTuple(typename="X", fields=[("foo", "int")])
+68 68 | 
+
+UP037_0.py:65:36: UP037 [*] Remove quotes from type annotation
+   |
+63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+64 |
+65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+   |                                    ^^^^^ UP037
+66 |
+67 | x: NamedTuple(typename="X", fields=[("foo", "int")])
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+62 62 | 
+63 63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+64 64 | 
+65    |-x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+   65 |+x: NamedTuple("X", fields=[("foo", int), ("bar", "str")])
+66 66 | 
+67 67 | x: NamedTuple(typename="X", fields=[("foo", "int")])
+68 68 | 
+
+UP037_0.py:65:45: UP037 [*] Remove quotes from type annotation
+   |
+63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+64 |
+65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+   |                                             ^^^^^ UP037
+66 |
+67 | x: NamedTuple(typename="X", fields=[("foo", "int")])
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+62 62 | 
+63 63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+64 64 | 
+65    |-x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+   65 |+x: NamedTuple("X", fields=[("foo", "int"), (bar, "str")])
+66 66 | 
+67 67 | x: NamedTuple(typename="X", fields=[("foo", "int")])
+68 68 | 
+
+UP037_0.py:65:52: UP037 [*] Remove quotes from type annotation
+   |
+63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+64 |
+65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+   |                                                    ^^^^^ UP037
+66 |
+67 | x: NamedTuple(typename="X", fields=[("foo", "int")])
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+62 62 | 
+63 63 | x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
+64 64 | 
+65    |-x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+   65 |+x: NamedTuple("X", fields=[("foo", "int"), ("bar", str)])
+66 66 | 
+67 67 | x: NamedTuple(typename="X", fields=[("foo", "int")])
+68 68 | 
+
+UP037_0.py:67:24: UP037 [*] Remove quotes from type annotation
+   |
+65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+66 |
+67 | x: NamedTuple(typename="X", fields=[("foo", "int")])
+   |                        ^^^ UP037
+68 |
+69 | X: MyCallable("X")
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+64 64 | 
+65 65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+66 66 | 
+67    |-x: NamedTuple(typename="X", fields=[("foo", "int")])
+   67 |+x: NamedTuple(typename=X, fields=[("foo", "int")])
+68 68 | 
+69 69 | X: MyCallable("X")
+70 70 | 
+
+UP037_0.py:67:38: UP037 [*] Remove quotes from type annotation
+   |
+65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+66 |
+67 | x: NamedTuple(typename="X", fields=[("foo", "int")])
+   |                                      ^^^^^ UP037
+68 |
+69 | X: MyCallable("X")
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+64 64 | 
+65 65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+66 66 | 
+67    |-x: NamedTuple(typename="X", fields=[("foo", "int")])
+   67 |+x: NamedTuple(typename="X", fields=[(foo, "int")])
+68 68 | 
+69 69 | X: MyCallable("X")
+70 70 | 
+
+UP037_0.py:67:45: UP037 [*] Remove quotes from type annotation
+   |
+65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+66 |
+67 | x: NamedTuple(typename="X", fields=[("foo", "int")])
+   |                                             ^^^^^ UP037
+68 |
+69 | X: MyCallable("X")
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+64 64 | 
+65 65 | x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
+66 66 | 
+67    |-x: NamedTuple(typename="X", fields=[("foo", "int")])
+   67 |+x: NamedTuple(typename="X", fields=[("foo", int)])
+68 68 | 
+69 69 | X: MyCallable("X")
+70 70 | 
+
+UP037_0.py:112:12: UP037 [*] Remove quotes from type annotation
+    |
+110 | # Handle end of line comment in string annotation
+111 | # See https://github.com/astral-sh/ruff/issues/15816
+112 | def f() -> "Literal[0]#":
+    |            ^^^^^^^^^^^^^ UP037
+113 |     return 0
+    |
+    = help: Remove quotes
+
+ℹ Safe fix
+109 109 | 
+110 110 | # Handle end of line comment in string annotation
+111 111 | # See https://github.com/astral-sh/ruff/issues/15816
+112     |-def f() -> "Literal[0]#":
+    112 |+def f() -> (Literal[0]#
+    113 |+):
+113 114 |     return 0
+114 115 | 
+115 116 | def g(x: "Literal['abc']#") -> None:
+
+UP037_0.py:115:10: UP037 [*] Remove quotes from type annotation
+    |
+113 |     return 0
+114 |
+115 | def g(x: "Literal['abc']#") -> None:
+    |          ^^^^^^^^^^^^^^^^^ UP037
+116 |     return
+    |
+    = help: Remove quotes
+
+ℹ Safe fix
+112 112 | def f() -> "Literal[0]#":
+113 113 |     return 0
+114 114 | 
+115     |-def g(x: "Literal['abc']#") -> None:
+    115 |+def g(x: (Literal['abc']#
+    116 |+)) -> None:
+116 117 |     return
+117 118 | 
+118 119 | def f() -> """Literal[0]
+
+UP037_0.py:118:12: UP037 [*] Remove quotes from type annotation
+    |
+116 |       return
+117 |
+118 |   def f() -> """Literal[0]
+    |  ____________^
+119 | |     #
+120 | |     
+121 | |     """:
+    | |_______^ UP037
+122 |       return 0
+    |
+    = help: Remove quotes
+
+ℹ Safe fix
+115 115 | def g(x: "Literal['abc']#") -> None:
+116 116 |     return
+117 117 | 
+118     |-def f() -> """Literal[0]
+    118 |+def f() -> (Literal[0]
+119 119 |     #
+120 120 |     
+121     |-    """:
+    121 |+    ):
+122 122 |     return 0

crates/ruff_linter/src/rules/pyupgrade/snapshots/ruff_linter__rules__pyupgrade__tests__add_future_annotation_UP037_1.py.snap

@@ -0,0 +1,42 @@
+---
+source: crates/ruff_linter/src/rules/pyupgrade/mod.rs
+---
+UP037_1.py:9:8: UP037 [*] Remove quotes from type annotation
+   |
+ 7 | def foo():
+ 8 |     # UP037
+ 9 |     x: "Tuple[int, int]" = (0, 0)
+   |        ^^^^^^^^^^^^^^^^^ UP037
+10 |     print(x)
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+6  6  | 
+7  7  | def foo():
+8  8  |     # UP037
+9     |-    x: "Tuple[int, int]" = (0, 0)
+   9  |+    x: Tuple[int, int] = (0, 0)
+10 10 |     print(x)
+11 11 | 
+12 12 | 
+
+UP037_1.py:14:4: UP037 [*] Remove quotes from type annotation
+   |
+13 | # OK
+14 | X: "Tuple[int, int]" = (0, 0)
+   |    ^^^^^^^^^^^^^^^^^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | from typing import TYPE_CHECKING
+2  3  | 
+3  4  | if TYPE_CHECKING:
+--------------------------------------------------------------------------------
+11 12 | 
+12 13 | 
+13 14 | # OK
+14    |-X: "Tuple[int, int]" = (0, 0)
+   15 |+X: Tuple[int, int] = (0, 0)

crates/ruff_linter/src/rules/pyupgrade/snapshots/ruff_linter__rules__pyupgrade__tests__add_future_annotation_UP037_2.pyi.snap

@@ -0,0 +1,232 @@
+---
+source: crates/ruff_linter/src/rules/pyupgrade/mod.rs
+---
+UP037_2.pyi:3:14: UP037 [*] Remove quotes from type annotation
+  |
+1 | # https://github.com/astral-sh/ruff/issues/7102
+2 |
+3 | def f(a: Foo['SingleLine  # Comment']): ...
+  |              ^^^^^^^^^^^^^^^^^^^^^^^ UP037
+  |
+  = help: Remove quotes
+
+ℹ Safe fix
+1 1 | # https://github.com/astral-sh/ruff/issues/7102
+2 2 | 
+3   |-def f(a: Foo['SingleLine  # Comment']): ...
+  3 |+def f(a: Foo[(SingleLine  # Comment
+  4 |+)]): ...
+4 5 | 
+5 6 | 
+6 7 | def f(a: Foo['''Bar[
+
+UP037_2.pyi:6:14: UP037 [*] Remove quotes from type annotation
+  |
+6 |   def f(a: Foo['''Bar[
+  |  ______________^
+7 | |     Multi |
+8 | |     Line]''']): ...
+  | |____________^ UP037
+  |
+  = help: Remove quotes
+
+ℹ Safe fix
+3 3 | def f(a: Foo['SingleLine  # Comment']): ...
+4 4 | 
+5 5 | 
+6   |-def f(a: Foo['''Bar[
+  6 |+def f(a: Foo[Bar[
+7 7 |     Multi |
+8   |-    Line]''']): ...
+  8 |+    Line]]): ...
+9 9 | 
+10 10 | 
+11 11 | def f(a: Foo['''Bar[
+
+UP037_2.pyi:11:14: UP037 [*] Remove quotes from type annotation
+   |
+11 |   def f(a: Foo['''Bar[
+   |  ______________^
+12 | |     Multi |
+13 | |     Line  # Comment
+14 | | ]''']): ...
+   | |____^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+8  8  |     Line]''']): ...
+9  9  | 
+10 10 | 
+11    |-def f(a: Foo['''Bar[
+   11 |+def f(a: Foo[Bar[
+12 12 |     Multi |
+13 13 |     Line  # Comment
+14    |-]''']): ...
+   14 |+]]): ...
+15 15 | 
+16 16 | 
+17 17 | def f(a: Foo['''Bar[
+
+UP037_2.pyi:17:14: UP037 [*] Remove quotes from type annotation
+   |
+17 |   def f(a: Foo['''Bar[
+   |  ______________^
+18 | |     Multi |
+19 | |     Line]  # Comment''']): ...
+   | |_______________________^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+14 14 | ]''']): ...
+15 15 | 
+16 16 | 
+17    |-def f(a: Foo['''Bar[
+   17 |+def f(a: Foo[(Bar[
+18 18 |     Multi |
+19    |-    Line]  # Comment''']): ...
+   19 |+    Line]  # Comment
+   20 |+)]): ...
+20 21 | 
+21 22 | 
+22 23 | def f(a: Foo['''
+
+UP037_2.pyi:22:14: UP037 [*] Remove quotes from type annotation
+   |
+22 |   def f(a: Foo['''
+   |  ______________^
+23 | | Bar[
+24 | |     Multi |
+25 | |     Line]  # Comment''']): ...
+   | |_______________________^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+19 19 |     Line]  # Comment''']): ...
+20 20 | 
+21 21 | 
+22    |-def f(a: Foo['''
+   22 |+def f(a: Foo[(
+23 23 | Bar[
+24 24 |     Multi |
+25    |-    Line]  # Comment''']): ...
+   25 |+    Line]  # Comment
+   26 |+)]): ...
+26 27 | 
+27 28 | 
+28 29 | def f(a: '''list[int]
+
+UP037_2.pyi:28:10: UP037 [*] Remove quotes from type annotation
+   |
+28 |   def f(a: '''list[int]
+   |  __________^
+29 | |     ''' = []): ...
+   | |_______^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+25 25 |     Line]  # Comment''']): ...
+26 26 | 
+27 27 | 
+28    |-def f(a: '''list[int]
+29    |-	''' = []): ...
+   28 |+def f(a: list[int]
+   29 |+	 = []): ...
+30 30 | 
+31 31 | 
+32 32 | a: '''\\
+
+UP037_2.pyi:32:4: UP037 [*] Remove quotes from type annotation
+   |
+32 |   a: '''\\
+   |  ____^
+33 | | list[int]''' = [42]
+   | |____________^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+29 29 | 	''' = []): ...
+30 30 | 
+31 31 | 
+32    |-a: '''\\
+33    |-list[int]''' = [42]
+   32 |+a: (\
+   33 |+list[int]) = [42]
+34 34 | 
+35 35 | 
+36 36 | def f(a: '''
+
+UP037_2.pyi:36:10: UP037 [*] Remove quotes from type annotation
+   |
+36 |   def f(a: '''
+   |  __________^
+37 | |     list[int]
+38 | |     ''' = []): ...
+   | |_______^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+33 33 | list[int]''' = [42]
+34 34 | 
+35 35 | 
+36    |-def f(a: '''
+   36 |+def f(a: 
+37 37 | 	list[int]
+38    |-	''' = []): ...
+   38 |+	 = []): ...
+39 39 | 
+40 40 | 
+41 41 | def f(a: Foo['''
+
+UP037_2.pyi:41:14: UP037 [*] Remove quotes from type annotation
+   |
+41 |   def f(a: Foo['''
+   |  ______________^
+42 | |     Bar
+43 | |     [
+44 | |     Multi |
+45 | |     Line
+46 | |     ]  # Comment''']): ...
+   | |___________________^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+38 38 | 	''' = []): ...
+39 39 | 
+40 40 | 
+41    |-def f(a: Foo['''
+   41 |+def f(a: Foo[(
+42 42 |     Bar
+43 43 |     [
+44 44 |     Multi |
+45 45 |     Line
+46    |-    ]  # Comment''']): ...
+   46 |+    ]  # Comment
+   47 |+)]): ...
+47 48 | 
+48 49 | 
+49 50 | a: '''list
+
+UP037_2.pyi:49:4: UP037 [*] Remove quotes from type annotation
+   |
+49 |   a: '''list
+   |  ____^
+50 | | [int]''' = [42]
+   | |________^ UP037
+   |
+   = help: Remove quotes
+
+ℹ Safe fix
+46 46 |     ]  # Comment''']): ...
+47 47 | 
+48 48 | 
+49    |-a: '''list
+50    |-[int]''' = [42]
+   49 |+a: (list
+   50 |+[int]) = [42]

crates/ruff_linter/src/rules/refurb/rules/unnecessary_from_float.rs

@@ -1,10 +1,12 @@
 use ruff_macros::{ViolationMetadata, derive_message_formats};
 use ruff_python_ast::{self as ast, Expr, ExprCall};
+use ruff_python_semantic::analyze::type_inference::{NumberLike, PythonType, ResolvedPythonType};
+use ruff_python_semantic::analyze::typing;
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 use crate::linter::float::as_non_finite_float_string_literal;
-use crate::{Edit, Fix, FixAvailability, Violation};
+use crate::{Applicability, Edit, Fix, FixAvailability, Violation};
 
 /// ## What it does
 /// Checks for unnecessary `from_float` and `from_decimal` usages to construct
@@ -16,6 +18,12 @@ use crate::{Edit, Fix, FixAvailability, Violation};
 /// the use of `from_float` and `from_decimal` methods is unnecessary, and
 /// should be avoided in favor of the more concise constructor syntax.
 ///
+/// However, there are important behavioral differences between the `from_*` methods
+/// and the constructors:
+/// - The `from_*` methods validate their argument types and raise `TypeError` for invalid types
+/// - The constructors accept broader argument types without validation
+/// - The `from_*` methods have different parameter names than the constructors
+///
 /// ## Example
 /// ```python
 /// Decimal.from_float(4.2)
@@ -32,6 +40,16 @@ use crate::{Edit, Fix, FixAvailability, Violation};
 /// Fraction(Decimal(4.2))
 /// ```
 ///
+/// ## Fix safety
+/// This rule's fix is marked as unsafe by default because:
+/// - The `from_*` methods provide type validation that the constructors don't
+/// - Removing type validation can change program behavior
+/// - The parameter names are different between methods and constructors
+///
+/// The fix is marked as safe only when:
+/// - The argument type is known to be valid for the target constructor
+/// - No keyword arguments are used, or they match the constructor's parameters
+///
 /// ## References
 /// - [Python documentation: `decimal`](https://docs.python.org/3/library/decimal.html)
 /// - [Python documentation: `fractions`](https://docs.python.org/3/library/fractions.html)
@@ -101,62 +119,178 @@ pub(crate) fn unnecessary_from_float(checker: &Checker, call: &ExprCall) {
         call.range(),
     );
 
-    let edit = Edit::range_replacement(
-        checker.locator().slice(&**value).to_string(),
-        call.func.range(),
-    );
+    // Validate that the method call has correct arguments and get the argument value
+    let Some(arg_value) = has_valid_method_arguments(call, method_name, constructor) else {
+        // Don't suggest a fix for invalid calls
+        return;
+    };
 
-    // Short-circuit case for special values, such as: `Decimal.from_float(float("inf"))` to `Decimal("inf")`.
-    'short_circuit: {
-        if !matches!(constructor, Constructor::Decimal) {
-            break 'short_circuit;
-        }
-        if !(method_name == MethodName::FromFloat) {
-            break 'short_circuit;
-        }
-
-        let Some(value) = (match method_name {
-            MethodName::FromFloat => call.arguments.find_argument_value("f", 0),
-            MethodName::FromDecimal => call.arguments.find_argument_value("dec", 0),
-        }) else {
-            return;
-        };
-
-        let Expr::Call(
-            call @ ast::ExprCall {
-                func, arguments, ..
-            },
-        ) = value
-        else {
-            break 'short_circuit;
-        };
-
-        // Must have exactly one argument, which is a string literal.
-        if !arguments.keywords.is_empty() {
-            break 'short_circuit;
-        }
-        let [float] = arguments.args.as_ref() else {
-            break 'short_circuit;
-        };
-        if as_non_finite_float_string_literal(float).is_none() {
-            break 'short_circuit;
-        }
-
-        // Must be a call to the `float` builtin.
-        if !semantic.match_builtin_expr(func, "float") {
-            break 'short_circuit;
-        }
-
-        let replacement = checker.locator().slice(float).to_string();
-        diagnostic.set_fix(Fix::safe_edits(
-            edit,
-            [Edit::range_replacement(replacement, call.range())],
-        ));
+    let constructor_name = checker.locator().slice(&**value).to_string();
 
+    // Special case for non-finite float literals: Decimal.from_float(float("inf")) -> Decimal("inf")
+    if let Some(replacement) = handle_non_finite_float_special_case(
+        call,
+        method_name,
+        constructor,
+        arg_value,
+        &constructor_name,
+        checker,
+    ) {
+        diagnostic.set_fix(Fix::safe_edit(replacement));
         return;
     }
 
-    diagnostic.set_fix(Fix::safe_edit(edit));
+    // Check if we should suppress the fix due to type validation concerns
+    let is_type_safe = is_valid_argument_type(arg_value, method_name, constructor, checker);
+    let has_keywords = !call.arguments.keywords.is_empty();
+
+    // Determine fix safety
+    let applicability = if is_type_safe && !has_keywords {
+        Applicability::Safe
+    } else {
+        Applicability::Unsafe
+    };
+
+    // Build the replacement
+    let arg_text = checker.locator().slice(arg_value);
+    let replacement_text = format!("{constructor_name}({arg_text})");
+
+    let edit = Edit::range_replacement(replacement_text, call.range());
+
+    diagnostic.set_fix(Fix::applicable_edit(edit, applicability));
+}
+
+/// Check if the argument would be valid for the target constructor
+fn is_valid_argument_type(
+    arg_expr: &Expr,
+    method_name: MethodName,
+    constructor: Constructor,
+    checker: &Checker,
+) -> bool {
+    let semantic = checker.semantic();
+    let resolved_type = ResolvedPythonType::from(arg_expr);
+
+    let (is_int, is_float) = if let ResolvedPythonType::Unknown = resolved_type {
+        arg_expr
+            .as_name_expr()
+            .and_then(|name| semantic.only_binding(name).map(|id| semantic.binding(id)))
+            .map(|binding| {
+                (
+                    typing::is_int(binding, semantic),
+                    typing::is_float(binding, semantic),
+                )
+            })
+            .unwrap_or_default()
+    } else {
+        (false, false)
+    };
+
+    match (method_name, constructor) {
+        // Decimal.from_float accepts int, bool, float
+        (MethodName::FromFloat, Constructor::Decimal) => match resolved_type {
+            ResolvedPythonType::Atom(PythonType::Number(
+                NumberLike::Integer | NumberLike::Bool | NumberLike::Float,
+            )) => true,
+            ResolvedPythonType::Unknown => is_int || is_float,
+            _ => false,
+        },
+        // Fraction.from_float accepts int, bool, float
+        (MethodName::FromFloat, Constructor::Fraction) => match resolved_type {
+            ResolvedPythonType::Atom(PythonType::Number(
+                NumberLike::Integer | NumberLike::Bool | NumberLike::Float,
+            )) => true,
+            ResolvedPythonType::Unknown => is_int || is_float,
+            _ => false,
+        },
+        // Fraction.from_decimal accepts int, bool, Decimal
+        (MethodName::FromDecimal, Constructor::Fraction) => match resolved_type {
+            ResolvedPythonType::Atom(PythonType::Number(
+                NumberLike::Integer | NumberLike::Bool,
+            )) => true,
+            ResolvedPythonType::Unknown => is_int,
+            _ => {
+                // Check if it's a Decimal instance
+                arg_expr
+                    .as_call_expr()
+                    .and_then(|call| semantic.resolve_qualified_name(&call.func))
+                    .is_some_and(|qualified_name| {
+                        matches!(qualified_name.segments(), ["decimal", "Decimal"])
+                    })
+            }
+        },
+        _ => false,
+    }
+}
+
+/// Check if the call has valid arguments for the from_* method
+fn has_valid_method_arguments(
+    call: &ExprCall,
+    method_name: MethodName,
+    constructor: Constructor,
+) -> Option<&Expr> {
+    if call.arguments.len() != 1 {
+        return None;
+    }
+
+    match method_name {
+        MethodName::FromFloat => {
+            // Decimal.from_float is positional-only; Fraction.from_float allows keyword 'f'.
+            if constructor == Constructor::Decimal {
+                // Only allow positional argument for Decimal.from_float
+                call.arguments.find_positional(0)
+            } else {
+                // Fraction.from_float allows either positional or 'f' keyword
+                call.arguments.find_argument_value("f", 0)
+            }
+        }
+        MethodName::FromDecimal => {
+            // from_decimal(dec) - should have exactly one positional argument or 'dec' keyword
+            call.arguments.find_argument_value("dec", 0)
+        }
+    }
+}
+
+/// Handle the special case for non-finite float literals
+fn handle_non_finite_float_special_case(
+    call: &ExprCall,
+    method_name: MethodName,
+    constructor: Constructor,
+    arg_value: &Expr,
+    constructor_name: &str,
+    checker: &Checker,
+) -> Option<Edit> {
+    // Only applies to Decimal.from_float
+    if !matches!(
+        (method_name, constructor),
+        (MethodName::FromFloat, Constructor::Decimal)
+    ) {
+        return None;
+    }
+
+    let Expr::Call(ast::ExprCall {
+        func, arguments, ..
+    }) = arg_value
+    else {
+        return None;
+    };
+
+    // Must be a call to the `float` builtin.
+    if !checker.semantic().match_builtin_expr(func, "float") {
+        return None;
+    }
+
+    // Must have exactly one argument, which is a string literal.
+    if !arguments.keywords.is_empty() {
+        return None;
+    }
+    let [float_arg] = arguments.args.as_ref() else {
+        return None;
+    };
+    as_non_finite_float_string_literal(float_arg)?;
+
+    let replacement_arg = checker.locator().slice(float_arg).to_string();
+    let replacement_text = format!("{constructor_name}({replacement_arg})");
+    Some(Edit::range_replacement(replacement_text, call.range()))
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]

crates/ruff_linter/src/rules/refurb/snapshots/ruff_linter__rules__refurb__tests__FURB164_FURB164.py.snap

@@ -95,7 +95,7 @@ FURB164.py:11:5: FURB164 [*] Verbose method `from_decimal` in `Fraction` constru
    |
    = help: Replace with `Fraction` constructor
 
-ℹ Safe fix
+ℹ Unsafe fix
 8  8  | _ = Fraction.from_float(-0.5)
 9  9  | _ = Fraction.from_float(5.0)
 10 10 | _ = fractions.Fraction.from_float(4.2)
@@ -116,7 +116,7 @@ FURB164.py:12:5: FURB164 [*] Verbose method `from_decimal` in `Fraction` constru
    |
    = help: Replace with `Fraction` constructor
 
-ℹ Safe fix
+ℹ Unsafe fix
 9  9  | _ = Fraction.from_float(5.0)
 10 10 | _ = fractions.Fraction.from_float(4.2)
 11 11 | _ = Fraction.from_decimal(Decimal("4.2"))
@@ -137,7 +137,7 @@ FURB164.py:13:5: FURB164 [*] Verbose method `from_decimal` in `Fraction` constru
    |
    = help: Replace with `Fraction` constructor
 
-ℹ Safe fix
+ℹ Unsafe fix
 10 10 | _ = fractions.Fraction.from_float(4.2)
 11 11 | _ = Fraction.from_decimal(Decimal("4.2"))
 12 12 | _ = Fraction.from_decimal(Decimal("-4.2"))
@@ -459,7 +459,7 @@ FURB164.py:27:5: FURB164 [*] Verbose method `from_float` in `Decimal` constructi
    27 |+_ = Decimal("  InfinIty \n\t ")
 28 28 | _ = Decimal.from_float(float("   -InfinIty\n \t"))
 29 29 | 
-30 30 | # OK
+30 30 | # Cases with keyword arguments - should produce unsafe fixes
 
 FURB164.py:28:5: FURB164 [*] Verbose method `from_float` in `Decimal` construction
    |
@@ -468,7 +468,7 @@ FURB164.py:28:5: FURB164 [*] Verbose method `from_float` in `Decimal` constructi
 28 | _ = Decimal.from_float(float("   -InfinIty\n \t"))
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FURB164
 29 |
-30 | # OK
+30 | # Cases with keyword arguments - should produce unsafe fixes
    |
    = help: Replace with `Decimal` constructor
 
@@ -479,5 +479,136 @@ FURB164.py:28:5: FURB164 [*] Verbose method `from_float` in `Decimal` constructi
 28    |-_ = Decimal.from_float(float("   -InfinIty\n \t"))
    28 |+_ = Decimal("   -InfinIty\n \t")
 29 29 | 
-30 30 | # OK
-31 31 | _ = Fraction(0.1)
+30 30 | # Cases with keyword arguments - should produce unsafe fixes
+31 31 | _ = Fraction.from_decimal(dec=Decimal("4.2"))
+
+FURB164.py:31:5: FURB164 [*] Verbose method `from_decimal` in `Fraction` construction
+   |
+30 | # Cases with keyword arguments - should produce unsafe fixes
+31 | _ = Fraction.from_decimal(dec=Decimal("4.2"))
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FURB164
+32 | _ = Decimal.from_float(f=4.2)
+   |
+   = help: Replace with `Fraction` constructor
+
+ℹ Unsafe fix
+28 28 | _ = Decimal.from_float(float("   -InfinIty\n \t"))
+29 29 | 
+30 30 | # Cases with keyword arguments - should produce unsafe fixes
+31    |-_ = Fraction.from_decimal(dec=Decimal("4.2"))
+   31 |+_ = Fraction(Decimal("4.2"))
+32 32 | _ = Decimal.from_float(f=4.2)
+33 33 | 
+34 34 | # Cases with invalid argument counts - should not get fixes
+
+FURB164.py:32:5: FURB164 Verbose method `from_float` in `Decimal` construction
+   |
+30 | # Cases with keyword arguments - should produce unsafe fixes
+31 | _ = Fraction.from_decimal(dec=Decimal("4.2"))
+32 | _ = Decimal.from_float(f=4.2)
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ FURB164
+33 |
+34 | # Cases with invalid argument counts - should not get fixes
+   |
+   = help: Replace with `Decimal` constructor
+
+FURB164.py:35:5: FURB164 Verbose method `from_decimal` in `Fraction` construction
+   |
+34 | # Cases with invalid argument counts - should not get fixes
+35 | _ = Fraction.from_decimal(Decimal("4.2"), 1)
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FURB164
+36 | _ = Decimal.from_float(4.2, None)
+   |
+   = help: Replace with `Fraction` constructor
+
+FURB164.py:36:5: FURB164 Verbose method `from_float` in `Decimal` construction
+   |
+34 | # Cases with invalid argument counts - should not get fixes
+35 | _ = Fraction.from_decimal(Decimal("4.2"), 1)
+36 | _ = Decimal.from_float(4.2, None)
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FURB164
+37 |
+38 | # Cases with wrong keyword arguments - should not get fixes  
+   |
+   = help: Replace with `Decimal` constructor
+
+FURB164.py:39:5: FURB164 Verbose method `from_decimal` in `Fraction` construction
+   |
+38 | # Cases with wrong keyword arguments - should not get fixes  
+39 | _ = Fraction.from_decimal(numerator=Decimal("4.2"))
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FURB164
+40 | _ = Decimal.from_float(value=4.2)
+   |
+   = help: Replace with `Fraction` constructor
+
+FURB164.py:40:5: FURB164 Verbose method `from_float` in `Decimal` construction
+   |
+38 | # Cases with wrong keyword arguments - should not get fixes  
+39 | _ = Fraction.from_decimal(numerator=Decimal("4.2"))
+40 | _ = Decimal.from_float(value=4.2)
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FURB164
+41 |
+42 | # Cases with type validation issues - should produce unsafe fixes
+   |
+   = help: Replace with `Decimal` constructor
+
+FURB164.py:43:5: FURB164 [*] Verbose method `from_float` in `Decimal` construction
+   |
+42 | # Cases with type validation issues - should produce unsafe fixes
+43 | _ = Decimal.from_float("4.2")  # Invalid type for from_float
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ FURB164
+44 | _ = Fraction.from_decimal(4.2)  # Invalid type for from_decimal
+45 | _ = Fraction.from_float("4.2")  # Invalid type for from_float
+   |
+   = help: Replace with `Decimal` constructor
+
+ℹ Unsafe fix
+40 40 | _ = Decimal.from_float(value=4.2)
+41 41 | 
+42 42 | # Cases with type validation issues - should produce unsafe fixes
+43    |-_ = Decimal.from_float("4.2")  # Invalid type for from_float
+   43 |+_ = Decimal("4.2")  # Invalid type for from_float
+44 44 | _ = Fraction.from_decimal(4.2)  # Invalid type for from_decimal
+45 45 | _ = Fraction.from_float("4.2")  # Invalid type for from_float
+46 46 | 
+
+FURB164.py:44:5: FURB164 [*] Verbose method `from_decimal` in `Fraction` construction
+   |
+42 | # Cases with type validation issues - should produce unsafe fixes
+43 | _ = Decimal.from_float("4.2")  # Invalid type for from_float
+44 | _ = Fraction.from_decimal(4.2)  # Invalid type for from_decimal
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ FURB164
+45 | _ = Fraction.from_float("4.2")  # Invalid type for from_float
+   |
+   = help: Replace with `Fraction` constructor
+
+ℹ Unsafe fix
+41 41 | 
+42 42 | # Cases with type validation issues - should produce unsafe fixes
+43 43 | _ = Decimal.from_float("4.2")  # Invalid type for from_float
+44    |-_ = Fraction.from_decimal(4.2)  # Invalid type for from_decimal
+   44 |+_ = Fraction(4.2)  # Invalid type for from_decimal
+45 45 | _ = Fraction.from_float("4.2")  # Invalid type for from_float
+46 46 | 
+47 47 | # OK - should not trigger the rule
+
+FURB164.py:45:5: FURB164 [*] Verbose method `from_float` in `Fraction` construction
+   |
+43 | _ = Decimal.from_float("4.2")  # Invalid type for from_float
+44 | _ = Fraction.from_decimal(4.2)  # Invalid type for from_decimal
+45 | _ = Fraction.from_float("4.2")  # Invalid type for from_float
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ FURB164
+46 |
+47 | # OK - should not trigger the rule
+   |
+   = help: Replace with `Fraction` constructor
+
+ℹ Unsafe fix
+42 42 | # Cases with type validation issues - should produce unsafe fixes
+43 43 | _ = Decimal.from_float("4.2")  # Invalid type for from_float
+44 44 | _ = Fraction.from_decimal(4.2)  # Invalid type for from_decimal
+45    |-_ = Fraction.from_float("4.2")  # Invalid type for from_float
+   45 |+_ = Fraction("4.2")  # Invalid type for from_float
+46 46 | 
+47 47 | # OK - should not trigger the rule
+48 48 | _ = Fraction(0.1)

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

@@ -599,4 +599,24 @@ mod tests {
         assert_diagnostics!(snapshot, diagnostics);
         Ok(())
     }
+
+    #[test_case(Rule::ImplicitOptional, Path::new("RUF013_0.py"))]
+    #[test_case(Rule::ImplicitOptional, Path::new("RUF013_1.py"))]
+    #[test_case(Rule::ImplicitOptional, Path::new("RUF013_2.py"))]
+    #[test_case(Rule::ImplicitOptional, Path::new("RUF013_3.py"))]
+    #[test_case(Rule::ImplicitOptional, Path::new("RUF013_4.py"))]
+    fn ruf013_add_future_import(rule_code: Rule, path: &Path) -> Result<()> {
+        let snapshot = format!("add_future_import_{}", path.to_string_lossy());
+        let diagnostics = test_path(
+            Path::new("ruff").join(path).as_path(),
+            &settings::LinterSettings {
+                preview: PreviewMode::Enabled,
+                future_annotations: true,
+                unresolved_target_version: PythonVersion::PY39.into(),
+                ..settings::LinterSettings::for_rule(rule_code)
+            },
+        )?;
+        assert_diagnostics!(snapshot, diagnostics);
+        Ok(())
+    }
 }

crates/ruff_linter/src/rules/ruff/rules/implicit_optional.rs

@@ -71,6 +71,13 @@ use crate::rules::ruff::typing::type_hint_explicitly_allows_none;
 ///
 /// ## Options
 /// - `target-version`
+/// - `lint.future-annotations`
+///
+/// ## Preview
+///
+/// When [preview] is enabled, if [`lint.future-annotations`] is set to `true`,
+/// `from __future__ import annotations` will be added if doing so would allow using the `|`
+/// operator on a Python version before 3.10.
 ///
 /// ## Fix safety
 ///
@@ -136,10 +143,15 @@ fn generate_fix(checker: &Checker, conversion_type: ConversionType, expr: &Expr)
                 node_index: ruff_python_ast::AtomicNodeIndex::dummy(),
             });
             let content = checker.generator().expr(&new_expr);
-            Ok(Fix::unsafe_edit(Edit::range_replacement(
-                content,
-                expr.range(),
-            )))
+            let edit = Edit::range_replacement(content, expr.range());
+            if checker.target_version() < PythonVersion::PY310 {
+                Ok(Fix::unsafe_edits(
+                    edit,
+                    [checker.importer().add_future_import()],
+                ))
+            } else {
+                Ok(Fix::unsafe_edit(edit))
+            }
         }
         ConversionType::Optional => {
             let importer = checker
@@ -187,6 +199,7 @@ pub(crate) fn implicit_optional(checker: &Checker, parameters: &Parameters) {
                 ) else {
                     continue;
                 };
+
                 let conversion_type = checker.target_version().into();
 
                 let mut diagnostic =
@@ -202,7 +215,14 @@ pub(crate) fn implicit_optional(checker: &Checker, parameters: &Parameters) {
             else {
                 continue;
             };
-            let conversion_type = checker.target_version().into();
+
+            let conversion_type = if checker.target_version() >= PythonVersion::PY310
+                || checker.settings().future_annotations()
+            {
+                ConversionType::BinOpOr
+            } else {
+                ConversionType::Optional
+            };
 
             let mut diagnostic =
                 checker.report_diagnostic(ImplicitOptional { conversion_type }, expr.range());

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__add_future_import_RUF013_0.py.snap

@@ -0,0 +1,445 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+RUF013_0.py:20:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+   |
+20 | def f(arg: int = None):  # RUF013
+   |            ^^^ RUF013
+21 |     pass
+   |
+   = help: Convert to `T | None`
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2  3  | 
+3  4  | 
+--------------------------------------------------------------------------------
+17 18 |     pass
+18 19 | 
+19 20 | 
+20    |-def f(arg: int = None):  # RUF013
+   21 |+def f(arg: int | None = None):  # RUF013
+21 22 |     pass
+22 23 | 
+23 24 | 
+
+RUF013_0.py:24:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+   |
+24 | def f(arg: str = None):  # RUF013
+   |            ^^^ RUF013
+25 |     pass
+   |
+   = help: Convert to `T | None`
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2  3  | 
+3  4  | 
+--------------------------------------------------------------------------------
+21 22 |     pass
+22 23 | 
+23 24 | 
+24    |-def f(arg: str = None):  # RUF013
+   25 |+def f(arg: str | None = None):  # RUF013
+25 26 |     pass
+26 27 | 
+27 28 | 
+
+RUF013_0.py:28:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+   |
+28 | def f(arg: Tuple[str] = None):  # RUF013
+   |            ^^^^^^^^^^ RUF013
+29 |     pass
+   |
+   = help: Convert to `T | None`
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2  3  | 
+3  4  | 
+--------------------------------------------------------------------------------
+25 26 |     pass
+26 27 | 
+27 28 | 
+28    |-def f(arg: Tuple[str] = None):  # RUF013
+   29 |+def f(arg: Tuple[str] | None = None):  # RUF013
+29 30 |     pass
+30 31 | 
+31 32 | 
+
+RUF013_0.py:58:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+   |
+58 | def f(arg: Union = None):  # RUF013
+   |            ^^^^^ RUF013
+59 |     pass
+   |
+   = help: Convert to `T | None`
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2  3  | 
+3  4  | 
+--------------------------------------------------------------------------------
+55 56 |     pass
+56 57 | 
+57 58 | 
+58    |-def f(arg: Union = None):  # RUF013
+   59 |+def f(arg: Union | None = None):  # RUF013
+59 60 |     pass
+60 61 | 
+61 62 | 
+
+RUF013_0.py:62:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+   |
+62 | def f(arg: Union[int] = None):  # RUF013
+   |            ^^^^^^^^^^ RUF013
+63 |     pass
+   |
+   = help: Convert to `T | None`
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2  3  | 
+3  4  | 
+--------------------------------------------------------------------------------
+59 60 |     pass
+60 61 | 
+61 62 | 
+62    |-def f(arg: Union[int] = None):  # RUF013
+   63 |+def f(arg: Union[int] | None = None):  # RUF013
+63 64 |     pass
+64 65 | 
+65 66 | 
+
+RUF013_0.py:66:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+   |
+66 | def f(arg: Union[int, str] = None):  # RUF013
+   |            ^^^^^^^^^^^^^^^ RUF013
+67 |     pass
+   |
+   = help: Convert to `T | None`
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2  3  | 
+3  4  | 
+--------------------------------------------------------------------------------
+63 64 |     pass
+64 65 | 
+65 66 | 
+66    |-def f(arg: Union[int, str] = None):  # RUF013
+   67 |+def f(arg: Union[int, str] | None = None):  # RUF013
+67 68 |     pass
+68 69 | 
+69 70 | 
+
+RUF013_0.py:85:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+   |
+85 | def f(arg: int | float = None):  # RUF013
+   |            ^^^^^^^^^^^ RUF013
+86 |     pass
+   |
+   = help: Convert to `T | None`
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2  3  | 
+3  4  | 
+--------------------------------------------------------------------------------
+82 83 |     pass
+83 84 | 
+84 85 | 
+85    |-def f(arg: int | float = None):  # RUF013
+   86 |+def f(arg: int | float | None = None):  # RUF013
+86 87 |     pass
+87 88 | 
+88 89 | 
+
+RUF013_0.py:89:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+   |
+89 | def f(arg: int | float | str | bytes = None):  # RUF013
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^ RUF013
+90 |     pass
+   |
+   = help: Convert to `T | None`
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2  3  | 
+3  4  | 
+--------------------------------------------------------------------------------
+86 87 |     pass
+87 88 | 
+88 89 | 
+89    |-def f(arg: int | float | str | bytes = None):  # RUF013
+   90 |+def f(arg: int | float | str | bytes | None = None):  # RUF013
+90 91 |     pass
+91 92 | 
+92 93 | 
+
+RUF013_0.py:108:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+    |
+108 | def f(arg: Literal[1] = None):  # RUF013
+    |            ^^^^^^^^^^ RUF013
+109 |     pass
+    |
+    = help: Convert to `T | None`
+
+ℹ Unsafe fix
+    1   |+from __future__ import annotations
+1   2   | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2   3   | 
+3   4   | 
+--------------------------------------------------------------------------------
+105 106 |     pass
+106 107 | 
+107 108 | 
+108     |-def f(arg: Literal[1] = None):  # RUF013
+    109 |+def f(arg: Literal[1] | None = None):  # RUF013
+109 110 |     pass
+110 111 | 
+111 112 | 
+
+RUF013_0.py:112:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+    |
+112 | def f(arg: Literal[1, "foo"] = None):  # RUF013
+    |            ^^^^^^^^^^^^^^^^^ RUF013
+113 |     pass
+    |
+    = help: Convert to `T | None`
+
+ℹ Unsafe fix
+    1   |+from __future__ import annotations
+1   2   | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2   3   | 
+3   4   | 
+--------------------------------------------------------------------------------
+109 110 |     pass
+110 111 | 
+111 112 | 
+112     |-def f(arg: Literal[1, "foo"] = None):  # RUF013
+    113 |+def f(arg: Literal[1, "foo"] | None = None):  # RUF013
+113 114 |     pass
+114 115 | 
+115 116 | 
+
+RUF013_0.py:131:22: RUF013 [*] PEP 484 prohibits implicit `Optional`
+    |
+131 | def f(arg: Annotated[int, ...] = None):  # RUF013
+    |                      ^^^ RUF013
+132 |     pass
+    |
+    = help: Convert to `T | None`
+
+ℹ Unsafe fix
+    1   |+from __future__ import annotations
+1   2   | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2   3   | 
+3   4   | 
+--------------------------------------------------------------------------------
+128 129 |     pass
+129 130 | 
+130 131 | 
+131     |-def f(arg: Annotated[int, ...] = None):  # RUF013
+    132 |+def f(arg: Annotated[int | None, ...] = None):  # RUF013
+132 133 |     pass
+133 134 | 
+134 135 | 
+
+RUF013_0.py:135:32: RUF013 [*] PEP 484 prohibits implicit `Optional`
+    |
+135 | def f(arg: Annotated[Annotated[int | str, ...], ...] = None):  # RUF013
+    |                                ^^^^^^^^^ RUF013
+136 |     pass
+    |
+    = help: Convert to `T | None`
+
+ℹ Unsafe fix
+    1   |+from __future__ import annotations
+1   2   | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2   3   | 
+3   4   | 
+--------------------------------------------------------------------------------
+132 133 |     pass
+133 134 | 
+134 135 | 
+135     |-def f(arg: Annotated[Annotated[int | str, ...], ...] = None):  # RUF013
+    136 |+def f(arg: Annotated[Annotated[int | str | None, ...], ...] = None):  # RUF013
+136 137 |     pass
+137 138 | 
+138 139 | 
+
+RUF013_0.py:151:11: RUF013 [*] PEP 484 prohibits implicit `Optional`
+    |
+150 | def f(
+151 |     arg1: int = None,  # RUF013
+    |           ^^^ RUF013
+152 |     arg2: Union[int, float] = None,  # RUF013
+153 |     arg3: Literal[1, 2, 3] = None,  # RUF013
+    |
+    = help: Convert to `T | None`
+
+ℹ Unsafe fix
+    1   |+from __future__ import annotations
+1   2   | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2   3   | 
+3   4   | 
+--------------------------------------------------------------------------------
+148 149 | 
+149 150 | 
+150 151 | def f(
+151     |-    arg1: int = None,  # RUF013
+    152 |+    arg1: int | None = None,  # RUF013
+152 153 |     arg2: Union[int, float] = None,  # RUF013
+153 154 |     arg3: Literal[1, 2, 3] = None,  # RUF013
+154 155 | ):
+
+RUF013_0.py:152:11: RUF013 [*] PEP 484 prohibits implicit `Optional`
+    |
+150 | def f(
+151 |     arg1: int = None,  # RUF013
+152 |     arg2: Union[int, float] = None,  # RUF013
+    |           ^^^^^^^^^^^^^^^^^ RUF013
+153 |     arg3: Literal[1, 2, 3] = None,  # RUF013
+154 | ):
+    |
+    = help: Convert to `T | None`
+
+ℹ Unsafe fix
+    1   |+from __future__ import annotations
+1   2   | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2   3   | 
+3   4   | 
+--------------------------------------------------------------------------------
+149 150 | 
+150 151 | def f(
+151 152 |     arg1: int = None,  # RUF013
+152     |-    arg2: Union[int, float] = None,  # RUF013
+    153 |+    arg2: Union[int, float] | None = None,  # RUF013
+153 154 |     arg3: Literal[1, 2, 3] = None,  # RUF013
+154 155 | ):
+155 156 |     pass
+
+RUF013_0.py:153:11: RUF013 [*] PEP 484 prohibits implicit `Optional`
+    |
+151 |     arg1: int = None,  # RUF013
+152 |     arg2: Union[int, float] = None,  # RUF013
+153 |     arg3: Literal[1, 2, 3] = None,  # RUF013
+    |           ^^^^^^^^^^^^^^^^ RUF013
+154 | ):
+155 |     pass
+    |
+    = help: Convert to `T | None`
+
+ℹ Unsafe fix
+    1   |+from __future__ import annotations
+1   2   | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2   3   | 
+3   4   | 
+--------------------------------------------------------------------------------
+150 151 | def f(
+151 152 |     arg1: int = None,  # RUF013
+152 153 |     arg2: Union[int, float] = None,  # RUF013
+153     |-    arg3: Literal[1, 2, 3] = None,  # RUF013
+    154 |+    arg3: Literal[1, 2, 3] | None = None,  # RUF013
+154 155 | ):
+155 156 |     pass
+156 157 | 
+
+RUF013_0.py:181:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+    |
+181 | def f(arg: Union[Annotated[int, ...], Union[str, bytes]] = None):  # RUF013
+    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ RUF013
+182 |     pass
+    |
+    = help: Convert to `T | None`
+
+ℹ Unsafe fix
+    1   |+from __future__ import annotations
+1   2   | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2   3   | 
+3   4   | 
+--------------------------------------------------------------------------------
+178 179 |     pass
+179 180 | 
+180 181 | 
+181     |-def f(arg: Union[Annotated[int, ...], Union[str, bytes]] = None):  # RUF013
+    182 |+def f(arg: Union[Annotated[int, ...], Union[str, bytes]] | None = None):  # RUF013
+182 183 |     pass
+183 184 | 
+184 185 | 
+
+RUF013_0.py:188:13: RUF013 [*] PEP 484 prohibits implicit `Optional`
+    |
+188 | def f(arg: "int" = None):  # RUF013
+    |             ^^^ RUF013
+189 |     pass
+    |
+    = help: Convert to `Optional[T]`
+
+ℹ Unsafe fix
+185 185 | # Quoted
+186 186 | 
+187 187 | 
+188     |-def f(arg: "int" = None):  # RUF013
+    188 |+def f(arg: "Optional[int]" = None):  # RUF013
+189 189 |     pass
+190 190 | 
+191 191 | 
+
+RUF013_0.py:192:13: RUF013 [*] PEP 484 prohibits implicit `Optional`
+    |
+192 | def f(arg: "str" = None):  # RUF013
+    |             ^^^ RUF013
+193 |     pass
+    |
+    = help: Convert to `Optional[T]`
+
+ℹ Unsafe fix
+189 189 |     pass
+190 190 | 
+191 191 | 
+192     |-def f(arg: "str" = None):  # RUF013
+    192 |+def f(arg: "Optional[str]" = None):  # RUF013
+193 193 |     pass
+194 194 | 
+195 195 | 
+
+RUF013_0.py:196:12: RUF013 PEP 484 prohibits implicit `Optional`
+    |
+196 | def f(arg: "st" "r" = None):  # RUF013
+    |            ^^^^^^^^ RUF013
+197 |     pass
+    |
+    = help: Convert to `Optional[T]`
+
+RUF013_0.py:204:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+    |
+204 | def f(arg: Union["int", "str"] = None):  # RUF013
+    |            ^^^^^^^^^^^^^^^^^^^ RUF013
+205 |     pass
+    |
+    = help: Convert to `T | None`
+
+ℹ Unsafe fix
+    1   |+from __future__ import annotations
+1   2   | from typing import Annotated, Any, Literal, Optional, Tuple, Union, Hashable
+2   3   | 
+3   4   | 
+--------------------------------------------------------------------------------
+201 202 |     pass
+202 203 | 
+203 204 | 
+204     |-def f(arg: Union["int", "str"] = None):  # RUF013
+    205 |+def f(arg: Union["int", "str"] | None = None):  # RUF013
+205 206 |     pass
+206 207 | 
+207 208 |

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__add_future_import_RUF013_1.py.snap

@@ -0,0 +1,19 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+RUF013_1.py:4:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+  |
+4 | def f(arg: int = None):  # RUF013
+  |            ^^^ RUF013
+5 |     pass
+  |
+  = help: Convert to `T | None`
+
+ℹ Unsafe fix
+1 1 | # No `typing.Optional` import
+  2 |+from __future__ import annotations
+2 3 | 
+3 4 | 
+4   |-def f(arg: int = None):  # RUF013
+  5 |+def f(arg: int | None = None):  # RUF013
+5 6 |     pass

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__add_future_import_RUF013_2.py.snap

@@ -0,0 +1,4 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__add_future_import_RUF013_3.py.snap

@@ -0,0 +1,65 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+RUF013_3.py:4:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+  |
+4 | def f(arg: typing.List[str] = None):  # RUF013
+  |            ^^^^^^^^^^^^^^^^ RUF013
+5 |     pass
+  |
+  = help: Convert to `T | None`
+
+ℹ Unsafe fix
+  1 |+from __future__ import annotations
+1 2 | import typing
+2 3 | 
+3 4 | 
+4   |-def f(arg: typing.List[str] = None):  # RUF013
+  5 |+def f(arg: typing.List[str] | None = None):  # RUF013
+5 6 |     pass
+6 7 | 
+7 8 | 
+
+RUF013_3.py:22:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+   |
+22 | def f(arg: typing.Union[int, str] = None):  # RUF013
+   |            ^^^^^^^^^^^^^^^^^^^^^^ RUF013
+23 |     pass
+   |
+   = help: Convert to `T | None`
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | import typing
+2  3  | 
+3  4  | 
+--------------------------------------------------------------------------------
+19 20 |     pass
+20 21 | 
+21 22 | 
+22    |-def f(arg: typing.Union[int, str] = None):  # RUF013
+   23 |+def f(arg: typing.Union[int, str] | None = None):  # RUF013
+23 24 |     pass
+24 25 | 
+25 26 | 
+
+RUF013_3.py:29:12: RUF013 [*] PEP 484 prohibits implicit `Optional`
+   |
+29 | def f(arg: typing.Literal[1, "foo", True] = None):  # RUF013
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ RUF013
+30 |     pass
+   |
+   = help: Convert to `T | None`
+
+ℹ Unsafe fix
+   1  |+from __future__ import annotations
+1  2  | import typing
+2  3  | 
+3  4  | 
+--------------------------------------------------------------------------------
+26 27 | # Literal
+27 28 | 
+28 29 | 
+29    |-def f(arg: typing.Literal[1, "foo", True] = None):  # RUF013
+   30 |+def f(arg: typing.Literal[1, "foo", True] | None = None):  # RUF013
+30 31 |     pass

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__add_future_import_RUF013_4.py.snap

@@ -0,0 +1,25 @@
+---
+source: crates/ruff_linter/src/rules/ruff/mod.rs
+---
+RUF013_4.py:15:61: RUF013 [*] PEP 484 prohibits implicit `Optional`
+   |
+15 | def multiple_2(arg1: Optional, arg2: Optional = None, arg3: int = None): ...
+   |                                                             ^^^ RUF013
+   |
+   = help: Convert to `T | None`
+
+ℹ Unsafe fix
+1  1  | # https://github.com/astral-sh/ruff/issues/13833
+   2  |+from __future__ import annotations
+2  3  | 
+3  4  | from typing import Optional
+4  5  | 
+--------------------------------------------------------------------------------
+12 13 | def multiple_1(arg1: Optional, arg2: Optional = None): ...
+13 14 | 
+14 15 | 
+15    |-def multiple_2(arg1: Optional, arg2: Optional = None, arg3: int = None): ...
+   16 |+def multiple_2(arg1: Optional, arg2: Optional = None, arg3: int | None = None): ...
+16 17 | 
+17 18 | 
+18 19 | def return_type(arg: Optional = None) -> Optional: ...

crates/ruff_linter/src/settings/mod.rs

@@ -210,6 +210,7 @@ macro_rules! display_settings {
 }
 
 #[derive(Debug, Clone, CacheKey)]
+#[expect(clippy::struct_excessive_bools)]
 pub struct LinterSettings {
     pub exclude: FilePatternSet,
     pub extension: ExtensionMapping,
@@ -251,6 +252,7 @@ pub struct LinterSettings {
     pub task_tags: Vec<String>,
     pub typing_modules: Vec<String>,
     pub typing_extensions: bool,
+    pub future_annotations: bool,
 
     // Plugins
     pub flake8_annotations: flake8_annotations::settings::Settings,
@@ -453,6 +455,7 @@ impl LinterSettings {
             explicit_preview_rules: false,
             extension: ExtensionMapping::default(),
             typing_extensions: true,
+            future_annotations: false,
         }
     }
 
@@ -472,6 +475,11 @@ impl LinterSettings {
             .is_match(path)
             .map_or(self.unresolved_target_version, TargetVersion::from)
     }
+
+    pub fn future_annotations(&self) -> bool {
+        // TODO(brent) we can just access the field directly once this is stabilized.
+        self.future_annotations && crate::preview::is_add_future_annotations_imports_enabled(self)
+    }
 }
 
 impl Default for LinterSettings {

crates/ruff_wasm/Cargo.toml

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

crates/ruff_wasm/src/lib.rs

@@ -77,10 +77,31 @@ struct ExpandedEdit {
     content: Option<String>,
 }
 
+/// Perform global constructor initialization.
+#[cfg(target_family = "wasm")]
+#[expect(unsafe_code)]
+pub fn before_main() {
+    unsafe extern "C" {
+        fn __wasm_call_ctors();
+    }
+
+    // Salsa uses the `inventory` crate, which registers global constructors that may need to be
+    // called explicitly on WASM. See <https://github.com/dtolnay/inventory/blob/master/src/lib.rs#L105>
+    // for details.
+    unsafe {
+        __wasm_call_ctors();
+    }
+}
+
+#[cfg(not(target_family = "wasm"))]
+pub fn before_main() {}
+
 #[wasm_bindgen(start)]
 pub fn run() {
     use log::Level;
 
+    before_main();
+
     // When the `console_error_panic_hook` feature is enabled, we can call the
     // `set_panic_hook` function at least once during initialization, and then
     // we will get better error messages if our code ever panics.

crates/ruff_wasm/tests/api.rs

@@ -21,6 +21,8 @@ macro_rules! check {
 
 #[wasm_bindgen_test]
 fn empty_config() {
+    ruff_wasm::before_main();
+
     check!(
         "if (1, 2):\n    pass",
         r#"{}"#,
@@ -42,6 +44,8 @@ fn empty_config() {
 
 #[wasm_bindgen_test]
 fn syntax_error() {
+    ruff_wasm::before_main();
+
     check!(
         "x =\ny = 1\n",
         r#"{}"#,
@@ -63,6 +67,8 @@ fn syntax_error() {
 
 #[wasm_bindgen_test]
 fn unsupported_syntax_error() {
+    ruff_wasm::before_main();
+
     check!(
         "match 2:\n    case 1: ...",
         r#"{"target-version": "py39"}"#,
@@ -84,11 +90,15 @@ fn unsupported_syntax_error() {
 
 #[wasm_bindgen_test]
 fn partial_config() {
+    ruff_wasm::before_main();
+
     check!("if (1, 2):\n    pass", r#"{"ignore": ["F"]}"#, []);
 }
 
 #[wasm_bindgen_test]
 fn partial_nested_config() {
+    ruff_wasm::before_main();
+
     let config = r#"{
           "select": ["Q"],
           "flake8-quotes": {

crates/ruff_workspace/src/configuration.rs

@@ -250,6 +250,14 @@ impl Configuration {
 
         conflicting_import_settings(&isort, &flake8_import_conventions)?;
 
+        let future_annotations = lint.future_annotations.unwrap_or_default();
+        if lint_preview.is_disabled() && future_annotations {
+            warn_user_once!(
+                "The `lint.future-annotations` setting will have no effect \
+                    because `preview` is disabled"
+            );
+        }
+
         Ok(Settings {
             cache_dir: self
                 .cache_dir
@@ -432,6 +440,7 @@ impl Configuration {
                     .map(RuffOptions::into_settings)
                     .unwrap_or_default(),
                 typing_extensions: lint.typing_extensions.unwrap_or(true),
+                future_annotations,
             },
 
             formatter,
@@ -636,6 +645,7 @@ pub struct LintConfiguration {
     pub task_tags: Option<Vec<String>>,
     pub typing_modules: Option<Vec<String>>,
     pub typing_extensions: Option<bool>,
+    pub future_annotations: Option<bool>,
 
     // Plugins
     pub flake8_annotations: Option<Flake8AnnotationsOptions>,
@@ -752,6 +762,7 @@ impl LintConfiguration {
             logger_objects: options.common.logger_objects,
             typing_modules: options.common.typing_modules,
             typing_extensions: options.typing_extensions,
+            future_annotations: options.future_annotations,
 
             // Plugins
             flake8_annotations: options.common.flake8_annotations,
@@ -1179,6 +1190,7 @@ impl LintConfiguration {
             pyupgrade: self.pyupgrade.combine(config.pyupgrade),
             ruff: self.ruff.combine(config.ruff),
             typing_extensions: self.typing_extensions.or(config.typing_extensions),
+            future_annotations: self.future_annotations.or(config.future_annotations),
         }
     }
 }

crates/ruff_workspace/src/options.rs

@@ -529,6 +529,24 @@ pub struct LintOptions {
         "#
     )]
     pub typing_extensions: Option<bool>,
+
+    /// Whether to allow rules to add `from __future__ import annotations` in cases where this would
+    /// simplify a fix or enable a new diagnostic.
+    ///
+    /// For example, `TC001`, `TC002`, and `TC003` can move more imports into `TYPE_CHECKING` blocks
+    /// if `__future__` annotations are enabled.
+    ///
+    /// This setting is currently in [preview](https://docs.astral.sh/ruff/preview/) and requires
+    /// preview mode to be enabled to have any effect.
+    #[option(
+        default = "false",
+        value_type = "bool",
+        example = r#"
+            # Enable `from __future__ import annotations` imports
+            future-annotations = true
+        "#
+    )]
+    pub future_annotations: Option<bool>,
 }
 
 /// Newtype wrapper for [`LintCommonOptions`] that allows customizing the JSON schema and omitting the fields from the [`OptionsMetadata`].
@@ -3896,6 +3914,7 @@ pub struct LintOptionsWire {
     ruff: Option<RuffOptions>,
     preview: Option<bool>,
     typing_extensions: Option<bool>,
+    future_annotations: Option<bool>,
 }
 
 impl From<LintOptionsWire> for LintOptions {
@@ -3951,6 +3970,7 @@ impl From<LintOptionsWire> for LintOptions {
             ruff,
             preview,
             typing_extensions,
+            future_annotations,
         } = value;
 
         LintOptions {
@@ -4007,6 +4027,7 @@ impl From<LintOptionsWire> for LintOptions {
             ruff,
             preview,
             typing_extensions,
+            future_annotations,
         }
     }
 }

crates/ty/docs/rules.md

@@ -36,7 +36,7 @@ def test(): -> "int":
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20call-non-callable) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L99)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L100)
 </small>
 
 **What it does**
@@ -58,7 +58,7 @@ Calling a non-callable object will raise a `TypeError` at runtime.
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20conflicting-argument-forms) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L143)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L144)
 </small>
 
 **What it does**
@@ -88,7 +88,7 @@ f(int)  # error
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20conflicting-declarations) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L169)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L170)
 </small>
 
 **What it does**
@@ -117,7 +117,7 @@ a = 1
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20conflicting-metaclass) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L194)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L195)
 </small>
 
 **What it does**
@@ -147,7 +147,7 @@ class C(A, B): ...
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20cyclic-class-definition) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L220)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L221)
 </small>
 
 **What it does**
@@ -177,7 +177,7 @@ class B(A): ...
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20duplicate-base) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L264)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L286)
 </small>
 
 **What it does**
@@ -202,7 +202,7 @@ class B(A, A): ...
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20duplicate-kw-only) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L285)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L307)
 </small>
 
 **What it does**
@@ -306,7 +306,7 @@ def test(): -> "Literal[5]":
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20inconsistent-mro) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L427)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L449)
 </small>
 
 **What it does**
@@ -334,7 +334,7 @@ class C(A, B): ...
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20index-out-of-bounds) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L451)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L473)
 </small>
 
 **What it does**
@@ -358,7 +358,7 @@ t[3]  # IndexError: tuple index out of range
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20instance-layout-conflict) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L317)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L339)
 </small>
 
 **What it does**
@@ -445,7 +445,7 @@ an atypical memory layout.
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-argument-type) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L471)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L493)
 </small>
 
 **What it does**
@@ -470,7 +470,7 @@ func("foo")  # error: [invalid-argument-type]
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-assignment) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L511)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L533)
 </small>
 
 **What it does**
@@ -496,7 +496,7 @@ a: int = ''
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-attribute-access) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1515)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1537)
 </small>
 
 **What it does**
@@ -528,7 +528,7 @@ C.instance_var = 3  # error: Cannot assign to instance variable
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-base) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L533)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L555)
 </small>
 
 **What it does**
@@ -550,7 +550,7 @@ class A(42): ...  # error: [invalid-base]
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-context-manager) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L584)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L606)
 </small>
 
 **What it does**
@@ -575,7 +575,7 @@ with 1:
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-declaration) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L605)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L627)
 </small>
 
 **What it does**
@@ -602,7 +602,7 @@ a: str
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-exception-caught) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L628)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L650)
 </small>
 
 **What it does**
@@ -644,7 +644,7 @@ except ZeroDivisionError:
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-generic-class) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L664)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L686)
 </small>
 
 **What it does**
@@ -675,7 +675,7 @@ class C[U](Generic[T]): ...
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-legacy-type-variable) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L690)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L712)
 </small>
 
 **What it does**
@@ -708,7 +708,7 @@ def f(t: TypeVar("U")): ...
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-metaclass) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L739)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L761)
 </small>
 
 **What it does**
@@ -740,7 +740,7 @@ class B(metaclass=f): ...
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-overload) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L766)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L788)
 </small>
 
 **What it does**
@@ -788,7 +788,7 @@ def foo(x: int) -> int: ...
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-parameter-default) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L809)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L831)
 </small>
 
 **What it does**
@@ -812,7 +812,7 @@ def f(a: int = ''): ...
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-protocol) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L399)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L421)
 </small>
 
 **What it does**
@@ -844,7 +844,7 @@ TypeError: Protocols can only inherit from other protocols, got <class 'int'>
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-raise) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L829)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L851)
 </small>
 
 Checks for `raise` statements that raise non-exceptions or use invalid
@@ -891,7 +891,7 @@ def g():
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-return-type) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L492)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L514)
 </small>
 
 **What it does**
@@ -914,7 +914,7 @@ def func() -> int:
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-super-argument) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L872)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L894)
 </small>
 
 **What it does**
@@ -968,7 +968,7 @@ TODO #14889
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-type-alias-type) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L718)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L740)
 </small>
 
 **What it does**
@@ -993,7 +993,7 @@ NewAlias = TypeAliasType(get_name(), int)        # error: TypeAliasType name mus
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-type-checking-constant) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L911)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L933)
 </small>
 
 **What it does**
@@ -1021,7 +1021,7 @@ TYPE_CHECKING = ''
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-type-form) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L935)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L957)
 </small>
 
 **What it does**
@@ -1049,7 +1049,7 @@ b: Annotated[int]  # `Annotated` expects at least two arguments
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-type-guard-call) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L987)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1009)
 </small>
 
 **What it does**
@@ -1081,7 +1081,7 @@ f(10)  # Error
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-type-guard-definition) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L959)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L981)
 </small>
 
 **What it does**
@@ -1113,7 +1113,7 @@ class C:
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20invalid-type-variable-constraints) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1015)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1037)
 </small>
 
 **What it does**
@@ -1146,7 +1146,7 @@ T = TypeVar('T', bound=str)  # valid bound TypeVar
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20missing-argument) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1044)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1066)
 </small>
 
 **What it does**
@@ -1169,7 +1169,7 @@ func()  # TypeError: func() missing 1 required positional argument: 'x'
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20no-matching-overload) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1063)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1085)
 </small>
 
 **What it does**
@@ -1196,7 +1196,7 @@ func("string")  # error: [no-matching-overload]
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20non-subscriptable) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1086)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1108)
 </small>
 
 **What it does**
@@ -1218,7 +1218,7 @@ Subscripting an object that does not support it will raise a `TypeError` at runt
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20not-iterable) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1104)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1126)
 </small>
 
 **What it does**
@@ -1242,7 +1242,7 @@ for i in 34:  # TypeError: 'int' object is not iterable
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20parameter-already-assigned) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1155)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1177)
 </small>
 
 **What it does**
@@ -1296,7 +1296,7 @@ def test(): -> "int":
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20static-assert-error) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1491)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1513)
 </small>
 
 **What it does**
@@ -1324,7 +1324,7 @@ static_assert(int(2.0 * 3.0) == 6)  # error: does not have a statically known tr
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20subclass-of-final-class) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1246)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1268)
 </small>
 
 **What it does**
@@ -1351,7 +1351,7 @@ class B(A): ...  # Error raised here
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20too-many-positional-arguments) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1291)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1313)
 </small>
 
 **What it does**
@@ -1376,7 +1376,7 @@ f("foo")  # Error raised here
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20type-assertion-failure) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1269)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1291)
 </small>
 
 **What it does**
@@ -1402,7 +1402,7 @@ def _(x: int):
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20unavailable-implicit-super-arguments) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1312)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1334)
 </small>
 
 **What it does**
@@ -1446,7 +1446,7 @@ class A:
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20unknown-argument) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1369)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1391)
 </small>
 
 **What it does**
@@ -1471,7 +1471,7 @@ f(x=1, y=2)  # Error raised here
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20unresolved-attribute) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1390)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1412)
 </small>
 
 **What it does**
@@ -1497,7 +1497,7 @@ A().foo  # AttributeError: 'A' object has no attribute 'foo'
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20unresolved-import) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1412)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1434)
 </small>
 
 **What it does**
@@ -1520,7 +1520,7 @@ import foo  # ModuleNotFoundError: No module named 'foo'
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20unresolved-reference) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1431)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1453)
 </small>
 
 **What it does**
@@ -1543,7 +1543,7 @@ print(x)  # NameError: name 'x' is not defined
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20unsupported-bool-conversion) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1124)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1146)
 </small>
 
 **What it does**
@@ -1578,7 +1578,7 @@ b1 < b2 < b1  # exception raised here
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20unsupported-operator) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1450)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1472)
 </small>
 
 **What it does**
@@ -1604,7 +1604,7 @@ A() + A()  # TypeError: unsupported operand type(s) for +: 'A' and 'A'
 <small>
 Default level: [`error`](../rules.md#rule-levels "This lint has a default level of 'error'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20zero-stepsize-in-slice) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1472)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1494)
 </small>
 
 **What it does**
@@ -1622,6 +1622,31 @@ l = list(range(10))
 l[1:10:0]  # ValueError: slice step cannot be zero
 ```
 
+## `deprecated`
+
+<small>
+Default level: [`warn`](../rules.md#rule-levels "This lint has a default level of 'warn'.") ·
+[Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20deprecated) ·
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L265)
+</small>
+
+**What it does**
+
+Checks for uses of deprecated items
+
+**Why is this bad?**
+
+Deprecated items should no longer be used.
+
+**Examples**
+
+```python
+@warnings.deprecated("use new_func instead")
+def old_func(): ...
+
+old_func()  # emits [deprecated] diagnostic
+```
+
 ## `invalid-ignore-comment`
 
 <small>
@@ -1655,7 +1680,7 @@ a = 20 / 0  # type: ignore
 <small>
 Default level: [`warn`](../rules.md#rule-levels "This lint has a default level of 'warn'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20possibly-unbound-attribute) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1176)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1198)
 </small>
 
 **What it does**
@@ -1681,7 +1706,7 @@ A.c  # AttributeError: type object 'A' has no attribute 'c'
 <small>
 Default level: [`warn`](../rules.md#rule-levels "This lint has a default level of 'warn'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20possibly-unbound-implicit-call) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L117)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L118)
 </small>
 
 **What it does**
@@ -1711,7 +1736,7 @@ A()[0]  # TypeError: 'A' object is not subscriptable
 <small>
 Default level: [`warn`](../rules.md#rule-levels "This lint has a default level of 'warn'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20possibly-unbound-import) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1198)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1220)
 </small>
 
 **What it does**
@@ -1741,7 +1766,7 @@ from module import a  # ImportError: cannot import name 'a' from 'module'
 <small>
 Default level: [`warn`](../rules.md#rule-levels "This lint has a default level of 'warn'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20redundant-cast) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1543)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1565)
 </small>
 
 **What it does**
@@ -1766,7 +1791,7 @@ cast(int, f())  # Redundant
 <small>
 Default level: [`warn`](../rules.md#rule-levels "This lint has a default level of 'warn'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20undefined-reveal) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1351)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1373)
 </small>
 
 **What it does**
@@ -1817,7 +1842,7 @@ a = 20 / 0  # ty: ignore[division-by-zero]
 <small>
 Default level: [`warn`](../rules.md#rule-levels "This lint has a default level of 'warn'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20unresolved-global) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1564)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1586)
 </small>
 
 **What it does**
@@ -1871,7 +1896,7 @@ def g():
 <small>
 Default level: [`warn`](../rules.md#rule-levels "This lint has a default level of 'warn'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20unsupported-base) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L551)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L573)
 </small>
 
 **What it does**
@@ -1908,7 +1933,7 @@ class D(C): ...  # error: [unsupported-base]
 <small>
 Default level: [`ignore`](../rules.md#rule-levels "This lint has a default level of 'ignore'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20division-by-zero) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L246)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L247)
 </small>
 
 **What it does**
@@ -1930,7 +1955,7 @@ Dividing by zero raises a `ZeroDivisionError` at runtime.
 <small>
 Default level: [`ignore`](../rules.md#rule-levels "This lint has a default level of 'ignore'.") ·
 [Related issues](https://github.com/astral-sh/ty/issues?q=sort%3Aupdated-desc%20is%3Aissue%20is%3Aopen%20possibly-unresolved-reference) ·
-[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1224)
+[View source](https://github.com/astral-sh/ruff/blob/main/crates%2Fty_python_semantic%2Fsrc%2Ftypes%2Fdiagnostic.rs#L1246)
 </small>
 
 **What it does**

crates/ty/tests/cli/main.rs

@@ -660,7 +660,7 @@ fn can_handle_large_binop_expressions() -> anyhow::Result<()> {
      --> test.py:4:13
       |
     2 | from typing_extensions import reveal_type
-    3 | total = 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1...
+    3 | total = 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 +…
     4 | reveal_type(total)
       |             ^^^^^ `Literal[2000]`
       |

crates/ty/tests/file_watching.rs

@@ -15,7 +15,7 @@ use ty_project::metadata::pyproject::{PyProject, Tool};
 use ty_project::metadata::value::{RangedValue, RelativePathBuf};
 use ty_project::watch::{ChangeEvent, ProjectWatcher, directory_watcher};
 use ty_project::{Db, ProjectDatabase, ProjectMetadata};
-use ty_python_semantic::{ModuleName, PythonPlatform, resolve_module};
+use ty_python_semantic::{Module, ModuleName, PythonPlatform, resolve_module};
 
 struct TestCase {
     db: ProjectDatabase,
@@ -40,6 +40,14 @@ impl TestCase {
         &self.db
     }
 
+    /// Stops file-watching and returns the collected change events.
+    ///
+    /// The caller must pass a `MatchEvent` filter that is applied to
+    /// the change events returned. To get all change events, use `|_:
+    /// &ChangeEvent| true`. If possible, callers should pass a filter for a
+    /// specific file name, e.g., `event_for_file("foo.py")`. When done this
+    /// way, the watcher will specifically try to wait for a change event
+    /// matching the filter. This can help avoid flakes.
     #[track_caller]
     fn stop_watch<M>(&mut self, matcher: M) -> Vec<ChangeEvent>
     where
@@ -1877,3 +1885,156 @@ fn rename_files_casing_only() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+/// This tests that retrieving submodules from a module has its cache
+/// appropriately invalidated after a file is created.
+#[test]
+fn submodule_cache_invalidation_created() -> anyhow::Result<()> {
+    let mut case = setup([("lib.py", ""), ("bar/__init__.py", ""), ("bar/foo.py", "")])?;
+    let module = resolve_module(case.db(), &ModuleName::new("bar").unwrap()).expect("`bar` module");
+    let get_submodules = |db: &dyn Db, module: &Module| {
+        let mut names = module
+            .all_submodules(db)
+            .iter()
+            .map(|name| name.as_str().to_string())
+            .collect::<Vec<String>>();
+        names.sort();
+        names.join("\n")
+    };
+
+    insta::assert_snapshot!(
+        get_submodules(case.db(), &module),
+        @"foo",
+    );
+
+    std::fs::write(case.project_path("bar/wazoo.py").as_std_path(), "")?;
+    let changes = case.stop_watch(event_for_file("wazoo.py"));
+    case.apply_changes(changes, None);
+
+    insta::assert_snapshot!(
+        get_submodules(case.db(), &module),
+        @r"
+    foo
+    wazoo
+    ",
+    );
+
+    Ok(())
+}
+
+/// This tests that retrieving submodules from a module has its cache
+/// appropriately invalidated after a file is deleted.
+#[test]
+fn submodule_cache_invalidation_deleted() -> anyhow::Result<()> {
+    let mut case = setup([
+        ("lib.py", ""),
+        ("bar/__init__.py", ""),
+        ("bar/foo.py", ""),
+        ("bar/wazoo.py", ""),
+    ])?;
+    let module = resolve_module(case.db(), &ModuleName::new("bar").unwrap()).expect("`bar` module");
+    let get_submodules = |db: &dyn Db, module: &Module| {
+        let mut names = module
+            .all_submodules(db)
+            .iter()
+            .map(|name| name.as_str().to_string())
+            .collect::<Vec<String>>();
+        names.sort();
+        names.join("\n")
+    };
+
+    insta::assert_snapshot!(
+        get_submodules(case.db(), &module),
+        @r"
+    foo
+    wazoo
+    ",
+    );
+
+    std::fs::remove_file(case.project_path("bar/wazoo.py").as_std_path())?;
+    let changes = case.stop_watch(event_for_file("wazoo.py"));
+    case.apply_changes(changes, None);
+
+    insta::assert_snapshot!(
+        get_submodules(case.db(), &module),
+        @"foo",
+    );
+
+    Ok(())
+}
+
+/// This tests that retrieving submodules from a module has its cache
+/// appropriately invalidated after a file is created and then deleted.
+#[test]
+fn submodule_cache_invalidation_created_then_deleted() -> anyhow::Result<()> {
+    let mut case = setup([("lib.py", ""), ("bar/__init__.py", ""), ("bar/foo.py", "")])?;
+    let module = resolve_module(case.db(), &ModuleName::new("bar").unwrap()).expect("`bar` module");
+    let get_submodules = |db: &dyn Db, module: &Module| {
+        let mut names = module
+            .all_submodules(db)
+            .iter()
+            .map(|name| name.as_str().to_string())
+            .collect::<Vec<String>>();
+        names.sort();
+        names.join("\n")
+    };
+
+    insta::assert_snapshot!(
+        get_submodules(case.db(), &module),
+        @"foo",
+    );
+
+    std::fs::write(case.project_path("bar/wazoo.py").as_std_path(), "")?;
+    let changes = case.take_watch_changes(event_for_file("wazoo.py"));
+    case.apply_changes(changes, None);
+
+    std::fs::remove_file(case.project_path("bar/wazoo.py").as_std_path())?;
+    let changes = case.stop_watch(event_for_file("wazoo.py"));
+    case.apply_changes(changes, None);
+
+    insta::assert_snapshot!(
+        get_submodules(case.db(), &module),
+        @"foo",
+    );
+
+    Ok(())
+}
+
+/// This tests that retrieving submodules from a module has its cache
+/// appropriately invalidated after a file is created *after* a project
+/// configuration change.
+#[test]
+fn submodule_cache_invalidation_after_pyproject_created() -> anyhow::Result<()> {
+    let mut case = setup([("lib.py", ""), ("bar/__init__.py", ""), ("bar/foo.py", "")])?;
+    let module = resolve_module(case.db(), &ModuleName::new("bar").unwrap()).expect("`bar` module");
+    let get_submodules = |db: &dyn Db, module: &Module| {
+        let mut names = module
+            .all_submodules(db)
+            .iter()
+            .map(|name| name.as_str().to_string())
+            .collect::<Vec<String>>();
+        names.sort();
+        names.join("\n")
+    };
+
+    insta::assert_snapshot!(
+        get_submodules(case.db(), &module),
+        @"foo",
+    );
+
+    case.update_options(Options::default())?;
+
+    std::fs::write(case.project_path("bar/wazoo.py").as_std_path(), "")?;
+    let changes = case.take_watch_changes(event_for_file("wazoo.py"));
+    case.apply_changes(changes, None);
+
+    insta::assert_snapshot!(
+        get_submodules(case.db(), &module),
+        @r"
+    foo
+    wazoo
+    ",
+    );
+
+    Ok(())
+}

crates/ty_ide/src/db.rs

@@ -96,7 +96,7 @@ pub(crate) mod tests {
 
     #[salsa::db]
     impl SemanticDb for TestDb {
-        fn is_file_open(&self, file: File) -> bool {
+        fn should_check_file(&self, file: File) -> bool {
             !file.path(self).is_vendored_path()
         }
 

crates/ty_ide/src/find_node.rs

@@ -112,6 +112,12 @@ impl<'a> CoveringNode<'a> {
         Ok(self)
     }
 
+    /// Returns an iterator over the ancestor nodes, starting from the root
+    /// and ending with the covering node.
+    pub(crate) fn ancestors(&self) -> impl Iterator<Item = AnyNodeRef<'a>> + '_ {
+        self.nodes.iter().copied()
+    }
+
     /// Finds the index of the node that fully covers the range and
     /// fulfills the given predicate.
     ///

crates/ty_ide/src/goto_definition.rs

@@ -0,0 +1,31 @@
+use crate::goto::find_goto_target;
+use crate::stub_mapping::StubMapper;
+use crate::{Db, NavigationTargets, RangedValue};
+use ruff_db::files::{File, FileRange};
+use ruff_db::parsed::parsed_module;
+use ruff_text_size::{Ranged, TextSize};
+
+/// Navigate to the definition of a symbol.
+///
+/// A "definition" is the actual implementation of a symbol, potentially in a source file
+/// rather than a stub file. This differs from "declaration" which may navigate to stub files.
+/// When possible, this function will map from stub file declarations to their corresponding
+/// source file implementations using the `StubMapper`.
+pub fn goto_definition(
+    db: &dyn Db,
+    file: File,
+    offset: TextSize,
+) -> Option<RangedValue<NavigationTargets>> {
+    let module = parsed_module(db, file).load(db);
+    let goto_target = find_goto_target(&module, offset)?;
+
+    // Create a StubMapper to map from stub files to source files
+    let stub_mapper = StubMapper::new(db);
+
+    let definition_targets = goto_target.get_definition_targets(file, db, Some(&stub_mapper))?;
+
+    Some(RangedValue {
+        range: FileRange::new(file, goto_target.range()),
+        value: definition_targets,
+    })
+}

crates/ty_ide/src/goto_type_definition.rs

@@ -0,0 +1,661 @@
+use crate::goto::find_goto_target;
+use crate::{Db, HasNavigationTargets, NavigationTargets, RangedValue};
+use ruff_db::files::{File, FileRange};
+use ruff_db::parsed::parsed_module;
+use ruff_text_size::{Ranged, TextSize};
+use ty_python_semantic::SemanticModel;
+
+pub fn goto_type_definition(
+    db: &dyn Db,
+    file: File,
+    offset: TextSize,
+) -> Option<RangedValue<NavigationTargets>> {
+    let module = parsed_module(db, file).load(db);
+    let goto_target = find_goto_target(&module, offset)?;
+
+    let model = SemanticModel::new(db, file);
+    let ty = goto_target.inferred_type(&model)?;
+
+    tracing::debug!("Inferred type of covering node is {}", ty.display(db));
+
+    let navigation_targets = ty.navigation_targets(db);
+
+    Some(RangedValue {
+        range: FileRange::new(file, goto_target.range()),
+        value: navigation_targets,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{CursorTest, IntoDiagnostic, cursor_test};
+    use crate::{NavigationTarget, goto_type_definition};
+    use insta::assert_snapshot;
+    use ruff_db::diagnostic::{
+        Annotation, Diagnostic, DiagnosticId, LintName, Severity, Span, SubDiagnostic,
+    };
+    use ruff_db::files::FileRange;
+    use ruff_text_size::Ranged;
+
+    #[test]
+    fn goto_type_of_expression_with_class_type() {
+        let test = cursor_test(
+            r#"
+            class Test: ...
+
+            a<CURSOR>b = Test()
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r"
+        info[goto-type-definition]: Type definition
+         --> main.py:2:19
+          |
+        2 |             class Test: ...
+          |                   ^^^^
+        3 |
+        4 |             ab = Test()
+          |
+        info: Source
+         --> main.py:4:13
+          |
+        2 |             class Test: ...
+        3 |
+        4 |             ab = Test()
+          |             ^^
+          |
+        ");
+    }
+
+    #[test]
+    fn goto_type_of_expression_with_function_type() {
+        let test = cursor_test(
+            r#"
+            def foo(a, b): ...
+
+            ab = foo
+
+            a<CURSOR>b
+        "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r"
+        info[goto-type-definition]: Type definition
+         --> main.py:2:17
+          |
+        2 |             def foo(a, b): ...
+          |                 ^^^
+        3 |
+        4 |             ab = foo
+          |
+        info: Source
+         --> main.py:6:13
+          |
+        4 |             ab = foo
+        5 |
+        6 |             ab
+          |             ^^
+          |
+        ");
+    }
+
+    #[test]
+    fn goto_type_of_expression_with_union_type() {
+        let test = cursor_test(
+            r#"
+
+            def foo(a, b): ...
+
+            def bar(a, b): ...
+
+            if random.choice():
+                a = foo
+            else:
+                a = bar
+
+            a<CURSOR>
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r"
+        info[goto-type-definition]: Type definition
+         --> main.py:3:17
+          |
+        3 |             def foo(a, b): ...
+          |                 ^^^
+        4 |
+        5 |             def bar(a, b): ...
+          |
+        info: Source
+          --> main.py:12:13
+           |
+        10 |                 a = bar
+        11 |
+        12 |             a
+           |             ^
+           |
+
+        info[goto-type-definition]: Type definition
+         --> main.py:5:17
+          |
+        3 |             def foo(a, b): ...
+        4 |
+        5 |             def bar(a, b): ...
+          |                 ^^^
+        6 |
+        7 |             if random.choice():
+          |
+        info: Source
+          --> main.py:12:13
+           |
+        10 |                 a = bar
+        11 |
+        12 |             a
+           |             ^
+           |
+        ");
+    }
+
+    #[test]
+    fn goto_type_of_expression_with_module() {
+        let mut test = cursor_test(
+            r#"
+            import lib
+
+            lib<CURSOR>
+            "#,
+        );
+
+        test.write_file("lib.py", "a = 10").unwrap();
+
+        assert_snapshot!(test.goto_type_definition(), @r"
+        info[goto-type-definition]: Type definition
+         --> lib.py:1:1
+          |
+        1 | a = 10
+          | ^^^^^^
+          |
+        info: Source
+         --> main.py:4:13
+          |
+        2 |             import lib
+        3 |
+        4 |             lib
+          |             ^^^
+          |
+        ");
+    }
+
+    #[test]
+    fn goto_type_of_expression_with_literal_type() {
+        let test = cursor_test(
+            r#"
+            a: str = "test"
+
+            a<CURSOR>
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r#"
+        info[goto-type-definition]: Type definition
+           --> stdlib/builtins.pyi:892:7
+            |
+        890 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        891 |
+        892 | class str(Sequence[str]):
+            |       ^^^
+        893 |     """str(object='') -> str
+        894 |     str(bytes_or_buffer[, encoding[, errors]]) -> str
+            |
+        info: Source
+         --> main.py:4:13
+          |
+        2 |             a: str = "test"
+        3 |
+        4 |             a
+          |             ^
+          |
+        "#);
+    }
+    #[test]
+    fn goto_type_of_expression_with_literal_node() {
+        let test = cursor_test(
+            r#"
+            a: str = "te<CURSOR>st"
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r#"
+        info[goto-type-definition]: Type definition
+           --> stdlib/builtins.pyi:892:7
+            |
+        890 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        891 |
+        892 | class str(Sequence[str]):
+            |       ^^^
+        893 |     """str(object='') -> str
+        894 |     str(bytes_or_buffer[, encoding[, errors]]) -> str
+            |
+        info: Source
+         --> main.py:2:22
+          |
+        2 |             a: str = "test"
+          |                      ^^^^^^
+          |
+        "#);
+    }
+
+    #[test]
+    fn goto_type_of_expression_with_type_var_type() {
+        let test = cursor_test(
+            r#"
+            type Alias[T: int = bool] = list[T<CURSOR>]
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r"
+        info[goto-type-definition]: Type definition
+         --> main.py:2:24
+          |
+        2 |             type Alias[T: int = bool] = list[T]
+          |                        ^
+          |
+        info: Source
+         --> main.py:2:46
+          |
+        2 |             type Alias[T: int = bool] = list[T]
+          |                                              ^
+          |
+        ");
+    }
+
+    #[test]
+    fn goto_type_of_expression_with_type_param_spec() {
+        let test = cursor_test(
+            r#"
+            type Alias[**P = [int, str]] = Callable[P<CURSOR>, int]
+            "#,
+        );
+
+        // TODO: Goto type definition currently doesn't work for type param specs
+        // because the inference doesn't support them yet.
+        // This snapshot should show a single target pointing to `T`
+        assert_snapshot!(test.goto_type_definition(), @"No type definitions found");
+    }
+
+    #[test]
+    fn goto_type_of_expression_with_type_var_tuple() {
+        let test = cursor_test(
+            r#"
+            type Alias[*Ts = ()] = tuple[*Ts<CURSOR>]
+            "#,
+        );
+
+        // TODO: Goto type definition currently doesn't work for type var tuples
+        // because the inference doesn't support them yet.
+        // This snapshot should show a single target pointing to `T`
+        assert_snapshot!(test.goto_type_definition(), @"No type definitions found");
+    }
+
+    #[test]
+    fn goto_type_of_bare_type_alias_type() {
+        let test = cursor_test(
+            r#"
+            from typing_extensions import TypeAliasType
+
+            Alias = TypeAliasType("Alias", tuple[int, int])
+
+            Alias<CURSOR>
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r#"
+        info[goto-type-definition]: Type definition
+         --> main.py:4:13
+          |
+        2 |             from typing_extensions import TypeAliasType
+        3 |
+        4 |             Alias = TypeAliasType("Alias", tuple[int, int])
+          |             ^^^^^
+        5 |
+        6 |             Alias
+          |
+        info: Source
+         --> main.py:6:13
+          |
+        4 |             Alias = TypeAliasType("Alias", tuple[int, int])
+        5 |
+        6 |             Alias
+          |             ^^^^^
+          |
+        "#);
+    }
+
+    #[test]
+    fn goto_type_on_keyword_argument() {
+        let test = cursor_test(
+            r#"
+            def test(a: str): ...
+
+            test(a<CURSOR>= "123")
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r#"
+        info[goto-type-definition]: Type definition
+           --> stdlib/builtins.pyi:892:7
+            |
+        890 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        891 |
+        892 | class str(Sequence[str]):
+            |       ^^^
+        893 |     """str(object='') -> str
+        894 |     str(bytes_or_buffer[, encoding[, errors]]) -> str
+            |
+        info: Source
+         --> main.py:4:18
+          |
+        2 |             def test(a: str): ...
+        3 |
+        4 |             test(a= "123")
+          |                  ^
+          |
+        "#);
+    }
+
+    #[test]
+    fn goto_type_on_incorrectly_typed_keyword_argument() {
+        let test = cursor_test(
+            r#"
+            def test(a: str): ...
+
+            test(a<CURSOR>= 123)
+            "#,
+        );
+
+        // TODO: This should jump to `str` and not `int` because
+        //   the keyword is typed as a string. It's only the passed argument that
+        //   is an int. Navigating to `str` would match pyright's behavior.
+        assert_snapshot!(test.goto_type_definition(), @r#"
+        info[goto-type-definition]: Type definition
+           --> stdlib/builtins.pyi:338:7
+            |
+        336 | _LiteralInteger = _PositiveInteger | _NegativeInteger | Literal[0]  # noqa: Y026  # TODO: Use TypeAlias once mypy bugs are fixed
+        337 |
+        338 | class int:
+            |       ^^^
+        339 |     """int([x]) -> integer
+        340 |     int(x, base=10) -> integer
+            |
+        info: Source
+         --> main.py:4:18
+          |
+        2 |             def test(a: str): ...
+        3 |
+        4 |             test(a= 123)
+          |                  ^
+          |
+        "#);
+    }
+
+    #[test]
+    fn goto_type_on_kwargs() {
+        let test = cursor_test(
+            r#"
+            def f(name: str): ...
+
+kwargs = { "name": "test"}
+
+f(**kwargs<CURSOR>)
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r#"
+        info[goto-type-definition]: Type definition
+            --> stdlib/builtins.pyi:2892:7
+             |
+        2890 |         """See PEP 585"""
+        2891 |
+        2892 | class dict(MutableMapping[_KT, _VT]):
+             |       ^^^^
+        2893 |     """dict() -> new empty dictionary
+        2894 |     dict(mapping) -> new dictionary initialized from a mapping object's
+             |
+        info: Source
+         --> main.py:6:5
+          |
+        4 | kwargs = { "name": "test"}
+        5 |
+        6 | f(**kwargs)
+          |     ^^^^^^
+          |
+        "#);
+    }
+
+    #[test]
+    fn goto_type_of_expression_with_builtin() {
+        let test = cursor_test(
+            r#"
+            def foo(a: str):
+                a<CURSOR>
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r#"
+        info[goto-type-definition]: Type definition
+           --> stdlib/builtins.pyi:892:7
+            |
+        890 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        891 |
+        892 | class str(Sequence[str]):
+            |       ^^^
+        893 |     """str(object='') -> str
+        894 |     str(bytes_or_buffer[, encoding[, errors]]) -> str
+            |
+        info: Source
+         --> main.py:3:17
+          |
+        2 |             def foo(a: str):
+        3 |                 a
+          |                 ^
+          |
+        "#);
+    }
+
+    #[test]
+    fn goto_type_definition_cursor_between_object_and_attribute() {
+        let test = cursor_test(
+            r#"
+            class X:
+                def foo(a, b): ...
+
+            x = X()
+
+            x<CURSOR>.foo()
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r"
+        info[goto-type-definition]: Type definition
+         --> main.py:2:19
+          |
+        2 |             class X:
+          |                   ^
+        3 |                 def foo(a, b): ...
+          |
+        info: Source
+         --> main.py:7:13
+          |
+        5 |             x = X()
+        6 |
+        7 |             x.foo()
+          |             ^
+          |
+        ");
+    }
+
+    #[test]
+    fn goto_between_call_arguments() {
+        let test = cursor_test(
+            r#"
+            def foo(a, b): ...
+
+            foo<CURSOR>()
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r"
+        info[goto-type-definition]: Type definition
+         --> main.py:2:17
+          |
+        2 |             def foo(a, b): ...
+          |                 ^^^
+        3 |
+        4 |             foo()
+          |
+        info: Source
+         --> main.py:4:13
+          |
+        2 |             def foo(a, b): ...
+        3 |
+        4 |             foo()
+          |             ^^^
+          |
+        ");
+    }
+
+    #[test]
+    fn goto_type_narrowing() {
+        let test = cursor_test(
+            r#"
+            def foo(a: str | None, b):
+                if a is not None:
+                    print(a<CURSOR>)
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r#"
+        info[goto-type-definition]: Type definition
+           --> stdlib/builtins.pyi:892:7
+            |
+        890 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        891 |
+        892 | class str(Sequence[str]):
+            |       ^^^
+        893 |     """str(object='') -> str
+        894 |     str(bytes_or_buffer[, encoding[, errors]]) -> str
+            |
+        info: Source
+         --> main.py:4:27
+          |
+        2 |             def foo(a: str | None, b):
+        3 |                 if a is not None:
+        4 |                     print(a)
+          |                           ^
+          |
+        "#);
+    }
+
+    #[test]
+    fn goto_type_none() {
+        let test = cursor_test(
+            r#"
+            def foo(a: str | None, b):
+                a<CURSOR>
+            "#,
+        );
+
+        assert_snapshot!(test.goto_type_definition(), @r#"
+        info[goto-type-definition]: Type definition
+           --> stdlib/types.pyi:922:11
+            |
+        920 | if sys.version_info >= (3, 10):
+        921 |     @final
+        922 |     class NoneType:
+            |           ^^^^^^^^
+        923 |         """The type of the None singleton."""
+            |
+        info: Source
+         --> main.py:3:17
+          |
+        2 |             def foo(a: str | None, b):
+        3 |                 a
+          |                 ^
+          |
+
+        info[goto-type-definition]: Type definition
+           --> stdlib/builtins.pyi:892:7
+            |
+        890 |     def __getitem__(self, key: int, /) -> str | int | None: ...
+        891 |
+        892 | class str(Sequence[str]):
+            |       ^^^
+        893 |     """str(object='') -> str
+        894 |     str(bytes_or_buffer[, encoding[, errors]]) -> str
+            |
+        info: Source
+         --> main.py:3:17
+          |
+        2 |             def foo(a: str | None, b):
+        3 |                 a
+          |                 ^
+          |
+        "#);
+    }
+
+    impl CursorTest {
+        fn goto_type_definition(&self) -> String {
+            let Some(targets) =
+                goto_type_definition(&self.db, self.cursor.file, self.cursor.offset)
+            else {
+                return "No goto target found".to_string();
+            };
+
+            if targets.is_empty() {
+                return "No type definitions found".to_string();
+            }
+
+            let source = targets.range;
+            self.render_diagnostics(
+                targets
+                    .into_iter()
+                    .map(|target| GotoTypeDefinitionDiagnostic::new(source, &target)),
+            )
+        }
+    }
+
+    struct GotoTypeDefinitionDiagnostic {
+        source: FileRange,
+        target: FileRange,
+    }
+
+    impl GotoTypeDefinitionDiagnostic {
+        fn new(source: FileRange, target: &NavigationTarget) -> Self {
+            Self {
+                source,
+                target: FileRange::new(target.file(), target.focus_range()),
+            }
+        }
+    }
+
+    impl IntoDiagnostic for GotoTypeDefinitionDiagnostic {
+        fn into_diagnostic(self) -> Diagnostic {
+            let mut source = SubDiagnostic::new(Severity::Info, "Source");
+            source.annotate(Annotation::primary(
+                Span::from(self.source.file()).with_range(self.source.range()),
+            ));
+
+            let mut main = Diagnostic::new(
+                DiagnosticId::Lint(LintName::of("goto-type-definition")),
+                Severity::Info,
+                "Type definition".to_string(),
+            );
+            main.annotate(Annotation::primary(
+                Span::from(self.target.file()).with_range(self.target.range()),
+            ));
+            main.sub(source);
+
+            main
+        }
+    }
+}

crates/ty_ide/src/lib.rs

@@ -3,16 +3,20 @@ mod db;
 mod docstring;
 mod find_node;
 mod goto;
+mod goto_declaration;
+mod goto_definition;
+mod goto_type_definition;
 mod hover;
 mod inlay_hints;
 mod markup;
 mod semantic_tokens;
 mod signature_help;
+mod stub_mapping;
 
 pub use completion::completion;
 pub use db::Db;
 pub use docstring::get_parameter_documentation;
-pub use goto::goto_type_definition;
+pub use goto::{goto_declaration, goto_definition, goto_type_definition};
 pub use hover::hover;
 pub use inlay_hints::inlay_hints;
 pub use markup::MarkupKind;
@@ -101,11 +105,11 @@ pub struct NavigationTargets(smallvec::SmallVec<[NavigationTarget; 1]>);
 
 impl NavigationTargets {
     fn single(target: NavigationTarget) -> Self {
-        Self(smallvec::smallvec![target])
+        Self(smallvec::smallvec_inline![target])
     }
 
     fn empty() -> Self {
-        Self(smallvec::SmallVec::new())
+        Self(smallvec::SmallVec::new_const())
     }
 
     fn unique(targets: impl IntoIterator<Item = NavigationTarget>) -> Self {

crates/ty_ide/src/semantic_tokens.rs

@@ -482,25 +482,40 @@ impl<'db> SemanticTokenVisitor<'db> {
         parameters: &ast::Parameters,
         func: Option<&ast::StmtFunctionDef>,
     ) {
-        // Parameters
-        for (i, param) in parameters.args.iter().enumerate() {
-            let token_type = if let Some(func) = func {
-                // For function definitions, use the classification logic to determine
-                // whether this is a self/cls parameter or just a regular parameter
-                self.classify_parameter(&param.parameter, i == 0, func)
-            } else {
-                // For lambdas, all parameters are just parameters (no self/cls)
-                SemanticTokenType::Parameter
+        let mut param_index = 0;
+
+        for any_param in parameters {
+            let parameter = any_param.as_parameter();
+
+            let token_type = match any_param {
+                ast::AnyParameterRef::NonVariadic(_) => {
+                    // For non-variadic parameters (positional-only, regular, keyword-only),
+                    // check if this should be classified as self/cls parameter
+                    if let Some(func) = func {
+                        let result = self.classify_parameter(parameter, param_index == 0, func);
+                        param_index += 1;
+                        result
+                    } else {
+                        // For lambdas, all parameters are just parameters (no self/cls)
+                        param_index += 1;
+                        SemanticTokenType::Parameter
+                    }
+                }
+                ast::AnyParameterRef::Variadic(_) => {
+                    // Variadic parameters (*args, **kwargs) are always just parameters
+                    param_index += 1;
+                    SemanticTokenType::Parameter
+                }
             };
 
             self.add_token(
-                param.parameter.name.range(),
+                parameter.name.range(),
                 token_type,
                 SemanticTokenModifier::empty(),
             );
 
             // Handle parameter type annotations
-            if let Some(annotation) = &param.parameter.annotation {
+            if let Some(annotation) = &parameter.annotation {
                 self.visit_type_annotation(annotation);
             }
         }
@@ -977,7 +992,8 @@ class MyClass:
 class MyClass:
     def method(instance, x): pass
     @classmethod
-    def other(klass, y): pass<CURSOR>
+    def other(klass, y): pass
+    def complex_method(instance, posonly, /, regular, *args, kwonly, **kwargs): pass<CURSOR>
 ",
         );
 
@@ -992,6 +1008,13 @@ class MyClass:
         "other" @ 75..80: Method [definition]
         "klass" @ 81..86: ClsParameter
         "y" @ 88..89: Parameter
+        "complex_method" @ 105..119: Method [definition]
+        "instance" @ 120..128: SelfParameter
+        "posonly" @ 130..137: Parameter
+        "regular" @ 142..149: Parameter
+        "args" @ 152..156: Parameter
+        "kwonly" @ 158..164: Parameter
+        "kwargs" @ 168..174: Parameter
         "#);
     }
 
@@ -1665,6 +1688,12 @@ class BoundedContainer[T: int, U = str]:
         "P" @ 324..325: Variable
         "str" @ 327..330: Class
         "wrapper" @ 341..348: Function [definition]
+        "args" @ 350..354: Parameter
+        "P" @ 356..357: Variable
+        "args" @ 358..362: Variable
+        "kwargs" @ 366..372: Parameter
+        "P" @ 374..375: Variable
+        "kwargs" @ 376..382: Variable
         "str" @ 387..390: Class
         "str" @ 407..410: Class
         "func" @ 411..415: Variable

crates/ty_ide/src/stub_mapping.rs

@@ -0,0 +1,47 @@
+use ty_python_semantic::ResolvedDefinition;
+
+/// Maps `ResolvedDefinitions` from stub files to corresponding definitions in source files.
+///
+/// This mapper is used to implement "Go To Definition" functionality that navigates from
+/// stub file declarations to their actual implementations in source files. It also allows
+/// other language server providers (like hover, completion, and signature help) to find
+/// docstrings for functions that resolve to stubs.
+pub(crate) struct StubMapper<'db> {
+    #[allow(dead_code)] // Will be used when implementation is added
+    db: &'db dyn crate::Db,
+}
+
+impl<'db> StubMapper<'db> {
+    #[allow(dead_code)] // Will be used in the future
+    pub(crate) fn new(db: &'db dyn crate::Db) -> Self {
+        Self { db }
+    }
+
+    /// Map a `ResolvedDefinition` from a stub file to corresponding definitions in source files.
+    ///
+    /// If the definition is in a stub file and a corresponding source file definition exists,
+    /// returns the source file definition(s). Otherwise, returns the original definition.
+    #[allow(dead_code)] // Will be used when implementation is added
+    #[allow(clippy::unused_self)] // Will use self when implementation is added
+    pub(crate) fn map_definition(
+        &self,
+        def: ResolvedDefinition<'db>,
+    ) -> Vec<ResolvedDefinition<'db>> {
+        // TODO: Implement stub-to-source mapping logic
+        // For now, just return the original definition
+        vec![def]
+    }
+
+    /// Map multiple `ResolvedDefinitions`, applying stub-to-source mapping to each.
+    ///
+    /// This is a convenience method that applies `map_definition` to each element
+    /// in the input vector and flattens the results.
+    pub(crate) fn map_definitions(
+        &self,
+        defs: Vec<ResolvedDefinition<'db>>,
+    ) -> Vec<ResolvedDefinition<'db>> {
+        defs.into_iter()
+            .flat_map(|def| self.map_definition(def))
+            .collect()
+    }
+}