Update tests

## Summary

No behavior changes, but these need some refactoring to support
https://github.com/astral-sh/ruff/pull/6575 (namely, they need to take
the `ast::ExprCompare` or similar node instead of the attribute fields),
and I don't want to muddy that PR.

## Test Plan

`cargo test`

.github/release.yml

@@ -4,6 +4,7 @@ changelog:
     labels:
       - internal
       - documentation
+      - formatter
   categories:
     - title: Breaking Changes
       labels:

.github/workflows/benchmark.yaml

@@ -3,12 +3,12 @@ name: Benchmark
 on:
   pull_request:
     paths:
-      - 'Cargo.toml'
-      - 'Cargo.lock'
-      - 'rust-toolchain'
-      - 'crates/**'
-      - '!crates/ruff_dev'
-      - '!crates/ruff_shrinking'
+      - "Cargo.toml"
+      - "Cargo.lock"
+      - "rust-toolchain"
+      - "crates/**"
+      - "!crates/ruff_dev"
+      - "!crates/ruff_shrinking"
 
   workflow_dispatch:
 
@@ -22,7 +22,7 @@ jobs:
     name: "Run | ${{ matrix.os }}"
     strategy:
       matrix:
-        os: [ ubuntu-latest, windows-latest ]
+        os: [ubuntu-latest, windows-latest]
     runs-on: ${{ matrix.os }}
 
     steps:

.github/workflows/ci.yaml

@@ -2,7 +2,7 @@ name: CI
 
 on:
   push:
-    branches: [ main ]
+    branches: [main]
   pull_request:
   workflow_dispatch:
 
@@ -16,7 +16,7 @@ env:
   CARGO_TERM_COLOR: always
   RUSTUP_MAX_RETRIES: 10
   PACKAGE_NAME: ruff
-  PYTHON_VERSION: "3.11" # to build abi3 wheels
+  PYTHON_VERSION: "3.11"
 
 jobs:
   determine_changes:
@@ -42,6 +42,7 @@ jobs:
               - "!crates/ruff_formatter/**"
               - "!crates/ruff_dev/**"
               - "!crates/ruff_shrinking/**"
+              - scripts/*
 
             formatter:
               - Cargo.toml
@@ -54,7 +55,8 @@ jobs:
               - crates/ruff_python_index/**
               - crates/ruff_text_size/**
               - crates/ruff_python_parser/**
-
+              - crates/ruff_dev/**
+              - scripts/*
 
   cargo-fmt:
     name: "cargo fmt"
@@ -83,7 +85,7 @@ jobs:
   cargo-test:
     strategy:
       matrix:
-        os: [ ubuntu-latest, windows-latest ]
+        os: [ubuntu-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     name: "cargo test | ${{ matrix.os }}"
     steps:
@@ -235,7 +237,6 @@ jobs:
       - name: "Run cargo-udeps"
         run: cargo +nightly-2023-06-08 udeps
 
-
   python-package:
     name: "python package"
     runs-on: ubuntu-latest
@@ -327,7 +328,7 @@ jobs:
     name: "Formatter ecosystem and progress checks"
     runs-on: ubuntu-latest
     needs: determine_changes
-    if: needs.determine_changes.outputs.formatter == 'true'
+    if: needs.determine_changes.outputs.formatter == 'true' || github.ref == 'refs/heads/main'
     steps:
       - uses: actions/checkout@v3
       - name: "Install Rust toolchain"
@@ -335,11 +336,8 @@ jobs:
       - name: "Cache rust"
         uses: Swatinem/rust-cache@v2
       - name: "Formatter progress"
-        run: scripts/formatter_progress.sh
+        run: scripts/formatter_ecosystem_checks.sh
       - name: "Github step summary"
-        run: grep "similarity index" target/progress_projects_report.txt | sort > $GITHUB_STEP_SUMMARY
-      # CPython is not black formatted, so we run only the stability check
-      - name: "Clone CPython 3.10"
-        run: git clone --branch 3.10 --depth 1 https://github.com/python/cpython.git crates/ruff/resources/test/cpython
-      - name: "Check CPython stability"
-        run: cargo run --bin ruff_dev -- format-dev --stability-check crates/ruff/resources/test/cpython
+        run: cat target/progress_projects_stats.txt > $GITHUB_STEP_SUMMARY
+      - name: "Remove checkouts from cache"
+        run: rm -r target/progress_projects

.github/workflows/docs.yaml

@@ -3,7 +3,7 @@ name: mkdocs
 on:
   workflow_dispatch:
   release:
-    types: [ published ]
+    types: [published]
 
 jobs:
   mkdocs:
@@ -40,7 +40,7 @@ jobs:
         run: mkdocs build --strict -f mkdocs.generated.yml
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@2.0.0
+        uses: cloudflare/wrangler-action@3.0.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/flake8-to-ruff.yaml

@@ -66,7 +66,7 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        target: [ x64, x86 ]
+        target: [x64, x86]
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
@@ -94,7 +94,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        target: [ x86_64, i686 ]
+        target: [x86_64, i686]
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
@@ -121,7 +121,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        target: [ aarch64, armv7, s390x, ppc64le, ppc64 ]
+        target: [aarch64, armv7, s390x, ppc64le, ppc64]
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4

.github/workflows/playground.yaml

@@ -3,7 +3,7 @@ name: "[Playground] Release"
 on:
   workflow_dispatch:
   release:
-    types: [ published ]
+    types: [published]
 
 env:
   CARGO_INCREMENTAL: 0
@@ -40,7 +40,7 @@ jobs:
         working-directory: playground
       - name: "Deploy to Cloudflare Pages"
         if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@2.0.0
+        uses: cloudflare/wrangler-action@3.0.0
         with:
           apiToken: ${{ secrets.CF_API_TOKEN }}
           accountId: ${{ secrets.CF_ACCOUNT_ID }}

.github/workflows/pr-comment.yaml

@@ -2,8 +2,8 @@ name: PR Check Comment
 
 on:
   workflow_run:
-    workflows: [ CI, Benchmark ]
-    types: [ completed ]
+    workflows: [CI, Benchmark]
+    types: [completed]
   workflow_dispatch:
     inputs:
       workflow_run_id:

.pre-commit-config.yaml

@@ -42,13 +42,13 @@ repos:
         name: cargo fmt
         entry: cargo fmt --
         language: system
-        types: [ rust ]
+        types: [rust]
         pass_filenames: false # This makes it a lot faster
       - id: ruff
         name: ruff
         entry: cargo run --bin ruff -- check --no-cache --force-exclude --fix --exit-non-zero-on-fix
         language: system
-        types_or: [ python, pyi ]
+        types_or: [python, pyi]
         require_serial: true
         exclude: |
           (?x)^(
@@ -62,5 +62,12 @@ repos:
     hooks:
       - id: black
 
+  # Prettier
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v3.0.0
+    hooks:
+      - id: prettier
+        types: [yaml]
+
 ci:
-  skip: [ cargo-fmt, dev-generate-all ]
+  skip: [cargo-fmt, dev-generate-all]

BREAKING_CHANGES.md

@@ -1,5 +1,15 @@
 # Breaking Changes
 
+## 0.0.283 / 0.284
+
+### The target Python version now defaults to 3.8 instead of 3.10 ([#6397](https://github.com/astral-sh/ruff/pull/6397))
+
+Previously, when a target Python version was not specified, Ruff would use a default of Python 3.10. However, it is safer to default to an _older_ Python version to avoid assuming the availability of new features. We now default to the oldest supported Python version which is currently Python 3.8.
+
+(We still support Python 3.7 but since [it has reached EOL](https://devguide.python.org/versions/#unsupported-versions) we've decided not to make it the default here.)
+
+Note this change was announced in 0.0.283 but not active until 0.0.284.
+
 ## 0.0.277
 
 ### `.ipynb_checkpoints`, `.pyenv`, `.pytest_cache`, and `.vscode` are now excluded by default ([#5513](https://github.com/astral-sh/ruff/pull/5513))

CONTRIBUTING.md

@@ -69,6 +69,13 @@ and pre-commit to run some validation checks:
 pipx install pre-commit  # or `pip install pre-commit` if you have a virtualenv
 ```
 
+You can optionally install pre-commit hooks to automatically run the validation checks
+when making a commit:
+
+```shell
+pre-commit install
+```
+
 ### Development
 
 After cloning the repository, run Ruff locally from the repository root with:
@@ -124,7 +131,6 @@ At time of writing, the repository includes the following crates:
 - `crates/ruff_macros`: proc macro crate containing macros used by Ruff.
 - `crates/ruff_python_ast`: library crate containing Python-specific AST types and utilities.
 - `crates/ruff_python_codegen`: library crate containing utilities for generating Python source code.
-- `crates/ruff_python_codegen`: library crate containing utilities for generating Python source code.
 - `crates/ruff_python_formatter`: library crate implementing the Python formatter. Emits an
     intermediate representation for each node, which `ruff_formatter` prints based on the configured
     line length.
@@ -565,7 +571,7 @@ An alternative is to convert the perf data to `flamegraph.svg` using
 [flamegraph](https://github.com/flamegraph-rs/flamegraph) (`cargo install flamegraph`):
 
 ```shell
-flamegraph --perfdata perf.data
+flamegraph --perfdata perf.data --no-inline
 ```
 
 #### Mac

Cargo.lock

@@ -14,6 +14,18 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
+[[package]]
+name = "ahash"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
+dependencies = [
+ "cfg-if",
+ "getrandom",
+ "once_cell",
+ "version_check",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "0.7.20"
@@ -133,6 +145,12 @@ dependencies = [
  "os_str_bytes",
 ]
 
+[[package]]
+name = "arrayvec"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+
 [[package]]
 name = "ascii-canvas"
 version = "3.0.0"
@@ -794,7 +812,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.281"
+version = "0.0.284"
 dependencies = [
  "anyhow",
  "clap",
@@ -985,6 +1003,16 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "imara-diff"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e98c1d0ad70fc91b8b9654b1f33db55e59579d3b3de2bffdced0fdb810570cb8"
+dependencies = [
+ "ahash",
+ "hashbrown 0.12.3",
+]
+
 [[package]]
 name = "imperative"
 version = "1.0.4"
@@ -1027,6 +1055,7 @@ dependencies = [
  "number_prefix",
  "portable-atomic",
  "unicode-width",
+ "vt100",
 ]
 
 [[package]]
@@ -2035,7 +2064,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.281"
+version = "0.0.284"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -2112,6 +2141,7 @@ dependencies = [
  "ruff",
  "ruff_python_ast",
  "ruff_python_formatter",
+ "ruff_python_index",
  "ruff_python_parser",
  "serde",
  "serde_json",
@@ -2134,7 +2164,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_cli"
-version = "0.0.281"
+version = "0.0.284"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -2190,11 +2220,11 @@ dependencies = [
  "anyhow",
  "clap",
  "ignore",
+ "imara-diff",
  "indicatif",
  "indoc",
  "itertools",
  "libcst",
- "log",
  "once_cell",
  "pretty_assertions",
  "rayon",
@@ -2218,6 +2248,9 @@ dependencies = [
  "strum_macros",
  "tempfile",
  "toml",
+ "tracing",
+ "tracing-indicatif",
+ "tracing-subscriber",
 ]
 
 [[package]]
@@ -2282,6 +2315,7 @@ dependencies = [
  "rustc-hash",
  "serde",
  "smallvec",
+ "static_assertions",
 ]
 
 [[package]]
@@ -2320,6 +2354,7 @@ dependencies = [
  "similar",
  "smallvec",
  "thiserror",
+ "unicode-width",
 ]
 
 [[package]]
@@ -2343,7 +2378,6 @@ dependencies = [
  "is-macro",
  "itertools",
  "lexical-parse-float",
- "num-bigint",
  "num-traits",
  "rand",
  "unic-ucd-category",
@@ -2390,6 +2424,7 @@ dependencies = [
  "num-traits",
  "ruff_index",
  "ruff_python_ast",
+ "ruff_python_parser",
  "ruff_python_stdlib",
  "ruff_source_file",
  "ruff_text_size",
@@ -3115,6 +3150,18 @@ dependencies = [
  "valuable",
 ]
 
+[[package]]
+name = "tracing-indicatif"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b38ed3722d27705c3bd7ca0ccf29acc3d8e1c717b4cd87f97891a2c1834ea1af"
+dependencies = [
+ "indicatif",
+ "tracing",
+ "tracing-core",
+ "tracing-subscriber",
+]
+
 [[package]]
 name = "tracing-log"
 version = "0.1.3"
@@ -3313,6 +3360,39 @@ version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
+[[package]]
+name = "vt100"
+version = "0.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84cd863bf0db7e392ba3bd04994be3473491b31e66340672af5d11943c6274de"
+dependencies = [
+ "itoa",
+ "log",
+ "unicode-width",
+ "vte",
+]
+
+[[package]]
+name = "vte"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5022b5fbf9407086c180e9557be968742d839e68346af7792b8592489732197"
+dependencies = [
+ "arrayvec",
+ "utf8parse",
+ "vte_generate_state_changes",
+]
+
+[[package]]
+name = "vte_generate_state_changes"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d257817081c7dffcdbab24b9e62d2def62e2ff7d00b1c20062551e6cccc145ff"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
 [[package]]
 name = "wait-timeout"
 version = "0.2.0"

Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-rust-version = "1.70"
+rust-version = "1.71"
 homepage = "https://beta.ruff.rs/docs"
 documentation = "https://beta.ruff.rs/docs"
 repository = "https://github.com/astral-sh/ruff"
@@ -46,6 +46,10 @@ syn = { version = "2.0.15" }
 test-case = { version = "3.0.0" }
 thiserror = { version = "1.0.43" }
 toml = { version = "0.7.2" }
+tracing = "0.1.37"
+tracing-indicatif = "0.3.4"
+tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
+unicode-width = "0.1.10"
 wsl = { version = "0.1.0" }
 
 # v1.0.1

README.md

@@ -30,7 +30,7 @@ An extremely fast Python linter, written in Rust.
 - 🤝 Python 3.11 compatibility
 - 📦 Built-in caching, to avoid re-analyzing unchanged files
 - 🔧 Autofix support, for automatic error correction (e.g., automatically remove unused imports)
-- 📏 Over [500 built-in rules](https://beta.ruff.rs/docs/rules/)
+- 📏 Over [600 built-in rules](https://beta.ruff.rs/docs/rules/)
 - ⚖️ [Near-parity](https://beta.ruff.rs/docs/faq/#how-does-ruff-compare-to-flake8) with the
     built-in Flake8 rule set
 - 🔌 Native re-implementations of dozens of Flake8 plugins, like flake8-bugbear
@@ -140,7 +140,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com) hook:
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.0.281
+  rev: v0.0.284
   hooks:
     - id: ruff
 ```
@@ -211,8 +211,8 @@ line-length = 88
 # Allow unused variables when underscore-prefixed.
 dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 
-# Assume Python 3.10.
-target-version = "py310"
+# Assume Python 3.8
+target-version = "py38"
 
 [tool.ruff.mccabe]
 # Unlike Flake8, default to a complexity level of 10.
@@ -233,7 +233,7 @@ linting command.
 
 <!-- Begin section: Rules -->
 
-**Ruff supports over 500 lint rules**, many of which are inspired by popular tools like Flake8,
+**Ruff supports over 600 lint rules**, many of which are inspired by popular tools like Flake8,
 isort, pyupgrade, and others. Regardless of the rule's origin, Ruff re-implements every rule in
 Rust as a first-party feature.
 

crates/flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.281"
+version = "0.0.284"
 description = """
 Convert Flake8 configuration files to Ruff configuration files.
 """

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.281"
+version = "0.0.284"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -62,8 +62,6 @@ quick-junit = { version = "0.3.2" }
 regex = { workspace = true }
 result-like = { version = "0.4.6" }
 rustc-hash = { workspace = true }
-
-
 schemars = { workspace = true, optional = true }
 semver = { version = "1.0.16" }
 serde = { workspace = true }
@@ -77,7 +75,7 @@ strum_macros = { workspace = true }
 thiserror = { version = "1.0.43" }
 toml = { workspace = true }
 typed-arena = { version = "2.0.2" }
-unicode-width = { version = "0.1.10" }
+unicode-width = { workspace = true }
 unicode_names2 = { version = "0.6.0", git = "https://github.com/youknowone/unicode_names2.git", rev = "4ce16aa85cbcdd9cc830410f1a72ef9a235f2fde" }
 wsl = { version = "0.1.0" }
 

crates/ruff/resources/test/fixtures/flake8_bandit/S108.py

@@ -14,3 +14,19 @@ with open("/dev/shm/unit/test", "w") as f:
 # not ok by config
 with open("/foo/bar", "w") as f:
     f.write("def")
+
+# Using `tempfile` module should be ok
+import tempfile
+from tempfile import TemporaryDirectory
+
+with tempfile.NamedTemporaryFile(dir="/tmp") as f:
+    f.write(b"def")
+
+with tempfile.NamedTemporaryFile(dir="/var/tmp") as f:
+    f.write(b"def")
+
+with tempfile.TemporaryDirectory(dir="/dev/shm") as d:
+    pass
+
+with TemporaryDirectory(dir="/tmp") as d:
+    pass

crates/ruff/resources/test/fixtures/flake8_boolean_trap/FBT.py

@@ -67,7 +67,8 @@ cfg.getboolean("hello", True)
 os.set_blocking(0, False)
 g_action.set_enabled(True)
 settings.set_enable_developer_extras(True)
-
+foo.is_(True)
+bar.is_not(False)
 
 class Registry:
     def __init__(self) -> None:

crates/ruff/resources/test/fixtures/flake8_bugbear/B006_B008.py

@@ -68,6 +68,20 @@ def this_is_also_wrong(value={}):
     ...
 
 
+class Foo:
+    @staticmethod
+    def this_is_also_wrong_and_more_indented(value={}):
+        pass
+
+
+def multiline_arg_wrong(value={
+
+}):
+    ...
+
+def single_line_func_wrong(value = {}): ...
+
+
 def and_this(value=set()):
     ...
 
@@ -240,12 +254,16 @@ def foo(f=lambda x: print(x)):
 
 from collections import abc
 from typing import Annotated, Dict, Optional, Sequence, Union, Set
+import typing_extensions
 
 
 def immutable_annotations(
     a: Sequence[int] | None = [],
     b: Optional[abc.Mapping[int, int]] = {},
     c: Annotated[Union[abc.Set[str], abc.Sized], "annotation"] = set(),
+    d: typing_extensions.Annotated[
+        Union[abc.Set[str], abc.Sized], "annotation"
+    ] = set(),
 ):
     pass
 
@@ -254,5 +272,35 @@ def mutable_annotations(
     a: list[int] | None = [],
     b: Optional[Dict[int, int]] = {},
     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+    d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
 ):
     pass
+
+
+def single_line_func_wrong(value: dict[str, str] = {}):
+    """Docstring"""
+
+
+def single_line_func_wrong(value: dict[str, str] = {}):
+    """Docstring"""
+    ...
+
+
+def single_line_func_wrong(value: dict[str, str] = {}):
+    """Docstring"""; ...
+
+
+def single_line_func_wrong(value: dict[str, str] = {}):
+    """Docstring"""; \
+        ...
+
+
+def single_line_func_wrong(value: dict[str, str] = {
+    # This is a comment
+}):
+    """Docstring"""
+
+
+def single_line_func_wrong(value: dict[str, str] = {}) \
+    : \
+    """Docstring"""

crates/ruff/resources/test/fixtures/flake8_bugbear/B014.py

@@ -74,3 +74,10 @@ try:
 except (ValueError, binascii.Error):
     # binascii.Error is a subclass of ValueError.
     pass
+
+
+# https://github.com/astral-sh/ruff/issues/6412
+try:
+    pass
+except (ValueError, ValueError, TypeError):
+    pass

crates/ruff/resources/test/fixtures/flake8_logging_format/G004.py

@@ -3,3 +3,6 @@ import logging
 name = "world"
 logging.info(f"Hello {name}")
 logging.log(logging.INFO, f"Hello {name}")
+
+_LOGGER = logging.getLogger()
+_LOGGER.info(f"{__name__}")

crates/ruff/resources/test/fixtures/flake8_pyi/PYI016.py

@@ -1,20 +1,19 @@
+import typing
+
 # Shouldn't affect non-union field types.
 field1: str
 
 # Should emit for duplicate field types.
 field2: str | str  # PYI016: Duplicate union member `str`
 
-
 # Should emit for union types in arguments.
 def func1(arg1: int | int):  # PYI016: Duplicate union member `int`
     print(arg1)
 
-
 # Should emit for unions in return types.
 def func2() -> str | str:  # PYI016: Duplicate union member `str`
     return "my string"
 
-
 # Should emit in longer unions, even if not directly adjacent.
 field3: str | str | int  # PYI016: Duplicate union member `str`
 field4: int | int | str  # PYI016: Duplicate union member `int`
@@ -33,3 +32,55 @@ field10: (str | int) | str  # PYI016: Duplicate union member `str`
 
 # Should emit for nested unions.
 field11: dict[int | int, str]
+
+# Should emit for unions with more than two cases
+field12: int | int | int  # Error
+field13: int | int | int | int  # Error
+
+# Should emit for unions with more than two cases, even if not directly adjacent
+field14: int | int | str | int  # Error
+
+# Should emit for duplicate literal types; also covered by PYI030
+field15: typing.Literal[1] | typing.Literal[1]  # Error
+
+# Shouldn't emit if in new parent type
+field16: int | dict[int, str]  # OK
+
+# Shouldn't emit if not in a union parent
+field17: dict[int, int]  # OK
+
+# Should emit in cases with newlines
+field18: typing.Union[
+    set[
+        int  # foo
+    ],
+    set[
+        int  # bar
+    ],
+]  # Error, newline and comment will not be emitted in message
+
+# Should emit in cases with `typing.Union` instead of `|`
+field19: typing.Union[int, int]  # Error
+
+# Should emit in cases with nested `typing.Union`
+field20: typing.Union[int, typing.Union[int, str]]  # Error
+
+# Should emit in cases with mixed `typing.Union` and `|`
+field21: typing.Union[int, int | str]  # Error
+
+# Should emit only once in cases with multiple nested `typing.Union`
+field22: typing.Union[int, typing.Union[int, typing.Union[int, int]]]  # Error
+
+# Should emit in cases with newlines
+field23: set[  # foo
+    int] | set[int]
+
+# Should emit twice (once for each `int` in the nested union, both of which are
+# duplicates of the outer `int`), but not three times (which would indicate that
+# we incorrectly re-checked the nested union).
+field24: typing.Union[int, typing.Union[int, int]]  # PYI016: Duplicate union member `int`
+
+# Should emit twice (once for each `int` in the nested union, both of which are
+# duplicates of the outer `int`), but not three times (which would indicate that
+# we incorrectly re-checked the nested union).
+field25: typing.Union[int, int | int]  # PYI016: Duplicate union member `int`

crates/ruff/resources/test/fixtures/flake8_pyi/PYI016.pyi

@@ -74,3 +74,13 @@ field22: typing.Union[int, typing.Union[int, typing.Union[int, int]]]  # Error
 # Should emit in cases with newlines
 field23: set[  # foo
     int] | set[int]
+
+# Should emit twice (once for each `int` in the nested union, both of which are
+# duplicates of the outer `int`), but not three times (which would indicate that
+# we incorrectly re-checked the nested union).
+field24: typing.Union[int, typing.Union[int, int]]  # PYI016: Duplicate union member `int`
+
+# Should emit twice (once for each `int` in the nested union, both of which are
+# duplicates of the outer `int`), but not three times (which would indicate that
+# we incorrectly re-checked the nested union).
+field25: typing.Union[int, int | int]  # PYI016: Duplicate union member `int`

crates/ruff/resources/test/fixtures/flake8_pyi/PYI019.py

@@ -0,0 +1,46 @@
+from typing import TypeVar, Self, Type
+
+_S = TypeVar("_S", bound=BadClass)
+_S2 = TypeVar("_S2", BadClass, GoodClass)
+
+class BadClass:
+    def __new__(cls: type[_S], *args: str, **kwargs: int) -> _S: ...  # PYI019
+
+
+    def bad_instance_method(self: _S, arg: bytes) -> _S: ...  # PYI019
+
+
+    @classmethod
+    def bad_class_method(cls: type[_S], arg: int) -> _S: ...  # PYI019
+
+
+    @classmethod
+    def bad_posonly_class_method(cls: type[_S], /) -> _S: ...  # PYI019
+
+
+    @classmethod
+    def excluded_edge_case(cls: Type[_S], arg: int) -> _S: ...  # Ok
+
+
+class GoodClass:
+    def __new__(cls: type[Self], *args: list[int], **kwargs: set[str]) -> Self: ...
+    def good_instance_method_1(self: Self, arg: bytes) -> Self: ...
+    def good_instance_method_2(self, arg1: _S2, arg2: _S2) -> _S2: ...
+    @classmethod
+    def good_cls_method_1(cls: type[Self], arg: int) -> Self: ...
+    @classmethod
+    def good_cls_method_2(cls, arg1: _S, arg2: _S) -> _S: ...
+    @staticmethod
+    def static_method(arg1: _S) -> _S: ...
+
+
+# Python > 3.12
+class PEP695BadDunderNew[T]:
+  def __new__[S](cls: type[S], *args: Any, ** kwargs: Any) -> S: ...  # PYI019
+
+
+  def generic_instance_method[S](self: S) -> S: ...  # PYI019
+
+
+class PEP695GoodDunderNew[T]:
+  def __new__(cls, *args: Any, **kwargs: Any) -> Self: ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI019.pyi

@@ -0,0 +1,46 @@
+from typing import TypeVar, Self, Type
+
+_S = TypeVar("_S", bound=BadClass)
+_S2 = TypeVar("_S2", BadClass, GoodClass)
+
+class BadClass:
+    def __new__(cls: type[_S], *args: str, **kwargs: int) -> _S: ...  # PYI019
+
+
+    def bad_instance_method(self: _S, arg: bytes) -> _S: ...  # PYI019
+
+
+    @classmethod
+    def bad_class_method(cls: type[_S], arg: int) -> _S: ...  # PYI019
+
+
+    @classmethod
+    def bad_posonly_class_method(cls: type[_S], /) -> _S: ...  # PYI019
+
+
+    @classmethod
+    def excluded_edge_case(cls: Type[_S], arg: int) -> _S: ...  # Ok
+
+
+class GoodClass:
+    def __new__(cls: type[Self], *args: list[int], **kwargs: set[str]) -> Self: ...
+    def good_instance_method_1(self: Self, arg: bytes) -> Self: ...
+    def good_instance_method_2(self, arg1: _S2, arg2: _S2) -> _S2: ...
+    @classmethod
+    def good_cls_method_1(cls: type[Self], arg: int) -> Self: ...
+    @classmethod
+    def good_cls_method_2(cls, arg1: _S, arg2: _S) -> _S: ...
+    @staticmethod
+    def static_method(arg1: _S) -> _S: ...
+
+
+# Python > 3.12
+class PEP695BadDunderNew[T]:
+  def __new__[S](cls: type[S], *args: Any, ** kwargs: Any) -> S: ...  # PYI019
+
+
+  def generic_instance_method[S](self: S) -> S: ...  # PYI019
+
+
+class PEP695GoodDunderNew[T]:
+  def __new__(cls, *args: Any, **kwargs: Any) -> Self: ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI024.py

@@ -1,9 +1,11 @@
 import collections
 
-person: collections.namedtuple  # OK
+person: collections.namedtuple  # Y024 Use "typing.NamedTuple" instead of "collections.namedtuple"
 
 from collections import namedtuple
 
-person: namedtuple  # OK
+person: namedtuple  # Y024 Use "typing.NamedTuple" instead of "collections.namedtuple"
 
-person = namedtuple("Person", ["name", "age"])  # OK
+person = namedtuple(
+    "Person", ["name", "age"]
+)  # Y024 Use "typing.NamedTuple" instead of "collections.namedtuple"

crates/ruff/resources/test/fixtures/flake8_pyi/PYI030.py

@@ -1,24 +1,38 @@
+import typing
+import typing_extensions
 from typing import Literal
-# Shouldn't emit for any cases in the non-stub file for compatibility with flake8-pyi.
-# Note that this rule could be applied here in the future.
 
+# Shouldn't affect non-union field types.
 field1: Literal[1]  # OK
-field2: Literal[1] | Literal[2]  # OK
 
-def func1(arg1: Literal[1] | Literal[2]):  # OK
+# Should emit for duplicate field types.
+field2: Literal[1] | Literal[2]  # Error
+
+# Should emit for union types in arguments.
+def func1(arg1: Literal[1] | Literal[2]):  # Error
     print(arg1)
 
 
-def func2() -> Literal[1] | Literal[2]:  # OK
+# Should emit for unions in return types.
+def func2() -> Literal[1] | Literal[2]:  # Error
     return "my Literal[1]ing"
 
 
-field3: Literal[1] | Literal[2] | str  # OK
-field4: str | Literal[1] | Literal[2]  # OK
-field5: Literal[1] | str | Literal[2]  # OK
-field6: Literal[1] | bool | Literal[2] | str  # OK
-field7 = Literal[1] | Literal[2]  # OK
-field8: Literal[1] | (Literal[2] | str)  # OK
-field9: Literal[1] | (Literal[2] | str)  # OK
-field10: (Literal[1] | str) | Literal[2]  # OK
-field11: dict[Literal[1] | Literal[2], str]  # OK
+# Should emit in longer unions, even if not directly adjacent.
+field3: Literal[1] | Literal[2] | str  # Error
+field4: str | Literal[1] | Literal[2]  # Error
+field5: Literal[1] | str | Literal[2]  # Error
+field6: Literal[1] | bool | Literal[2] | str  # Error
+
+# Should emit for non-type unions.
+field7 = Literal[1] | Literal[2]  # Error
+
+# Should emit for parenthesized unions.
+field8: Literal[1] | (Literal[2] | str)  # Error
+
+# Should handle user parentheses when fixing.
+field9: Literal[1] | (Literal[2] | str)  # Error
+field10: (Literal[1] | str) | Literal[2]  # Error
+
+# Should emit for union in generic parent type.
+field11: dict[Literal[1] | Literal[2], str]  # Error

crates/ruff/resources/test/fixtures/flake8_pyi/PYI032.py

@@ -3,8 +3,8 @@ import typing
 
 
 class Bad:
-    def __eq__(self, other: Any) -> bool: ...  # Fine because not a stub file
-    def __ne__(self, other: typing.Any) -> typing.Any: ...  # Fine because not a stub file
+    def __eq__(self, other: Any) -> bool: ...  # Y032
+    def __ne__(self, other: typing.Any) -> typing.Any: ...  # Y032
 
 
 class Good:

crates/ruff/resources/test/fixtures/flake8_pyi/PYI042.py

@@ -9,16 +9,16 @@ from typing import (
 
 just_literals_pipe_union: TypeAlias = (
     Literal[True] | Literal["idk"]
-)  # not PYI042 (not a stubfile)
+)  # PYI042, since not camel case
 PublicAliasT: TypeAlias = str | int
 PublicAliasT2: TypeAlias = Union[str, bytes]
 _ABCDEFGHIJKLMNOPQRST: TypeAlias = typing.Any
 _PrivateAliasS: TypeAlias = Literal["I", "guess", "this", "is", "okay"]
 _PrivateAliasS2: TypeAlias = Annotated[str, "also okay"]
 
-snake_case_alias1: TypeAlias = str | int  # not PYI042 (not a stubfile)
-_snake_case_alias2: TypeAlias = Literal["whatever"]  # not PYI042 (not a stubfile)
-Snake_case_alias: TypeAlias = int | float  # not PYI042 (not a stubfile)
+snake_case_alias1: TypeAlias = str | int  # PYI042, since not camel case
+_snake_case_alias2: TypeAlias = Literal["whatever"]  # PYI042, since not camel case
+Snake_case_alias: TypeAlias = int | float  # PYI042, since not camel case
 
 # check that this edge case doesn't crash
 _: TypeAlias = str | int

crates/ruff/resources/test/fixtures/flake8_pyi/PYI043.py

@@ -7,11 +7,11 @@ from typing import (
     Literal,
 )
 
-_PrivateAliasT: TypeAlias = str | int  # not PYI043 (not a stubfile)
-_PrivateAliasT2: TypeAlias = typing.Any  # not PYI043 (not a stubfile)
+_PrivateAliasT: TypeAlias = str | int  # PYI043, since this ends in a T
+_PrivateAliasT2: TypeAlias = typing.Any  # PYI043, since this ends in a T
 _PrivateAliasT3: TypeAlias = Literal[
     "not", "a", "chance"
-]  # not PYI043 (not a stubfile)
+]  # PYI043, since this ends in a T
 just_literals_pipe_union: TypeAlias = Literal[True] | Literal["idk"]
 PublicAliasT: TypeAlias = str | int
 PublicAliasT2: TypeAlias = Union[str, bytes]

crates/ruff/resources/test/fixtures/flake8_pyi/PYI051.py

@@ -0,0 +1,17 @@
+import typing
+from typing import Literal, TypeAlias, Union
+
+A: str | Literal["foo"]
+B: TypeAlias = typing.Union[Literal[b"bar", b"foo"], bytes, str]
+C: TypeAlias = typing.Union[Literal[5], int, typing.Union[Literal["foo"], str]]
+D: TypeAlias = typing.Union[Literal[b"str_bytes", 42], bytes, int]
+
+def func(x: complex | Literal[1J], y: Union[Literal[3.14], float]): ...
+
+# OK
+A: Literal["foo"]
+B: TypeAlias = Literal[b"bar", b"foo"]
+C: TypeAlias = typing.Union[Literal[5], Literal["foo"]]
+D: TypeAlias = Literal[b"str_bytes", 42]
+
+def func(x: Literal[1J], y: Literal[3.14]): ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI051.pyi

@@ -0,0 +1,17 @@
+import typing
+from typing import Literal, TypeAlias, Union
+
+A: str | Literal["foo"]
+B: TypeAlias = typing.Union[Literal[b"bar", b"foo"], bytes, str]
+C: TypeAlias = typing.Union[Literal[5], int, typing.Union[Literal["foo"], str]]
+D: TypeAlias = typing.Union[Literal[b"str_bytes", 42], bytes, int]
+
+def func(x: complex | Literal[1J], y: Union[Literal[3.14], float]): ...
+
+# OK
+A: Literal["foo"]
+B: TypeAlias = Literal[b"bar", b"foo"]
+C: TypeAlias = typing.Union[Literal[5], Literal["foo"]]
+D: TypeAlias = Literal[b"str_bytes", 42]
+
+def func(x: Literal[1J], y: Literal[3.14]): ...

crates/ruff/resources/test/fixtures/flake8_pyi/PYI055.py

@@ -0,0 +1,31 @@
+import builtins
+from typing import Union
+
+w: builtins.type[int] | builtins.type[str] | builtins.type[complex]
+x: type[int] | type[str] | type[float]
+y: builtins.type[int] | type[str] | builtins.type[complex]
+z: Union[type[float], type[complex]]
+z: Union[type[float, int], type[complex]]
+
+
+def func(arg: type[int] | str | type[float]) -> None:
+    ...
+
+
+# OK
+x: type[int, str, float]
+y: builtins.type[int, str, complex]
+z: Union[float, complex]
+
+
+def func(arg: type[int, float] | str) -> None:
+    ...
+
+
+# OK
+item: type[requests_mock.Mocker] | type[httpretty] = requests_mock.Mocker
+
+
+def func():
+    # PYI055
+    item: type[requests_mock.Mocker] | type[httpretty] = requests_mock.Mocker

crates/ruff/resources/test/fixtures/flake8_pyi/PYI055.pyi

@@ -0,0 +1,24 @@
+import builtins
+from typing import Union
+
+w: builtins.type[int] | builtins.type[str] | builtins.type[complex]
+x: type[int] | type[str] | type[float]
+y: builtins.type[int] | type[str] | builtins.type[complex]
+z: Union[type[float], type[complex]]
+z: Union[type[float, int], type[complex]]
+
+def func(arg: type[int] | str | type[float]) -> None: ...
+
+# OK
+x: type[int, str, float]
+y: builtins.type[int, str, complex]
+z: Union[float, complex]
+
+def func(arg: type[int, float] | str) -> None: ...
+
+# OK
+item: type[requests_mock.Mocker] | type[httpretty] = requests_mock.Mocker
+
+def func():
+    # PYI055
+    item: type[requests_mock.Mocker] | type[httpretty] = requests_mock.Mocker

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT009.py

@@ -80,3 +80,15 @@ class Test(unittest.TestCase):
 
     def test_assert_not_regexp_matches(self):
         self.assertNotRegex("abc", r"abc")  # Error
+
+    def test_fail_if(self):
+        self.failIf("abc")  # Error
+
+    def test_fail_unless(self):
+        self.failUnless("abc")  # Error
+
+    def test_fail_unless_equal(self):
+        self.failUnlessEqual(1, 2)  # Error
+
+    def test_fail_if_equal(self):
+        self.failIfEqual(1, 2)  # Error

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT014.py

@@ -0,0 +1,26 @@
+import pytest
+
+
+@pytest.mark.parametrize("x", [1, 1, 2])
+def test_error_literal(x):
+    ...
+
+
+a = 1
+b = 2
+c = 3
+
+
+@pytest.mark.parametrize("x", [a, a, b, b, b, c])
+def test_error_expr_simple(x):
+    ...
+
+
+@pytest.mark.parametrize("x", [(a, b), (a, b), (b, c)])
+def test_error_expr_complex(x):
+    ...
+
+
+@pytest.mark.parametrize("x", [1, 2])
+def test_ok(x):
+    ...

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT027_0.py

@@ -0,0 +1,48 @@
+import unittest
+
+
+class Test(unittest.TestCase):
+    def test_errors(self):
+        with self.assertRaises(ValueError):
+            raise ValueError
+        with self.assertRaises(expected_exception=ValueError):
+            raise ValueError
+
+        with self.failUnlessRaises(ValueError):
+            raise ValueError
+
+        with self.assertRaisesRegex(ValueError, "test"):
+            raise ValueError("test")
+
+        with self.assertRaisesRegex(ValueError, expected_regex="test"):
+            raise ValueError("test")
+
+        with self.assertRaisesRegex(
+            expected_exception=ValueError, expected_regex="test"
+        ):
+            raise ValueError("test")
+
+        with self.assertRaisesRegex(
+            expected_regex="test", expected_exception=ValueError
+        ):
+            raise ValueError("test")
+
+        with self.assertRaisesRegexp(ValueError, "test"):
+            raise ValueError("test")
+
+    def test_unfixable_errors(self):
+        with self.assertRaises(ValueError, msg="msg"):
+            raise ValueError
+
+        with self.assertRaises(
+            # comment
+            ValueError
+        ):
+            raise ValueError
+
+        with (
+            self
+            # comment
+            .assertRaises(ValueError)
+        ):
+            raise ValueError

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT027_1.py

@@ -0,0 +1,12 @@
+import unittest
+import pytest
+
+
+class Test(unittest.TestCase):
+    def test_pytest_raises(self):
+        with pytest.raises(ValueError):
+            raise ValueError
+
+    def test_errors(self):
+        with self.assertRaises(ValueError):
+            raise ValueError

crates/ruff/resources/test/fixtures/flake8_self/SLF001.py

@@ -73,3 +73,7 @@ print(foo.__dict__)
 print(foo.__str__())
 print(foo().__class__)
 print(foo._asdict())
+
+import os
+
+os._exit()

crates/ruff/resources/test/fixtures/flake8_tidy_imports/TID253.py

@@ -0,0 +1,31 @@
+## Banned modules ##
+import torch
+
+from torch import *
+
+from tensorflow import a, b, c
+
+import torch as torch_wearing_a_trenchcoat
+
+# this should count as module level
+x = 1; import tensorflow
+
+# banning a module also bans any submodules
+import torch.foo.bar
+
+from tensorflow.foo import bar
+
+from torch.foo.bar import *
+
+# unlike TID251, inline imports are *not* banned
+def my_cool_function():
+    import tensorflow.foo.bar
+
+def another_cool_function():
+    from torch.foo import bar
+
+def import_alias():
+    from torch.foo import bar
+
+if TYPE_CHECKING:
+    import torch

crates/ruff/resources/test/fixtures/flake8_type_checking/runtime_evaluated_base_classes_4.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from datetime import date
+
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+
+class Birthday(DeclarativeBase):
+
+    __tablename__ = "birthday"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    day: Mapped[date]

crates/ruff/resources/test/fixtures/flake8_type_checking/snapshot.py

@@ -0,0 +1,10 @@
+"""Regression test: ensure that we don't treat the export entry as a typing-only reference."""
+from __future__ import annotations
+
+from logging import getLogger
+
+__all__ = ("getLogger",)
+
+
+def foo() -> None:
+    pass

crates/ruff/resources/test/fixtures/flake8_unused_arguments/ARG.py

@@ -202,3 +202,14 @@ class C:
 ###
 def f(x: None) -> None:
     _ = cast(Any, _identity)(x=x)
+
+###
+# Unused arguments with `locals`.
+###
+def f(bar: str):
+    print(locals())
+
+
+class C:
+    def __init__(self, x) -> None:
+        print(locals())

crates/ruff/resources/test/fixtures/flake8_use_pathlib/PTH206.py

@@ -18,3 +18,5 @@ file_name.split(os.sep)
 
 # OK
 "foo/bar/".split("/")
+"foo/bar/".split(os.sep, 1)
+"foo/bar/".split(1, sep=os.sep)

crates/ruff/resources/test/fixtures/isort/required_imports/comments_and_newlines.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+# A copyright notice could go here
+
+# A linter directive could go here
+
+x = 1

crates/ruff/resources/test/fixtures/jupyter/cell/cell_magic.json

@@ -0,0 +1,8 @@
+{
+  "execution_count": null,
+  "cell_type": "code",
+  "id": "1",
+  "metadata": {},
+  "outputs": [],
+  "source": ["%%timeit\n", "print('hello world')"]
+}

crates/ruff/resources/test/fixtures/jupyter/ipy_escape_command.ipynb

@@ -0,0 +1,52 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eab4754a-d6df-4b41-8ee8-7e23aef440f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "\n",
+    "%matplotlib inline\n",
+    "\n",
+    "import os\n",
+    "\n",
+    "_ = math.pi"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2b0e2986-1b87-4bb6-9b1d-c11ca1decd87",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%timeit\n",
+    "import sys"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (ruff)",
+   "language": "python",
+   "name": "ruff"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

crates/ruff/resources/test/fixtures/jupyter/ipy_escape_command_expected.ipynb

@@ -0,0 +1,51 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cad32845-44f9-4a53-8b8c-a6b1bb3f3378",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "\n",
+    "%matplotlib inline\n",
+    "\n",
+    "\n",
+    "_ = math.pi"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d7b8e967-8b4a-493b-b6f7-d5cecfb3a5c3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%timeit\n",
+    "import sys"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (ruff)",
+   "language": "python",
+   "name": "ruff"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

crates/ruff/resources/test/fixtures/jupyter/isort.ipynb

@@ -25,6 +25,23 @@
     "def foo():\n",
     "    pass"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16214f6f-bb32-4594-81be-79fb27c6ec92",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "import sys\n",
+    "\n",
+    "%matplotlib \\\n",
+    "    --inline\n",
+    "\n",
+    "import math\n",
+    "import abc"
+   ]
   }
  ],
  "metadata": {

crates/ruff/resources/test/fixtures/jupyter/isort_expected.ipynb

@@ -27,6 +27,23 @@
     "def foo():\n",
     "    pass"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6d6c55c6-4a34-4662-914b-4ee11c9c24a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "from pathlib import Path\n",
+    "\n",
+    "%matplotlib \\\n",
+    "    --inline\n",
+    "\n",
+    "import abc\n",
+    "import math"
+   ]
   }
  ],
  "metadata": {

crates/ruff/resources/test/fixtures/jupyter/unused_variable.ipynb

@@ -0,0 +1,49 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a0efffbc-85f1-4513-bf49-5387ec3a2a4e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def f():\n",
+    "    foo1 = %matplotlib --list\n",
+    "    foo2: list[str] = %matplotlib --list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e0b2b50-43f2-4f59-951d-9404dd560ae4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def f():\n",
+    "    bar1 = !pwd\n",
+    "    bar2: str = !pwd"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (ruff)",
+   "language": "python",
+   "name": "ruff"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

crates/ruff/resources/test/fixtures/jupyter/unused_variable_expected.ipynb

@@ -0,0 +1,49 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24426ef2-046c-453e-b809-05b56e7355e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def f():\n",
+    "    %matplotlib --list\n",
+    "    %matplotlib --list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3d98fdae-b86b-476e-b4db-9d3ce5562682",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def f():\n",
+    "    !pwd\n",
+    "    !pwd"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (ruff)",
+   "language": "python",
+   "name": "ruff"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

crates/ruff/resources/test/fixtures/perflint/PERF203.py

@@ -21,3 +21,29 @@ while i < 10:
         print("error")
 
     i += 1
+
+# OK - no other way to write this
+for i in range(10):
+    try:
+        print(f"{i}")
+        break
+    except:
+        print("error")
+
+# OK - no other way to write this
+for i in range(10):
+    try:
+        print(f"{i}")
+        continue
+    except:
+        print("error")
+
+
+# OK - no other way to write this
+for i in range(10):
+    try:
+        print(f"{i}")
+        if i > 0:
+            break
+    except:
+        print("error")

crates/ruff/resources/test/fixtures/perflint/PERF401.py

@@ -45,3 +45,18 @@ def f():
     for i in items:
         if i not in result:
             result.append(i)  # OK
+
+
+def f():
+    fibonacci = [0, 1]
+    for i in range(20):
+        fibonacci.append(sum(fibonacci[-2:]))  # OK
+    print(fibonacci)
+
+
+def f():
+    foo = object()
+    foo.fibonacci = [0, 1]
+    for i in range(20):
+        foo.fibonacci.append(sum(foo.fibonacci[-2:]))  # OK
+    print(foo.fibonacci)

crates/ruff/resources/test/fixtures/pycodestyle/E402.py

@@ -30,3 +30,10 @@ def foo() -> None:
 
 if __name__ == "__main__":
     import g
+
+import h; import i
+
+
+if __name__ == "__main__":
+    import j; \
+import k

crates/ruff/resources/test/fixtures/pycodestyle/E501_2.py

@@ -1,11 +1,16 @@
-a = """ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A6"""
-a	=	"""ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A6"""
+# aaaa
+# aaaaa
+    # a
+	# a
+	# aa
+	# aaa
+	# aaaa
+		# a
+		# aa
+		# aaa
 
-b = """ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A6"""
-b	=	"""ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A6"""
-
-c   =   """2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A6"""
-c	=	"""2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A6"""
-
-d       =       """💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A6"""
-d	=	"""💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A67ß9💣2ℝ4A6"""
+if True: # noqa: E501
+	[12]
+	[12 ]
+	[1,2]
+	[1, 2]

crates/ruff/resources/test/fixtures/pycodestyle/E70.py

@@ -66,3 +66,6 @@ while 1:
 #: E703:2:1
 0\
 ;
+#: E701:2:3
+a = \
+  5;

crates/ruff/resources/test/fixtures/pycodestyle/E721.py

@@ -58,3 +58,33 @@ assert type(res) == type(None)
 types = StrEnum
 if x == types.X:
     pass
+
+#: E721
+assert type(res) is int
+
+
+class Foo:
+    def asdf(self, value: str | None):
+        #: E721
+        if type(value) is str:
+            ...
+
+
+class Foo:
+    def type(self):
+        pass
+
+    def asdf(self, value: str | None):
+        #: E721
+        if type(value) is str:
+            ...
+
+
+class Foo:
+    def asdf(self, value: str | None):
+        def type():
+            pass
+
+        # Okay
+        if type(value) is str:
+            ...

crates/ruff/resources/test/fixtures/pydocstyle/D.py

@@ -634,3 +634,8 @@ def starts_with_this():
 @expect('D404: First word of the docstring should not be "This"')
 def starts_with_space_then_this():
     """ This is a docstring that starts with a space."""  # noqa: D210
+
+
+class SameLine: """This is a docstring on the same line"""
+
+def same_line(): """This is a docstring on the same line"""

crates/ruff/resources/test/fixtures/pyflakes/F401_0.py

@@ -92,3 +92,10 @@ match *0, 1, *2:
     case 0,:
         import x
         import y
+
+
+# Test: access a sub-importation via an alias.
+import foo.bar as bop
+import foo.bar.baz
+
+print(bop.baz.read_csv("test.csv"))

crates/ruff/resources/test/fixtures/pyflakes/F823.py

@@ -70,3 +70,13 @@ import requests_mock as rm
 
 def requests_mock(requests_mock: rm.Mocker):
     print(rm.ANY)
+
+
+import sklearn.base
+import mlflow.sklearn
+
+
+def f():
+    import sklearn
+
+    mlflow

crates/ruff/resources/test/fixtures/pyflakes/F841_0.py

@@ -145,3 +145,9 @@ def f() -> None:
     obj = Foo()
     obj.do_thing()
 
+
+def f():
+    try:
+        pass
+    except Exception as _:
+        pass

crates/ruff/resources/test/fixtures/pyflakes/F841_3.py

@@ -147,3 +147,10 @@ def f() -> None:
     global CONSTANT
     CONSTANT = 1
     CONSTANT = 2
+
+
+def f() -> None:
+    try:
+        print("hello")
+    except A as e :
+        print("oh no!")

crates/ruff/resources/test/fixtures/pylint/bad_dunder_method_name.py

@@ -0,0 +1,46 @@
+class Apples:
+    def _init_(self):  # [bad-dunder-name]
+        pass
+
+    def __hello__(self):  # [bad-dunder-name]
+        print("hello")
+
+    def __init_(self):  # [bad-dunder-name]
+        # author likely unintentionally misspelled the correct init dunder.
+        pass
+
+    def _init_(self):  # [bad-dunder-name]
+        # author likely unintentionally misspelled the correct init dunder.
+        pass
+
+    def ___neg__(self):  # [bad-dunder-name]
+        # author likely accidentally added an additional `_`
+        pass
+
+    def __inv__(self):  # [bad-dunder-name]
+        # author likely meant to call the invert dunder method
+        pass
+
+    def hello(self):
+        print("hello")
+
+    def __init__(self):
+        pass
+
+    def init(self):
+        # valid name even though someone could accidentally mean __init__
+        pass
+
+    def _protected_method(self):
+        print("Protected")
+
+    def __private_method(self):
+        print("Private")
+
+    @property
+    def __doc__(self):
+        return "Docstring"
+
+
+def __foo_bar__():  # this is not checked by the [bad-dunder-name] rule
+    ...

crates/ruff/resources/test/fixtures/pylint/bad_string_format_character.py

@@ -0,0 +1,29 @@
+# pylint: disable=missing-docstring,consider-using-f-string, pointless-statement
+
+## Old style formatting
+
+"%s %z" % ("hello", "world")  # [bad-format-character]
+
+"%s" "%z" % ("hello", "world")  # [bad-format-character]
+
+"""%s %z""" % ("hello", "world")  # [bad-format-character]
+
+"""%s""" """%z""" % ("hello", "world")  # [bad-format-character]
+
+## New style formatting
+
+"{:s} {:y}".format("hello", "world")  # [bad-format-character]
+
+"{:*^30s}".format("centered")
+
+## f-strings
+
+H, W = "hello", "world"
+f"{H} {W}"
+f"{H:s} {W:z}"  # [bad-format-character]
+
+f"{1:z}"  # [bad-format-character]
+
+## False negatives
+
+print(("%" "z") % 1)

crates/ruff/resources/test/fixtures/pylint/bad_string_format_type.py

@@ -13,6 +13,7 @@ print("foo %(foo)d bar %(bar)d" % {"foo": "1", "bar": "2"})
 "%(key)d" % {"key": []}
 print("%d" % ("%s" % ("nested",),))
 "%d" % ((1, 2, 3),)
+"%d" % (1 if x > 0 else [])
 
 # False negatives
 WORD = "abc"
@@ -55,3 +56,4 @@ r'\%03o' % (ord(c),)
 "%d" % (len(foo),)
 '(%r, %r, %r, %r)' % (hostname, address, username, '$PASSWORD')
 '%r' % ({'server_school_roles': server_school_roles, 'is_school_multiserver_domain': is_school_multiserver_domain}, )
+"%d" % (1 if x > 0 else 2)

crates/ruff/resources/test/fixtures/pylint/comparison_with_itself.py

@@ -19,6 +19,10 @@ foo in foo
 
 foo not in foo
 
+id(foo) == id(foo)
+
+len(foo) == len(foo)
+
 # Non-errors.
 "foo" == "foo"  # This is flagged by `comparison-of-constant` instead.
 
@@ -43,3 +47,11 @@ foo is not bar
 foo in bar
 
 foo not in bar
+
+x(foo) == y(foo)
+
+id(foo) == id(bar)
+
+id(foo, bar) == id(foo, bar)
+
+id(foo, bar=1) == id(foo, bar=1)

crates/ruff/resources/test/fixtures/pylint/invalid_all_format.py

@@ -40,3 +40,4 @@ __all__ = __all__ + ["Hello"]
 
 __all__ = __all__ + multiprocessing.__all__
 
+__all__ = list[str](["Hello", "world"])

crates/ruff/resources/test/fixtures/pylint/invalid_envvar_default.py

@@ -10,3 +10,4 @@ os.getenv("AA", "GOOD" + "BAD")
 os.getenv("AA", "GOOD" + 1)
 os.getenv("AA", "GOOD %s" % "BAD")
 os.getenv("B", Z)
+

crates/ruff/resources/test/fixtures/pylint/invalid_envvar_value.py

@@ -10,6 +10,8 @@ os.getenv(key="foo", default="bar")
 os.getenv(key=f"foo", default="bar")
 os.getenv(key="foo" + "bar", default=1)
 os.getenv(key=1 + "bar", default=1)  # [invalid-envvar-value]
+os.getenv("PATH_TEST" if using_clear_path else "PATH_ORIG")
+os.getenv(1 if using_clear_path else "PATH_ORIG")
 
 AA = "aa"
 os.getenv(AA)

crates/ruff/resources/test/fixtures/pylint/logging_too_few_args.py

@@ -19,6 +19,10 @@ logging.error("Example log %s, %s", "foo", "bar", "baz", **kwargs)
 # do not handle keyword arguments
 logging.error("%(objects)d modifications: %(modifications)d errors: %(errors)d")
 
+logging.info(msg="Hello %s")
+
+logging.info(msg="Hello %s %s")
+
 import warning
 
 warning.warning("Hello %s %s", "World!")

crates/ruff/resources/test/fixtures/pylint/logging_too_many_args.py

@@ -15,6 +15,10 @@ logging.error("Example log %s, %s", "foo", "bar", "baz", **kwargs)
 # do not handle keyword arguments
 logging.error("%(objects)d modifications: %(modifications)d errors: %(errors)d", {"objects": 1, "modifications": 1, "errors": 1})
 
+logging.info(msg="Hello")
+
+logging.info(msg="Hello", something="else")
+
 import warning
 
 warning.warning("Hello %s", "World!", "again")

crates/ruff/resources/test/fixtures/pylint/subprocess_run_without_check.py

@@ -0,0 +1,13 @@
+import subprocess
+
+# Errors.
+subprocess.run("ls")
+subprocess.run("ls", shell=True)
+
+# Non-errors.
+subprocess.run("ls", check=True)
+subprocess.run("ls", check=False)
+subprocess.run("ls", shell=True, check=True)
+subprocess.run("ls", shell=True, check=False)
+foo.run("ls")  # Not a subprocess.run call.
+subprocess.bar("ls")  # Not a subprocess.run call.

crates/ruff/resources/test/fixtures/pyupgrade/UP030_0.py

@@ -32,3 +32,30 @@ print(
 )
 
 '{' '0}'.format(1)
+
+args = list(range(10))
+kwargs = {x: x for x in range(10)}
+
+"{0}".format(*args)
+
+"{0}".format(**kwargs)
+
+"{0}_{1}".format(*args)
+
+"{0}_{1}".format(1, *args)
+
+"{0}_{1}".format(1, 2, *args)
+
+"{0}_{1}".format(*args, 1, 2)
+
+"{0}_{1}_{2}".format(1, **kwargs)
+
+"{0}_{1}_{2}".format(1, 2, **kwargs)
+
+"{0}_{1}_{2}".format(1, 2, 3, **kwargs)
+
+"{0}_{1}_{2}".format(1, 2, 3, *args, **kwargs)
+
+"{1}_{0}".format(1, 2, *args)
+
+"{1}_{0}".format(1, 2)

crates/ruff/resources/test/fixtures/pyupgrade/UP030_1.py

@@ -15,3 +15,17 @@ f"{0}".format(1)
 print(f"{0}".format(1))
 
 ''.format(1)
+
+'{1} {0}'.format(*args)
+
+"{1}_{0}".format(*args, 1)
+
+"{1}_{0}".format(*args, 1, 2)
+
+"{1}_{0}".format(1, **kwargs)
+
+"{1}_{0}".format(1, foo=2)
+
+"{1}_{0}".format(1, 2, **kwargs)
+
+"{1}_{0}".format(1, 2, foo=3, bar=4)

crates/ruff/resources/test/fixtures/pyupgrade/UP030_2.py

@@ -1,28 +0,0 @@
-# These SHOULD change
-
-args = list(range(10))
-kwargs = {x: x for x in range(10)}
-
-"{0}".format(*args)
-
-"{0}".format(**kwargs)
-
-"{0}_{1}".format(*args)
-
-"{0}_{1}".format(1, *args)
-
-"{1}_{0}".format(*args)
-
-"{1}_{0}".format(1, *args)
-
-"{0}_{1}".format(1, 2, *args)
-
-"{0}_{1}".format(*args, 1, 2)
-
-"{0}_{1}_{2}".format(1, **kwargs)
-
-"{0}_{1}_{2}".format(1, 2, **kwargs)
-
-"{0}_{1}_{2}".format(1, 2, 3, **kwargs)
-
-"{0}_{1}_{2}".format(1, 2, 3, *args, **kwargs)

crates/ruff/resources/test/fixtures/pyupgrade/UP031_0.py

@@ -106,3 +106,7 @@ print('Hello %(arg)s' % bar['bop'])
     """
     % (x,)
 )
+
+"%s" % (
+    x,  # comment
+)

crates/ruff/resources/test/fixtures/pyupgrade/UP032_0.py

@@ -6,8 +6,12 @@
 
 "{1} {0}".format(a, b)
 
+"{0} {1} {0}".format(a, b)
+
 "{x.y}".format(x=z)
 
+"{x} {y} {x}".format(x=a, y=b)
+
 "{.x} {.y}".format(a, b)
 
 "{} {}".format(a.b, c.d)
@@ -72,6 +76,58 @@ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
     111111
 )
 
+"{a}" "{b}".format(a=1, b=1)
+
+(
+    "{a}"
+    "{b}"
+).format(a=1, b=1)
+
+(
+    "{a}"
+    ""
+    "{b}"
+    ""
+).format(a=1, b=1)
+
+(
+    (
+        # comment
+        "{a}"
+        # comment
+        "{b}"
+    )
+    # comment
+    .format(a=1, b=1)
+)
+
+(
+    "{a}"
+    "b"
+).format(a=1)
+
+
+def d(osname, version, release):
+    return"{}-{}.{}".format(osname, version, release)
+
+
+def e():
+    yield"{}".format(1)
+
+
+assert"{}".format(1)
+
+
+async def c():
+    return "{}".format(await 3)
+
+
+async def c():
+    return "{}".format(1 + await 3)
+
+
+"{}".format(1 * 2)
+
 ###
 # Non-errors
 ###
@@ -85,8 +141,6 @@ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 
 "{} {}".format(*a)
 
-"{0} {0}".format(arg)
-
 "{x} {x}".format(arg)
 
 "{x.y} {x.z}".format(arg)
@@ -103,8 +157,6 @@ b"{} {}".format(a, b)
 
 r'"\N{snowman} {}".format(a)'
 
-"{a}" "{b}".format(a=1, b=1)
-
 "123456789 {}".format(
     11111111111111111111111111111111111111111111111111111111111111111111111111,
 )
@@ -140,20 +192,13 @@ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
     ]
 )
 
-async def c():
-    return "{}".format(await 3)
+(
+    "{a}"
+    "{1 + 2}"
+).format(a=1)
 
+"{}".format(**c)
 
-async def c():
-    return "{}".format(1 + await 3)
-
-
-def d(osname, version, release):
-    return"{}-{}.{}".format(osname, version, release)
-
-
-def e():
-    yield"{}".format(1)
-
-
-assert"{}".format(1)
+"{}".format(
+    1  # comment
+)

crates/ruff/resources/test/fixtures/pyupgrade/UP035.py

@@ -46,6 +46,35 @@ from typing import Callable, Match, Pattern, List, OrderedDict, AbstractSet, Con
 if True: from collections import (
     Mapping, Counter)
 
+# Bad imports from PYI027 that are now handled by PYI022 (UP035)
+from typing import ContextManager
+from typing import OrderedDict
+from typing_extensions import OrderedDict
+from typing import Callable
+from typing import ByteString
+from typing import Container
+from typing import Hashable
+from typing import ItemsView
+from typing import Iterable
+from typing import Iterator
+from typing import KeysView
+from typing import Mapping
+from typing import MappingView
+from typing import MutableMapping
+from typing import MutableSequence
+from typing import MutableSet
+from typing import Sequence
+from typing import Sized
+from typing import ValuesView
+from typing import Awaitable
+from typing import AsyncIterator
+from typing import AsyncIterable
+from typing import Coroutine
+from typing import Collection
+from typing import AsyncGenerator
+from typing import Reversible
+from typing import Generator
+
 # OK
 from a import b
 

crates/ruff/resources/test/fixtures/pyupgrade/UP037.py

@@ -1,5 +1,3 @@
-"""A mirror of UP037_1.py, with `from __future__ import annotations`."""
-
 from __future__ import annotations
 
 from typing import (

crates/ruff/resources/test/fixtures/pyupgrade/UP037_1.py

@@ -1,108 +0,0 @@
-"""A mirror of UP037_0.py, without `from __future__ import annotations`."""
-
-from typing import (
-    Annotated,
-    Callable,
-    List,
-    Literal,
-    NamedTuple,
-    Tuple,
-    TypeVar,
-    TypedDict,
-    cast,
-)
-
-from mypy_extensions import Arg, DefaultArg, DefaultNamedArg, NamedArg, VarArg
-
-
-def foo(var: "MyClass") -> "MyClass":
-    x: "MyClass"
-
-
-def foo(*, inplace: "bool"):
-    pass
-
-
-def foo(*args: "str", **kwargs: "int"):
-    pass
-
-
-x: Tuple["MyClass"]
-
-x: Callable[["MyClass"], None]
-
-
-class Foo(NamedTuple):
-    x: "MyClass"
-
-
-class D(TypedDict):
-    E: TypedDict("E", foo="int", total=False)
-
-
-class D(TypedDict):
-    E: TypedDict("E", {"foo": "int"})
-
-
-x: Annotated["str", "metadata"]
-
-x: Arg("str", "name")
-
-x: DefaultArg("str", "name")
-
-x: NamedArg("str", "name")
-
-x: DefaultNamedArg("str", "name")
-
-x: DefaultNamedArg("str", name="name")
-
-x: VarArg("str")
-
-x: List[List[List["MyClass"]]]
-
-x: NamedTuple("X", [("foo", "int"), ("bar", "str")])
-
-x: NamedTuple("X", fields=[("foo", "int"), ("bar", "str")])
-
-x: NamedTuple(typename="X", fields=[("foo", "int")])
-
-X: MyCallable("X")
-
-
-# OK
-class D(TypedDict):
-    E: TypedDict("E")
-
-
-x: Annotated[()]
-
-x: DefaultNamedArg(name="name", quox="str")
-
-x: DefaultNamedArg(name="name")
-
-x: NamedTuple("X", [("foo",), ("bar",)])
-
-x: NamedTuple("X", ["foo", "bar"])
-
-x: NamedTuple()
-
-x: Literal["foo", "bar"]
-
-x = cast(x, "str")
-
-
-def foo(x, *args, **kwargs):
-    ...
-
-
-def foo(*, inplace):
-    ...
-
-
-x: Annotated[1:2] = ...
-
-x = TypeVar("x", "str", "int")
-
-x = cast("str", x)
-
-X = List["MyClass"]

crates/ruff/resources/test/fixtures/pyupgrade/UP040.py

@@ -0,0 +1,47 @@
+import typing
+from typing import TypeAlias
+
+# UP040
+x: typing.TypeAlias = int
+x: TypeAlias = int
+
+# UP040 simple generic
+T = typing.TypeVar["T"]
+x: typing.TypeAlias = list[T]
+
+# UP040 call style generic
+T = typing.TypeVar("T")
+x: typing.TypeAlias = list[T]
+
+# UP040 bounded generic (todo)
+T = typing.TypeVar("T", bound=int)
+x: typing.TypeAlias = list[T]
+
+T = typing.TypeVar("T", int, str)
+x: typing.TypeAlias = list[T]
+
+# UP040 contravariant generic (todo)
+T = typing.TypeVar("T", contravariant=True)
+x: typing.TypeAlias = list[T]
+
+# UP040 covariant generic (todo)
+T = typing.TypeVar("T", covariant=True)
+x: typing.TypeAlias = list[T]
+
+# UP040 in class scope
+T = typing.TypeVar["T"]
+class Foo:
+    # reference to global variable
+    x: typing.TypeAlias = list[T]
+
+    # reference to class variable
+    TCLS = typing.TypeVar["TCLS"]
+    y: typing.TypeAlias = list[TCLS]
+
+# UP040 wont add generics in fix
+T = typing.TypeVar(*args)
+x: typing.TypeAlias = list[T]
+
+# OK
+x: TypeAlias
+x: int = 1

crates/ruff/resources/test/fixtures/ruff/RUF012.py

@@ -11,6 +11,8 @@ class A:
     without_annotation = []
     class_variable: ClassVar[list[int]] = []
     final_variable: Final[list[int]] = []
+    class_variable_without_subscript: ClassVar = []
+    final_variable_without_subscript: Final = []
 
 
 from dataclasses import dataclass, field

crates/ruff/resources/test/fixtures/ruff/RUF017.py

@@ -0,0 +1,14 @@
+x = [1, 2, 3]
+y = [4, 5, 6]
+
+# RUF017
+sum([x, y], start=[])
+sum([x, y], [])
+sum([[1, 2, 3], [4, 5, 6]], start=[])
+sum([[1, 2, 3], [4, 5, 6]], [])
+sum([[1, 2, 3], [4, 5, 6]],
+    [])
+
+# OK
+sum([x, y])
+sum([[1, 2, 3], [4, 5, 6]])

crates/ruff/resources/test/fixtures/ruff/RUF100_4.py

@@ -0,0 +1,5 @@
+# ruff: noqa: RUF100
+
+import os  # noqa: F401
+
+print(os.sep)

crates/ruff/resources/test/fixtures/tryceratops/TRY003.py

@@ -52,3 +52,7 @@ def good(a: int):
 def another_good(a):
     if a % 2 == 0:
         raise GoodArgCantBeEven(a)
+
+
+def another_good():
+    raise NotImplementedError("This is acceptable too")

crates/ruff/src/autofix/codemods.rs

@@ -33,7 +33,7 @@ impl<'a, T: Codegen<'a>> CodegenStylist<'a> for T {
 ///
 /// Returns `Ok(None)` if the statement is empty after removing the imports.
 pub(crate) fn remove_imports<'a>(
-    imports: impl Iterator<Item = &'a str>,
+    member_names: impl Iterator<Item = &'a str>,
     stmt: &Stmt,
     locator: &Locator,
     stylist: &Stylist,
@@ -45,27 +45,20 @@ pub(crate) fn remove_imports<'a>(
         bail!("Expected Statement::Simple");
     };
 
-    let (aliases, import_module) = match body.body.first_mut() {
-        Some(SmallStatement::Import(import_body)) => (&mut import_body.names, None),
+    let aliases = match body.body.first_mut() {
+        Some(SmallStatement::Import(import_body)) => &mut import_body.names,
         Some(SmallStatement::ImportFrom(import_body)) => {
             if let ImportNames::Aliases(names) = &mut import_body.names {
-                (
-                    names,
-                    Some((&import_body.relative, import_body.module.as_ref())),
-                )
+                names
             } else if let ImportNames::Star(..) = &import_body.names {
                 // Special-case: if the import is a `from ... import *`, then we delete the
                 // entire statement.
                 let mut found_star = false;
-                for import in imports {
-                    let qualified_name = match import_body.module.as_ref() {
-                        Some(module_name) => format!("{}.*", compose_module_path(module_name)),
-                        None => "*".to_string(),
-                    };
-                    if import == qualified_name {
+                for member in member_names {
+                    if member == "*" {
                         found_star = true;
                     } else {
-                        bail!("Expected \"*\" for unused import (got: \"{}\")", import);
+                        bail!("Expected \"*\" for unused import (got: \"{}\")", member);
                     }
                 }
                 if !found_star {
@@ -82,30 +75,10 @@ pub(crate) fn remove_imports<'a>(
     // Preserve the trailing comma (or not) from the last entry.
     let trailing_comma = aliases.last().and_then(|alias| alias.comma.clone());
 
-    for import in imports {
-        let alias_index = aliases.iter().position(|alias| {
-            let qualified_name = match import_module {
-                Some((relative, module)) => {
-                    let module = module.map(compose_module_path);
-                    let member = compose_module_path(&alias.name);
-                    let mut qualified_name = String::with_capacity(
-                        relative.len() + module.as_ref().map_or(0, String::len) + member.len() + 1,
-                    );
-                    for _ in 0..relative.len() {
-                        qualified_name.push('.');
-                    }
-                    if let Some(module) = module {
-                        qualified_name.push_str(&module);
-                        qualified_name.push('.');
-                    }
-                    qualified_name.push_str(&member);
-                    qualified_name
-                }
-                None => compose_module_path(&alias.name),
-            };
-            qualified_name == import
-        });
-
+    for member in member_names {
+        let alias_index = aliases
+            .iter()
+            .position(|alias| member == compose_module_path(&alias.name));
         if let Some(index) = alias_index {
             aliases.remove(index);
         }
@@ -139,7 +112,7 @@ pub(crate) fn remove_imports<'a>(
 ///
 /// Returns the modified import statement.
 pub(crate) fn retain_imports(
-    imports: &[&str],
+    member_names: &[&str],
     stmt: &Stmt,
     locator: &Locator,
     stylist: &Stylist,
@@ -151,14 +124,11 @@ pub(crate) fn retain_imports(
         bail!("Expected Statement::Simple");
     };
 
-    let (aliases, import_module) = match body.body.first_mut() {
-        Some(SmallStatement::Import(import_body)) => (&mut import_body.names, None),
+    let aliases = match body.body.first_mut() {
+        Some(SmallStatement::Import(import_body)) => &mut import_body.names,
         Some(SmallStatement::ImportFrom(import_body)) => {
             if let ImportNames::Aliases(names) = &mut import_body.names {
-                (
-                    names,
-                    Some((&import_body.relative, import_body.module.as_ref())),
-                )
+                names
             } else {
                 bail!("Expected: ImportNames::Aliases");
             }
@@ -170,28 +140,9 @@ pub(crate) fn retain_imports(
     let trailing_comma = aliases.last().and_then(|alias| alias.comma.clone());
 
     aliases.retain(|alias| {
-        imports.iter().any(|import| {
-            let qualified_name = match import_module {
-                Some((relative, module)) => {
-                    let module = module.map(compose_module_path);
-                    let member = compose_module_path(&alias.name);
-                    let mut qualified_name = String::with_capacity(
-                        relative.len() + module.as_ref().map_or(0, String::len) + member.len() + 1,
-                    );
-                    for _ in 0..relative.len() {
-                        qualified_name.push('.');
-                    }
-                    if let Some(module) = module {
-                        qualified_name.push_str(&module);
-                        qualified_name.push('.');
-                    }
-                    qualified_name.push_str(&member);
-                    qualified_name
-                }
-                None => compose_module_path(&alias.name),
-            };
-            qualified_name == *import
-        })
+        member_names
+            .iter()
+            .any(|member| *member == compose_module_path(&alias.name))
     });
 
     // But avoid destroying any trailing comments.

crates/ruff/src/autofix/edits.rs

@@ -1,14 +1,17 @@
 //! Interface for generating autofix edits from higher-level actions (e.g., "remove an argument").
+
 use anyhow::{bail, Result};
-use ruff_python_ast::{self as ast, ExceptHandler, Expr, Keyword, Ranged, Stmt};
-use ruff_python_parser::{lexer, Mode};
-use ruff_text_size::{TextLen, TextRange, TextSize};
 
 use ruff_diagnostics::Edit;
+use ruff_python_ast::{
+    self as ast, Arguments, ExceptHandler, Expr, Keyword, PySourceType, Ranged, Stmt,
+};
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
+use ruff_python_parser::{lexer, AsMode};
 use ruff_python_trivia::{has_leading_content, is_python_whitespace, PythonWhitespace};
 use ruff_source_file::{Locator, NewlineWithTrailingNewline};
+use ruff_text_size::{TextLen, TextRange, TextSize};
 
 use crate::autofix::codemods;
 
@@ -55,118 +58,115 @@ pub(crate) fn delete_stmt(
 
 /// Generate a `Fix` to remove the specified imports from an `import` statement.
 pub(crate) fn remove_unused_imports<'a>(
-    unused_imports: impl Iterator<Item = &'a str>,
+    member_names: impl Iterator<Item = &'a str>,
     stmt: &Stmt,
     parent: Option<&Stmt>,
     locator: &Locator,
     stylist: &Stylist,
     indexer: &Indexer,
 ) -> Result<Edit> {
-    match codemods::remove_imports(unused_imports, stmt, locator, stylist)? {
+    match codemods::remove_imports(member_names, stmt, locator, stylist)? {
         None => Ok(delete_stmt(stmt, parent, locator, indexer)),
         Some(content) => Ok(Edit::range_replacement(content, stmt.range())),
     }
 }
 
+#[derive(Debug, Copy, Clone)]
+pub(crate) enum Parentheses {
+    /// Remove parentheses, if the removed argument is the only argument left.
+    Remove,
+    /// Preserve parentheses, even if the removed argument is the only argument
+    Preserve,
+}
+
 /// Generic function to remove arguments or keyword arguments in function
 /// calls and class definitions. (For classes `args` should be considered
 /// `bases`)
 ///
 /// Supports the removal of parentheses when this is the only (kw)arg left.
 /// For this behavior, set `remove_parentheses` to `true`.
-pub(crate) fn remove_argument(
+pub(crate) fn remove_argument<T: Ranged>(
+    argument: &T,
+    arguments: &Arguments,
+    parentheses: Parentheses,
     locator: &Locator,
-    call_at: TextSize,
-    expr_range: TextRange,
-    args: &[Expr],
-    keywords: &[Keyword],
-    remove_parentheses: bool,
+    source_type: PySourceType,
 ) -> Result<Edit> {
     // TODO(sbrugman): Preserve trailing comments.
-    let contents = locator.after(call_at);
+    if arguments.keywords.len() + arguments.args.len() > 1 {
+        let mut fix_start = None;
+        let mut fix_end = None;
 
-    let mut fix_start = None;
-    let mut fix_end = None;
-
-    let n_arguments = keywords.len() + args.len();
-    if n_arguments == 0 {
-        bail!("No arguments or keywords to remove");
-    }
-
-    if n_arguments == 1 {
-        // Case 1: there is only one argument.
-        let mut count = 0u32;
-        for (tok, range) in lexer::lex_starts_at(contents, Mode::Module, call_at).flatten() {
-            if tok.is_lpar() {
-                if count == 0 {
-                    fix_start = Some(if remove_parentheses {
-                        range.start()
-                    } else {
-                        range.start() + TextSize::from(1)
-                    });
-                }
-                count = count.saturating_add(1);
-            }
-
-            if tok.is_rpar() {
-                count = count.saturating_sub(1);
-                if count == 0 {
-                    fix_end = Some(if remove_parentheses {
+        if arguments
+            .args
+            .iter()
+            .map(Expr::start)
+            .chain(arguments.keywords.iter().map(Keyword::start))
+            .any(|location| location > argument.start())
+        {
+            // Case 1: argument or keyword is _not_ the last node, so delete from the start of the
+            // argument to the end of the subsequent comma.
+            let mut seen_comma = false;
+            for (tok, range) in lexer::lex_starts_at(
+                locator.slice(arguments.range()),
+                source_type.as_mode(),
+                arguments.start(),
+            )
+            .flatten()
+            {
+                if seen_comma {
+                    if tok.is_non_logical_newline() {
+                        // Also delete any non-logical newlines after the comma.
+                        continue;
+                    }
+                    fix_end = Some(if tok.is_newline() {
                         range.end()
                     } else {
-                        range.end() - TextSize::from(1)
+                        range.start()
                     });
                     break;
                 }
+                if range.start() == argument.start() {
+                    fix_start = Some(range.start());
+                }
+                if fix_start.is_some() && tok.is_comma() {
+                    seen_comma = true;
+                }
+            }
+        } else {
+            // Case 2: argument or keyword is the last node, so delete from the start of the
+            // previous comma to the end of the argument.
+            for (tok, range) in lexer::lex_starts_at(
+                locator.slice(arguments.range()),
+                source_type.as_mode(),
+                arguments.start(),
+            )
+            .flatten()
+            {
+                if range.start() == argument.start() {
+                    fix_end = Some(argument.end());
+                    break;
+                }
+                if tok.is_comma() {
+                    fix_start = Some(range.start());
+                }
             }
         }
-    } else if args
-        .iter()
-        .map(Expr::start)
-        .chain(keywords.iter().map(Keyword::start))
-        .any(|location| location > expr_range.start())
-    {
-        // Case 2: argument or keyword is _not_ the last node.
-        let mut seen_comma = false;
-        for (tok, range) in lexer::lex_starts_at(contents, Mode::Module, call_at).flatten() {
-            if seen_comma {
-                if tok.is_non_logical_newline() {
-                    // Also delete any non-logical newlines after the comma.
-                    continue;
-                }
-                fix_end = Some(if tok.is_newline() {
-                    range.end()
-                } else {
-                    range.start()
-                });
-                break;
-            }
-            if range.start() == expr_range.start() {
-                fix_start = Some(range.start());
-            }
-            if fix_start.is_some() && tok.is_comma() {
-                seen_comma = true;
+
+        match (fix_start, fix_end) {
+            (Some(start), Some(end)) => Ok(Edit::deletion(start, end)),
+            _ => {
+                bail!("No fix could be constructed")
             }
         }
     } else {
-        // Case 3: argument or keyword is the last node, so we have to find the last
-        // comma in the stmt.
-        for (tok, range) in lexer::lex_starts_at(contents, Mode::Module, call_at).flatten() {
-            if range.start() == expr_range.start() {
-                fix_end = Some(expr_range.end());
-                break;
+        // Only one argument; remove it (but preserve parentheses, if needed).
+        Ok(match parentheses {
+            Parentheses::Remove => Edit::deletion(arguments.start(), arguments.end()),
+            Parentheses::Preserve => {
+                Edit::replacement("()".to_string(), arguments.start(), arguments.end())
             }
-            if tok.is_comma() {
-                fix_start = Some(range.start());
-            }
-        }
-    }
-
-    match (fix_start, fix_end) {
-        (Some(start), Some(end)) => Ok(Edit::deletion(start, end)),
-        _ => {
-            bail!("No fix could be constructed")
-        }
+        })
     }
 }
 
@@ -179,16 +179,13 @@ fn is_only<T: PartialEq>(vec: &[T], value: &T) -> bool {
 fn is_lone_child(child: &Stmt, parent: &Stmt) -> bool {
     match parent {
         Stmt::FunctionDef(ast::StmtFunctionDef { body, .. })
-        | Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef { body, .. })
         | Stmt::ClassDef(ast::StmtClassDef { body, .. })
-        | Stmt::With(ast::StmtWith { body, .. })
-        | Stmt::AsyncWith(ast::StmtAsyncWith { body, .. }) => {
+        | Stmt::With(ast::StmtWith { body, .. }) => {
             if is_only(body, child) {
                 return true;
             }
         }
         Stmt::For(ast::StmtFor { body, orelse, .. })
-        | Stmt::AsyncFor(ast::StmtAsyncFor { body, orelse, .. })
         | Stmt::While(ast::StmtWhile { body, orelse, .. }) => {
             if is_only(body, child) || is_only(orelse, child) {
                 return true;
@@ -212,14 +209,7 @@ fn is_lone_child(child: &Stmt, parent: &Stmt) -> bool {
             handlers,
             orelse,
             finalbody,
-            range: _,
-        })
-        | Stmt::TryStar(ast::StmtTryStar {
-            body,
-            handlers,
-            orelse,
-            finalbody,
-            range: _,
+            ..
         }) => {
             if is_only(body, child)
                 || is_only(orelse, child)
@@ -294,24 +284,24 @@ fn next_stmt_break(semicolon: TextSize, locator: &Locator) -> TextSize {
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
-    use ruff_python_ast::{Ranged, Suite};
-    use ruff_python_parser::Parse;
-    use ruff_text_size::TextSize;
 
+    use ruff_python_ast::Ranged;
+    use ruff_python_parser::parse_suite;
     use ruff_source_file::Locator;
+    use ruff_text_size::TextSize;
 
     use crate::autofix::edits::{next_stmt_break, trailing_semicolon};
 
     #[test]
     fn find_semicolon() -> Result<()> {
         let contents = "x = 1";
-        let program = Suite::parse(contents, "<filename>")?;
+        let program = parse_suite(contents, "<filename>")?;
         let stmt = program.first().unwrap();
         let locator = Locator::new(contents);
         assert_eq!(trailing_semicolon(stmt.end(), &locator), None);
 
         let contents = "x = 1; y = 1";
-        let program = Suite::parse(contents, "<filename>")?;
+        let program = parse_suite(contents, "<filename>")?;
         let stmt = program.first().unwrap();
         let locator = Locator::new(contents);
         assert_eq!(
@@ -320,7 +310,7 @@ mod tests {
         );
 
         let contents = "x = 1 ; y = 1";
-        let program = Suite::parse(contents, "<filename>")?;
+        let program = parse_suite(contents, "<filename>")?;
         let stmt = program.first().unwrap();
         let locator = Locator::new(contents);
         assert_eq!(
@@ -333,7 +323,7 @@ x = 1 \
   ; y = 1
 "
         .trim();
-        let program = Suite::parse(contents, "<filename>")?;
+        let program = parse_suite(contents, "<filename>")?;
         let stmt = program.first().unwrap();
         let locator = Locator::new(contents);
         assert_eq!(

crates/ruff/src/autofix/mod.rs

@@ -76,7 +76,7 @@ fn apply_fixes<'a>(
             }
 
             // If this fix overlaps with a fix we've already applied, skip it.
-            if last_pos.map_or(false, |last_pos| last_pos >= first.start()) {
+            if last_pos.is_some_and(|last_pos| last_pos >= first.start()) {
                 continue;
             }
         }

crates/ruff/src/checkers/ast/analyze/bindings.rs

@@ -16,9 +16,15 @@ pub(crate) fn bindings(checker: &mut Checker) {
         return;
     }
 
-    for binding in checker.semantic.bindings.iter() {
+    for binding in &*checker.semantic.bindings {
         if checker.enabled(Rule::UnusedVariable) {
-            if binding.kind.is_bound_exception() && !binding.is_used() {
+            if binding.kind.is_bound_exception()
+                && !binding.is_used()
+                && !checker
+                    .settings
+                    .dummy_variable_rgx
+                    .is_match(binding.name(checker.locator))
+            {
                 let mut diagnostic = Diagnostic::new(
                     pyflakes::rules::UnusedVariable {
                         name: binding.name(checker.locator).to_string(),
@@ -56,13 +62,11 @@ pub(crate) fn bindings(checker: &mut Checker) {
                 checker.diagnostics.push(diagnostic);
             }
         }
-        if checker.is_stub {
-            if checker.enabled(Rule::UnaliasedCollectionsAbcSetImport) {
-                if let Some(diagnostic) =
-                    flake8_pyi::rules::unaliased_collections_abc_set_import(checker, binding)
-                {
-                    checker.diagnostics.push(diagnostic);
-                }
+        if checker.enabled(Rule::UnaliasedCollectionsAbcSetImport) {
+            if let Some(diagnostic) =
+                flake8_pyi::rules::unaliased_collections_abc_set_import(checker, binding)
+            {
+                checker.diagnostics.push(diagnostic);
             }
         }
     }

crates/ruff/src/checkers/ast/analyze/deferred_for_loops.rs

@@ -11,21 +11,18 @@ pub(crate) fn deferred_for_loops(checker: &mut Checker) {
         for snapshot in for_loops {
             checker.semantic.restore(snapshot);
 
-            if let Stmt::For(ast::StmtFor {
+            let Stmt::For(ast::StmtFor {
                 target, iter, body, ..
-            })
-            | Stmt::AsyncFor(ast::StmtAsyncFor {
-                target, iter, body, ..
-            }) = &checker.semantic.stmt()
-            {
-                if checker.enabled(Rule::UnusedLoopControlVariable) {
-                    flake8_bugbear::rules::unused_loop_control_variable(checker, target, body);
-                }
-                if checker.enabled(Rule::IncorrectDictIterator) {
-                    perflint::rules::incorrect_dict_iterator(checker, target, iter);
-                }
-            } else {
-                unreachable!("Expected Expr::For | Expr::AsyncFor");
+            }) = checker.semantic.current_statement()
+            else {
+                unreachable!("Expected Stmt::For");
+            };
+
+            if checker.enabled(Rule::UnusedLoopControlVariable) {
+                flake8_bugbear::rules::unused_loop_control_variable(checker, target, body);
+            }
+            if checker.enabled(Rule::IncorrectDictIterator) {
+                perflint::rules::incorrect_dict_iterator(checker, target, iter);
             }
         }
     }

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

@@ -1,5 +1,4 @@
 use ruff_diagnostics::Diagnostic;
-use ruff_python_ast::cast;
 use ruff_python_semantic::analyze::{branch_detection, visibility};
 use ruff_python_semantic::{Binding, BindingKind, ScopeKind};
 
@@ -37,7 +36,7 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
     // Identify any valid runtime imports. If a module is imported at runtime, and
     // used at runtime, then by default, we avoid flagging any other
     // imports from that model as typing-only.
-    let enforce_typing_imports = !checker.is_stub
+    let enforce_typing_imports = !checker.source_type.is_stub()
         && checker.any_enabled(&[
             Rule::RuntimeImportInTypeCheckingBlock,
             Rule::TypingOnlyFirstPartyImport,
@@ -112,7 +111,11 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                     // If the bindings are in different forks, abort.
                     if shadowed.source.map_or(true, |left| {
                         binding.source.map_or(true, |right| {
-                            branch_detection::different_forks(left, right, &checker.semantic.stmts)
+                            branch_detection::different_forks(
+                                left,
+                                right,
+                                checker.semantic.statements(),
+                            )
                         })
                     }) {
                         continue;
@@ -168,16 +171,25 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                             continue;
                         }
 
-                        // If this is an overloaded function, abort.
-                        if shadowed.kind.is_function_definition()
-                            && visibility::is_overload(
-                                cast::decorator_list(
-                                    checker.semantic.stmts[shadowed.source.unwrap()],
-                                ),
-                                &checker.semantic,
-                            )
-                        {
+                        let Some(statement_id) = shadowed.source else {
                             continue;
+                        };
+
+                        // If this is an overloaded function, abort.
+                        if shadowed.kind.is_function_definition() {
+                            if checker
+                                .semantic
+                                .statement(statement_id)
+                                .as_function_def_stmt()
+                                .is_some_and(|function| {
+                                    visibility::is_overload(
+                                        &function.decorator_list,
+                                        &checker.semantic,
+                                    )
+                                })
+                            {
+                                continue;
+                            }
                         }
                     } else {
                         // Only enforce cross-scope shadowing for imports.
@@ -195,7 +207,11 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                     // If the bindings are in different forks, abort.
                     if shadowed.source.map_or(true, |left| {
                         binding.source.map_or(true, |right| {
-                            branch_detection::different_forks(left, right, &checker.semantic.stmts)
+                            branch_detection::different_forks(
+                                left,
+                                right,
+                                checker.semantic.statements(),
+                            )
                         })
                     }) {
                         continue;
@@ -218,25 +234,20 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
             }
         }
 
-        if checker.is_stub {
-            if checker.enabled(Rule::UnusedPrivateTypeVar) {
-                flake8_pyi::rules::unused_private_type_var(checker, scope, &mut diagnostics);
-            }
-            if checker.enabled(Rule::UnusedPrivateProtocol) {
-                flake8_pyi::rules::unused_private_protocol(checker, scope, &mut diagnostics);
-            }
-            if checker.enabled(Rule::UnusedPrivateTypeAlias) {
-                flake8_pyi::rules::unused_private_type_alias(checker, scope, &mut diagnostics);
-            }
-            if checker.enabled(Rule::UnusedPrivateTypedDict) {
-                flake8_pyi::rules::unused_private_typed_dict(checker, scope, &mut diagnostics);
-            }
+        if checker.enabled(Rule::UnusedPrivateTypeVar) {
+            flake8_pyi::rules::unused_private_type_var(checker, scope, &mut diagnostics);
+        }
+        if checker.enabled(Rule::UnusedPrivateProtocol) {
+            flake8_pyi::rules::unused_private_protocol(checker, scope, &mut diagnostics);
+        }
+        if checker.enabled(Rule::UnusedPrivateTypeAlias) {
+            flake8_pyi::rules::unused_private_type_alias(checker, scope, &mut diagnostics);
+        }
+        if checker.enabled(Rule::UnusedPrivateTypedDict) {
+            flake8_pyi::rules::unused_private_typed_dict(checker, scope, &mut diagnostics);
         }
 
-        if matches!(
-            scope.kind,
-            ScopeKind::Function(_) | ScopeKind::AsyncFunction(_) | ScopeKind::Lambda(_)
-        ) {
+        if matches!(scope.kind, ScopeKind::Function(_) | ScopeKind::Lambda(_)) {
             if checker.enabled(Rule::UnusedVariable) {
                 pyflakes::rules::unused_variable(checker, scope, &mut diagnostics);
             }
@@ -245,7 +256,7 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
                 pyflakes::rules::unused_annotation(checker, scope, &mut diagnostics);
             }
 
-            if !checker.is_stub {
+            if !checker.source_type.is_stub() {
                 if checker.any_enabled(&[
                     Rule::UnusedClassMethodArgument,
                     Rule::UnusedFunctionArgument,
@@ -262,10 +273,7 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
             }
         }
 
-        if matches!(
-            scope.kind,
-            ScopeKind::Function(_) | ScopeKind::AsyncFunction(_) | ScopeKind::Module
-        ) {
+        if matches!(scope.kind, ScopeKind::Function(_) | ScopeKind::Module) {
             if enforce_typing_imports {
                 let runtime_imports: Vec<&Binding> = checker
                     .semantic

crates/ruff/src/checkers/ast/analyze/definitions.rs

@@ -30,8 +30,8 @@ pub(crate) fn definitions(checker: &mut Checker) {
         Rule::MissingTypeKwargs,
         Rule::MissingTypeSelf,
     ]);
-    let enforce_stubs = checker.is_stub
-        && checker.any_enabled(&[Rule::DocstringInStub, Rule::IterMethodReturnIterable]);
+    let enforce_stubs = checker.source_type.is_stub() && checker.enabled(Rule::DocstringInStub);
+    let enforce_stubs_and_runtime = checker.enabled(Rule::IterMethodReturnIterable);
     let enforce_docstrings = checker.any_enabled(&[
         Rule::BlankLineAfterLastSection,
         Rule::BlankLineAfterSummary,
@@ -81,7 +81,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
         Rule::UndocumentedPublicPackage,
     ]);
 
-    if !enforce_annotations && !enforce_docstrings && !enforce_stubs {
+    if !enforce_annotations && !enforce_docstrings && !enforce_stubs && !enforce_stubs_and_runtime {
         return;
     }
 
@@ -117,7 +117,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
             // interfaces, without any AST nodes in between. Right now, we
             // only error when traversing definition boundaries (functions,
             // classes, etc.).
-            if !overloaded_name.map_or(false, |overloaded_name| {
+            if !overloaded_name.is_some_and(|overloaded_name| {
                 flake8_annotations::helpers::is_overload_impl(
                     definition,
                     &overloaded_name,
@@ -141,6 +141,8 @@ pub(crate) fn definitions(checker: &mut Checker) {
             if checker.enabled(Rule::DocstringInStub) {
                 flake8_pyi::rules::docstring_in_stubs(checker, docstring);
             }
+        }
+        if enforce_stubs_and_runtime {
             if checker.enabled(Rule::IterMethodReturnIterable) {
                 flake8_pyi::rules::iter_method_return_iterable(checker, definition);
             }
@@ -169,7 +171,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
                 expr.start(),
             ));
 
-            if pydocstyle::helpers::should_ignore_docstring(contents) {
+            if pydocstyle::helpers::should_ignore_docstring(expr) {
                 #[allow(deprecated)]
                 let location = checker.locator.compute_source_location(expr.start());
                 warn_user!(

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

@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Constant, Expr, ExprContext, Operator, Ranged};
+use ruff_python_ast::{self as ast, Arguments, Constant, Expr, ExprContext, Operator, Ranged};
 use ruff_python_literal::cformat::{CFormatError, CFormatErrorType};
 
 use ruff_diagnostics::Diagnostic;
@@ -31,7 +31,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 if let Some(operator) = typing::to_pep604_operator(value, slice, &checker.semantic)
                 {
                     if checker.enabled(Rule::FutureRewritableTypeAnnotation) {
-                        if !checker.is_stub
+                        if !checker.source_type.is_stub()
                             && checker.settings.target_version < PythonVersion::Py310
                             && checker.settings.target_version >= PythonVersion::Py37
                             && !checker.semantic.future_annotations()
@@ -44,7 +44,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                         }
                     }
                     if checker.enabled(Rule::NonPEP604Annotation) {
-                        if checker.is_stub
+                        if checker.source_type.is_stub()
                             || checker.settings.target_version >= PythonVersion::Py310
                             || (checker.settings.target_version >= PythonVersion::Py37
                                 && checker.semantic.future_annotations()
@@ -59,7 +59,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
 
             // Ex) list[...]
             if checker.enabled(Rule::FutureRequiredTypeAnnotation) {
-                if !checker.is_stub
+                if !checker.source_type.is_stub()
                     && checker.settings.target_version < PythonVersion::Py39
                     && !checker.semantic.future_annotations()
                     && checker.semantic.in_annotation()
@@ -74,24 +74,27 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             }
 
             // Ex) Union[...]
-            if checker.any_enabled(&[Rule::UnnecessaryLiteralUnion, Rule::DuplicateUnionMember]) {
-                // Determine if the current expression is an union
-                // Avoid duplicate checks if the parent is an `Union[...]` since these rules traverse nested unions
-                let is_unchecked_union = checker
-                    .semantic
-                    .expr_grandparent()
-                    .and_then(Expr::as_subscript_expr)
-                    .map_or(true, |parent| {
-                        !checker.semantic.match_typing_expr(&parent.value, "Union")
-                    });
-
-                if is_unchecked_union {
+            if checker.any_enabled(&[
+                Rule::UnnecessaryLiteralUnion,
+                Rule::DuplicateUnionMember,
+                Rule::RedundantLiteralUnion,
+                Rule::UnnecessaryTypeUnion,
+            ]) {
+                // Avoid duplicate checks if the parent is a union, since these rules already
+                // traverse nested unions.
+                if !checker.semantic.in_nested_union() {
                     if checker.enabled(Rule::UnnecessaryLiteralUnion) {
                         flake8_pyi::rules::unnecessary_literal_union(checker, expr);
                     }
                     if checker.enabled(Rule::DuplicateUnionMember) {
                         flake8_pyi::rules::duplicate_union_member(checker, expr);
                     }
+                    if checker.enabled(Rule::RedundantLiteralUnion) {
+                        flake8_pyi::rules::redundant_literal_union(checker, expr);
+                    }
+                    if checker.enabled(Rule::UnnecessaryTypeUnion) {
+                        flake8_pyi::rules::unnecessary_type_union(checker, expr);
+                    }
                 }
             }
 
@@ -152,10 +155,8 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                     if checker.enabled(Rule::NumpyDeprecatedFunction) {
                         numpy::rules::deprecated_function(checker, expr);
                     }
-                    if checker.is_stub {
-                        if checker.enabled(Rule::CollectionsNamedTuple) {
-                            flake8_pyi::rules::collections_named_tuple(checker, expr);
-                        }
+                    if checker.enabled(Rule::CollectionsNamedTuple) {
+                        flake8_pyi::rules::collections_named_tuple(checker, expr);
                     }
 
                     // Ex) List[...]
@@ -167,20 +168,18 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                             typing::to_pep585_generic(expr, &checker.semantic)
                         {
                             if checker.enabled(Rule::FutureRewritableTypeAnnotation) {
-                                if !checker.is_stub
+                                if !checker.source_type.is_stub()
                                     && checker.settings.target_version < PythonVersion::Py39
                                     && checker.settings.target_version >= PythonVersion::Py37
                                     && !checker.semantic.future_annotations()
                                     && checker.semantic.in_annotation()
                                     && !checker.settings.pyupgrade.keep_runtime_typing
                                 {
-                                    flake8_future_annotations::rules::future_rewritable_type_annotation(
-                                                checker, expr,
-                                            );
+                                    flake8_future_annotations::rules::future_rewritable_type_annotation(checker, expr);
                                 }
                             }
                             if checker.enabled(Rule::NonPEP585Annotation) {
-                                if checker.is_stub
+                                if checker.source_type.is_stub()
                                     || checker.settings.target_version >= PythonVersion::Py39
                                     || (checker.settings.target_version >= PythonVersion::Py37
                                         && checker.semantic.future_annotations()
@@ -199,13 +198,13 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 }
                 ExprContext::Store => {
                     if checker.enabled(Rule::NonLowercaseVariableInFunction) {
-                        if checker.semantic.scope().kind.is_any_function() {
+                        if checker.semantic.current_scope().kind.is_function() {
                             // Ignore globals.
                             if !checker
                                 .semantic
-                                .scope()
+                                .current_scope()
                                 .get(id)
-                                .map_or(false, |binding_id| {
+                                .is_some_and(|binding_id| {
                                     checker.semantic.binding(binding_id).is_global()
                                 })
                             {
@@ -216,16 +215,19 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                         }
                     }
                     if checker.enabled(Rule::MixedCaseVariableInClassScope) {
-                        if let ScopeKind::Class(ast::StmtClassDef { bases, .. }) =
-                            &checker.semantic.scope().kind
+                        if let ScopeKind::Class(ast::StmtClassDef { arguments, .. }) =
+                            &checker.semantic.current_scope().kind
                         {
                             pep8_naming::rules::mixed_case_variable_in_class_scope(
-                                checker, expr, id, bases,
+                                checker,
+                                expr,
+                                id,
+                                arguments.as_deref(),
                             );
                         }
                     }
                     if checker.enabled(Rule::MixedCaseVariableInGlobalScope) {
-                        if matches!(checker.semantic.scope().kind, ScopeKind::Module) {
+                        if matches!(checker.semantic.current_scope().kind, ScopeKind::Module) {
                             pep8_naming::rules::mixed_case_variable_in_global_scope(
                                 checker, expr, id,
                             );
@@ -238,7 +240,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                             checker.diagnostics.push(diagnostic);
                         }
                     }
-                    if let ScopeKind::Class(class_def) = checker.semantic.scope().kind {
+                    if let ScopeKind::Class(class_def) = checker.semantic.current_scope().kind {
                         if checker.enabled(Rule::BuiltinAttributeShadowing) {
                             flake8_builtins::rules::builtin_attribute_shadowing(
                                 checker, class_def, id, *range,
@@ -259,7 +261,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 pylint::rules::load_before_global_declaration(checker, id, expr);
             }
         }
-        Expr::Attribute(ast::ExprAttribute { attr, value, .. }) => {
+        Expr::Attribute(attribute) => {
             // Ex) typing.List[...]
             if checker.any_enabled(&[
                 Rule::FutureRewritableTypeAnnotation,
@@ -267,7 +269,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             ]) {
                 if let Some(replacement) = typing::to_pep585_generic(expr, &checker.semantic) {
                     if checker.enabled(Rule::FutureRewritableTypeAnnotation) {
-                        if !checker.is_stub
+                        if !checker.source_type.is_stub()
                             && checker.settings.target_version < PythonVersion::Py39
                             && checker.settings.target_version >= PythonVersion::Py37
                             && !checker.semantic.future_annotations()
@@ -280,7 +282,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                         }
                     }
                     if checker.enabled(Rule::NonPEP585Annotation) {
-                        if checker.is_stub
+                        if checker.source_type.is_stub()
                             || checker.settings.target_version >= PythonVersion::Py39
                             || (checker.settings.target_version >= PythonVersion::Py37
                                 && checker.semantic.future_annotations()
@@ -318,22 +320,26 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             if checker.enabled(Rule::PrivateMemberAccess) {
                 flake8_self::rules::private_member_access(checker, expr);
             }
-            if checker.is_stub {
-                if checker.enabled(Rule::CollectionsNamedTuple) {
-                    flake8_pyi::rules::collections_named_tuple(checker, expr);
-                }
+            if checker.enabled(Rule::CollectionsNamedTuple) {
+                flake8_pyi::rules::collections_named_tuple(checker, expr);
             }
-            pandas_vet::rules::attr(checker, attr, value, expr);
+            pandas_vet::rules::attr(checker, attribute);
         }
         Expr::Call(
             call @ ast::ExprCall {
                 func,
-                args,
-                keywords,
+                arguments:
+                    Arguments {
+                        args,
+                        keywords,
+                        range: _,
+                    },
                 range: _,
             },
         ) => {
             if checker.any_enabled(&[
+                // pylint
+                Rule::BadStringFormatCharacter,
                 // pyflakes
                 Rule::StringDotFormatInvalidFormat,
                 Rule::StringDotFormatExtraNamedArguments,
@@ -382,9 +388,8 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                                         .enabled(Rule::StringDotFormatExtraPositionalArguments)
                                     {
                                         pyflakes::rules::string_dot_format_extra_positional_arguments(
-                                                checker,
-                                                &summary, args, location,
-                                            );
+                                            checker, &summary, args, location,
+                                        );
                                     }
                                     if checker.enabled(Rule::StringDotFormatMissingArguments) {
                                         pyflakes::rules::string_dot_format_missing_argument(
@@ -397,7 +402,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                                         );
                                     }
                                     if checker.enabled(Rule::FormatLiterals) {
-                                        pyupgrade::rules::format_literals(checker, &summary, expr);
+                                        pyupgrade::rules::format_literals(checker, &summary, call);
                                     }
                                     if checker.enabled(Rule::FString) {
                                         pyupgrade::rules::f_strings(
@@ -410,6 +415,12 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                                     }
                                 }
                             }
+
+                            if checker.enabled(Rule::BadStringFormatCharacter) {
+                                pylint::rules::bad_string_format_character::call(
+                                    checker, val, location,
+                                );
+                            }
                         }
                     }
                 }
@@ -424,10 +435,10 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 pyupgrade::rules::super_call_with_parameters(checker, expr, func, args);
             }
             if checker.enabled(Rule::UnnecessaryEncodeUTF8) {
-                pyupgrade::rules::unnecessary_encode_utf8(checker, expr, func, args, keywords);
+                pyupgrade::rules::unnecessary_encode_utf8(checker, call);
             }
             if checker.enabled(Rule::RedundantOpenModes) {
-                pyupgrade::rules::redundant_open_modes(checker, expr);
+                pyupgrade::rules::redundant_open_modes(checker, call);
             }
             if checker.enabled(Rule::NativeLiterals) {
                 pyupgrade::rules::native_literals(checker, expr, func, args, keywords);
@@ -436,10 +447,10 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 pyupgrade::rules::open_alias(checker, expr, func);
             }
             if checker.enabled(Rule::ReplaceUniversalNewlines) {
-                pyupgrade::rules::replace_universal_newlines(checker, func, keywords);
+                pyupgrade::rules::replace_universal_newlines(checker, call);
             }
             if checker.enabled(Rule::ReplaceStdoutStderr) {
-                pyupgrade::rules::replace_stdout_stderr(checker, expr, func, args, keywords);
+                pyupgrade::rules::replace_stdout_stderr(checker, call);
             }
             if checker.enabled(Rule::OSErrorAlias) {
                 pyupgrade::rules::os_error_alias_call(checker, func);
@@ -459,7 +470,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_async::rules::blocking_os_call(checker, expr);
             }
             if checker.any_enabled(&[Rule::Print, Rule::PPrint]) {
-                flake8_print::rules::print_call(checker, func, keywords);
+                flake8_print::rules::print_call(checker, call);
             }
             if checker.any_enabled(&[
                 Rule::SuspiciousPickleUsage,
@@ -511,13 +522,11 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             }
             if checker.enabled(Rule::ZipWithoutExplicitStrict) {
                 if checker.settings.target_version >= PythonVersion::Py310 {
-                    flake8_bugbear::rules::zip_without_explicit_strict(
-                        checker, expr, func, args, keywords,
-                    );
+                    flake8_bugbear::rules::zip_without_explicit_strict(checker, call);
                 }
             }
             if checker.enabled(Rule::NoExplicitStacklevel) {
-                flake8_bugbear::rules::no_explicit_stacklevel(checker, func, keywords);
+                flake8_bugbear::rules::no_explicit_stacklevel(checker, call);
             }
             if checker.enabled(Rule::UnnecessaryDictKwargs) {
                 flake8_pie::rules::unnecessary_dict_kwargs(checker, expr, keywords);
@@ -526,22 +535,22 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_bandit::rules::exec_used(checker, func);
             }
             if checker.enabled(Rule::BadFilePermissions) {
-                flake8_bandit::rules::bad_file_permissions(checker, func, args, keywords);
+                flake8_bandit::rules::bad_file_permissions(checker, call);
             }
             if checker.enabled(Rule::RequestWithNoCertValidation) {
-                flake8_bandit::rules::request_with_no_cert_validation(checker, func, keywords);
+                flake8_bandit::rules::request_with_no_cert_validation(checker, call);
             }
             if checker.enabled(Rule::UnsafeYAMLLoad) {
-                flake8_bandit::rules::unsafe_yaml_load(checker, func, args, keywords);
+                flake8_bandit::rules::unsafe_yaml_load(checker, call);
             }
             if checker.enabled(Rule::SnmpInsecureVersion) {
-                flake8_bandit::rules::snmp_insecure_version(checker, func, keywords);
+                flake8_bandit::rules::snmp_insecure_version(checker, call);
             }
             if checker.enabled(Rule::SnmpWeakCryptography) {
-                flake8_bandit::rules::snmp_weak_cryptography(checker, func, args, keywords);
+                flake8_bandit::rules::snmp_weak_cryptography(checker, call);
             }
             if checker.enabled(Rule::Jinja2AutoescapeFalse) {
-                flake8_bandit::rules::jinja2_autoescape_false(checker, func, keywords);
+                flake8_bandit::rules::jinja2_autoescape_false(checker, call);
             }
             if checker.enabled(Rule::HardcodedPasswordFuncArg) {
                 flake8_bandit::rules::hardcoded_password_func_arg(checker, keywords);
@@ -550,18 +559,16 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_bandit::rules::hardcoded_sql_expression(checker, expr);
             }
             if checker.enabled(Rule::HashlibInsecureHashFunction) {
-                flake8_bandit::rules::hashlib_insecure_hash_functions(
-                    checker, func, args, keywords,
-                );
+                flake8_bandit::rules::hashlib_insecure_hash_functions(checker, call);
             }
             if checker.enabled(Rule::RequestWithoutTimeout) {
-                flake8_bandit::rules::request_without_timeout(checker, func, keywords);
+                flake8_bandit::rules::request_without_timeout(checker, call);
             }
             if checker.enabled(Rule::ParamikoCall) {
                 flake8_bandit::rules::paramiko_call(checker, func);
             }
             if checker.enabled(Rule::LoggingConfigInsecureListen) {
-                flake8_bandit::rules::logging_config_insecure_listen(checker, func, keywords);
+                flake8_bandit::rules::logging_config_insecure_listen(checker, call);
             }
             if checker.any_enabled(&[
                 Rule::SubprocessWithoutShellEqualsTrue,
@@ -572,7 +579,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 Rule::StartProcessWithPartialPath,
                 Rule::UnixCommandWildcardInjection,
             ]) {
-                flake8_bandit::rules::shell_injection(checker, func, args, keywords);
+                flake8_bandit::rules::shell_injection(checker, call);
             }
             if checker.enabled(Rule::UnnecessaryGeneratorList) {
                 flake8_comprehensions::rules::unnecessary_generator_list(
@@ -656,7 +663,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_comprehensions::rules::unnecessary_map(
                     checker,
                     expr,
-                    checker.semantic.expr_parent(),
+                    checker.semantic.current_expression_parent(),
                     func,
                     args,
                 );
@@ -666,32 +673,24 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                     checker, expr, func, args, keywords,
                 );
             }
-            if checker.enabled(Rule::BooleanPositionalValueInFunctionCall) {
-                flake8_boolean_trap::rules::check_boolean_positional_value_in_function_call(
-                    checker, args, func,
-                );
+            if checker.enabled(Rule::BooleanPositionalValueInCall) {
+                flake8_boolean_trap::rules::boolean_positional_value_in_call(checker, args, func);
             }
             if checker.enabled(Rule::Debugger) {
                 flake8_debugger::rules::debugger_call(checker, expr, func);
             }
             if checker.enabled(Rule::PandasUseOfInplaceArgument) {
-                pandas_vet::rules::inplace_argument(checker, expr, func, args, keywords);
+                pandas_vet::rules::inplace_argument(checker, call);
             }
             pandas_vet::rules::call(checker, func);
             if checker.enabled(Rule::PandasUseOfDotReadTable) {
-                pandas_vet::rules::use_of_read_table(checker, func, keywords);
+                pandas_vet::rules::use_of_read_table(checker, call);
             }
             if checker.enabled(Rule::PandasUseOfPdMerge) {
                 pandas_vet::rules::use_of_pd_merge(checker, func);
             }
             if checker.enabled(Rule::CallDatetimeWithoutTzinfo) {
-                flake8_datetimez::rules::call_datetime_without_tzinfo(
-                    checker,
-                    func,
-                    args,
-                    keywords,
-                    expr.range(),
-                );
+                flake8_datetimez::rules::call_datetime_without_tzinfo(checker, call);
             }
             if checker.enabled(Rule::CallDatetimeToday) {
                 flake8_datetimez::rules::call_datetime_today(checker, func, expr.range());
@@ -707,30 +706,13 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 );
             }
             if checker.enabled(Rule::CallDatetimeNowWithoutTzinfo) {
-                flake8_datetimez::rules::call_datetime_now_without_tzinfo(
-                    checker,
-                    func,
-                    args,
-                    keywords,
-                    expr.range(),
-                );
+                flake8_datetimez::rules::call_datetime_now_without_tzinfo(checker, call);
             }
             if checker.enabled(Rule::CallDatetimeFromtimestamp) {
-                flake8_datetimez::rules::call_datetime_fromtimestamp(
-                    checker,
-                    func,
-                    args,
-                    keywords,
-                    expr.range(),
-                );
+                flake8_datetimez::rules::call_datetime_fromtimestamp(checker, call);
             }
             if checker.enabled(Rule::CallDatetimeStrptimeWithoutZone) {
-                flake8_datetimez::rules::call_datetime_strptime_without_zone(
-                    checker,
-                    func,
-                    args,
-                    expr.range(),
-                );
+                flake8_datetimez::rules::call_datetime_strptime_without_zone(checker, call);
             }
             if checker.enabled(Rule::CallDateToday) {
                 flake8_datetimez::rules::call_date_today(checker, func, expr.range());
@@ -754,18 +736,16 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 pylint::rules::bad_str_strip_call(checker, func, args);
             }
             if checker.enabled(Rule::InvalidEnvvarDefault) {
-                pylint::rules::invalid_envvar_default(checker, func, args, keywords);
+                pylint::rules::invalid_envvar_default(checker, call);
             }
             if checker.enabled(Rule::InvalidEnvvarValue) {
-                pylint::rules::invalid_envvar_value(checker, func, args, keywords);
+                pylint::rules::invalid_envvar_value(checker, call);
             }
             if checker.enabled(Rule::NestedMinMax) {
                 pylint::rules::nested_min_max(checker, expr, func, args, keywords);
             }
             if checker.enabled(Rule::PytestPatchWithLambda) {
-                if let Some(diagnostic) =
-                    flake8_pytest_style::rules::patch_with_lambda(func, args, keywords)
-                {
+                if let Some(diagnostic) = flake8_pytest_style::rules::patch_with_lambda(call) {
                     checker.diagnostics.push(diagnostic);
                 }
             }
@@ -776,17 +756,27 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                     checker.diagnostics.push(diagnostic);
                 }
             }
+            if checker.enabled(Rule::PytestUnittestRaisesAssertion) {
+                if let Some(diagnostic) =
+                    flake8_pytest_style::rules::unittest_raises_assertion(checker, call)
+                {
+                    checker.diagnostics.push(diagnostic);
+                }
+            }
             if checker.enabled(Rule::SubprocessPopenPreexecFn) {
-                pylint::rules::subprocess_popen_preexec_fn(checker, func, keywords);
+                pylint::rules::subprocess_popen_preexec_fn(checker, call);
+            }
+            if checker.enabled(Rule::SubprocessRunWithoutCheck) {
+                pylint::rules::subprocess_run_without_check(checker, call);
             }
             if checker.any_enabled(&[
                 Rule::PytestRaisesWithoutException,
                 Rule::PytestRaisesTooBroad,
             ]) {
-                flake8_pytest_style::rules::raises_call(checker, func, args, keywords);
+                flake8_pytest_style::rules::raises_call(checker, call);
             }
             if checker.enabled(Rule::PytestFailWithoutMessage) {
-                flake8_pytest_style::rules::fail_call(checker, func, args, keywords);
+                flake8_pytest_style::rules::fail_call(checker, call);
             }
             if checker.enabled(Rule::PairwiseOverZipped) {
                 if checker.settings.target_version >= PythonVersion::Py310 {
@@ -857,7 +847,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_use_pathlib::rules::path_constructor_current_directory(checker, expr, func);
             }
             if checker.enabled(Rule::OsSepSplit) {
-                flake8_use_pathlib::rules::os_sep_split(checker, func, args, keywords);
+                flake8_use_pathlib::rules::os_sep_split(checker, call);
             }
             if checker.enabled(Rule::NumpyLegacyRandom) {
                 numpy::rules::legacy_random(checker, func);
@@ -872,17 +862,20 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 Rule::LoggingExcInfo,
                 Rule::LoggingRedundantExcInfo,
             ]) {
-                flake8_logging_format::rules::logging_call(checker, func, args, keywords);
+                flake8_logging_format::rules::logging_call(checker, call);
             }
             if checker.any_enabled(&[Rule::LoggingTooFewArgs, Rule::LoggingTooManyArgs]) {
-                pylint::rules::logging_call(checker, func, args, keywords);
+                pylint::rules::logging_call(checker, call);
             }
             if checker.enabled(Rule::DjangoLocalsInRenderFunction) {
-                flake8_django::rules::locals_in_render_function(checker, func, args, keywords);
+                flake8_django::rules::locals_in_render_function(checker, call);
             }
-            if checker.is_stub && checker.enabled(Rule::UnsupportedMethodCallOnAll) {
+            if checker.enabled(Rule::UnsupportedMethodCallOnAll) {
                 flake8_pyi::rules::unsupported_method_call_on_all(checker, func);
             }
+            if checker.enabled(Rule::QuadraticListSummation) {
+                ruff::rules::quadratic_list_summation(checker, call);
+            }
         }
         Expr::Dict(ast::ExprDict {
             keys,
@@ -931,7 +924,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 pylint::rules::await_outside_async(checker, expr);
             }
         }
-        Expr::JoinedStr(ast::ExprJoinedStr { values, range: _ }) => {
+        Expr::FString(ast::ExprFString { values, .. }) => {
             if checker.enabled(Rule::FStringMissingPlaceholders) {
                 pyflakes::rules::f_string_missing_placeholders(expr, values, checker);
             }
@@ -958,7 +951,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             range: _,
         }) => {
             if let Expr::Constant(ast::ExprConstant {
-                value: Constant::Str(value),
+                value: Constant::Str(ast::StringConstant { value, .. }),
                 ..
             }) = left.as_ref()
             {
@@ -1045,6 +1038,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                         checker.locator,
                     );
                 }
+                if checker.enabled(Rule::BadStringFormatCharacter) {
+                    pylint::rules::bad_string_format_character::percent(checker, expr);
+                }
                 if checker.enabled(Rule::BadStringFormatType) {
                     pylint::rules::bad_string_format_type(checker, expr, right);
                 }
@@ -1076,7 +1072,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
         }) => {
             // Ex) `str | None`
             if checker.enabled(Rule::FutureRequiredTypeAnnotation) {
-                if !checker.is_stub
+                if !checker.source_type.is_stub()
                     && checker.settings.target_version < PythonVersion::Py310
                     && !checker.semantic.future_annotations()
                     && checker.semantic.in_annotation()
@@ -1088,44 +1084,35 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                     );
                 }
             }
-            if checker.is_stub {
+
+            // Avoid duplicate checks if the parent is a union, since these rules already
+            // traverse nested unions.
+            if !checker.semantic.in_nested_union() {
                 if checker.enabled(Rule::DuplicateUnionMember)
-                        && checker.semantic.in_type_definition()
-                        // Avoid duplicate checks if the parent is an `|`
-                        && !matches!(
-                            checker.semantic.expr_parent(),
-                            Some(Expr::BinOp(ast::ExprBinOp { op: Operator::BitOr, ..}))
-                        )
+                    && checker.semantic.in_type_definition()
                 {
                     flake8_pyi::rules::duplicate_union_member(checker, expr);
                 }
-                if checker.enabled(Rule::UnnecessaryLiteralUnion)
-                        // Avoid duplicate checks if the parent is an `|`
-                        && !matches!(
-                            checker.semantic.expr_parent(),
-                            Some(Expr::BinOp(ast::ExprBinOp { op: Operator::BitOr, ..}))
-                        )
-                {
+                if checker.enabled(Rule::UnnecessaryLiteralUnion) {
                     flake8_pyi::rules::unnecessary_literal_union(checker, expr);
                 }
+                if checker.enabled(Rule::RedundantLiteralUnion) {
+                    flake8_pyi::rules::redundant_literal_union(checker, expr);
+                }
+                if checker.enabled(Rule::UnnecessaryTypeUnion) {
+                    flake8_pyi::rules::unnecessary_type_union(checker, expr);
+                }
             }
         }
-        Expr::UnaryOp(ast::ExprUnaryOp {
-            op,
-            operand,
-            range: _,
-        }) => {
-            let check_not_in = checker.enabled(Rule::NotInTest);
-            let check_not_is = checker.enabled(Rule::NotIsTest);
-            if check_not_in || check_not_is {
-                pycodestyle::rules::not_tests(
-                    checker,
-                    expr,
-                    *op,
-                    operand,
-                    check_not_in,
-                    check_not_is,
-                );
+        Expr::UnaryOp(
+            unary_op @ ast::ExprUnaryOp {
+                op,
+                operand,
+                range: _,
+            },
+        ) => {
+            if checker.any_enabled(&[Rule::NotInTest, Rule::NotIsTest]) {
+                pycodestyle::rules::not_tests(checker, unary_op);
             }
             if checker.enabled(Rule::UnaryPrefixIncrementDecrement) {
                 flake8_bugbear::rules::unary_prefix_increment_decrement(
@@ -1142,30 +1129,22 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_simplify::rules::double_negation(checker, expr, *op, operand);
             }
         }
-        Expr::Compare(ast::ExprCompare {
-            left,
-            ops,
-            comparators,
-            range: _,
-        }) => {
-            let check_none_comparisons = checker.enabled(Rule::NoneComparison);
-            let check_true_false_comparisons = checker.enabled(Rule::TrueFalseComparison);
-            if check_none_comparisons || check_true_false_comparisons {
-                pycodestyle::rules::literal_comparisons(
-                    checker,
-                    expr,
-                    left,
-                    ops,
-                    comparators,
-                    check_none_comparisons,
-                    check_true_false_comparisons,
-                );
+        Expr::Compare(
+            compare @ ast::ExprCompare {
+                left,
+                ops,
+                comparators,
+                range: _,
+            },
+        ) => {
+            if checker.any_enabled(&[Rule::NoneComparison, Rule::TrueFalseComparison]) {
+                pycodestyle::rules::literal_comparisons(checker, compare);
             }
             if checker.enabled(Rule::IsLiteral) {
                 pyflakes::rules::invalid_literal_comparison(checker, left, ops, comparators, expr);
             }
             if checker.enabled(Rule::TypeComparison) {
-                pycodestyle::rules::type_comparison(checker, expr, ops, comparators);
+                pycodestyle::rules::type_comparison(checker, compare);
             }
             if checker.any_enabled(&[
                 Rule::SysVersionCmpStr3,
@@ -1216,7 +1195,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             kind: _,
             range: _,
         }) => {
-            if checker.is_stub && checker.enabled(Rule::NumericLiteralTooLong) {
+            if checker.source_type.is_stub() && checker.enabled(Rule::NumericLiteralTooLong) {
                 flake8_pyi::rules::numeric_literal_too_long(checker, expr);
             }
         }
@@ -1225,7 +1204,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             kind: _,
             range: _,
         }) => {
-            if checker.is_stub && checker.enabled(Rule::StringOrBytesTooLong) {
+            if checker.source_type.is_stub() && checker.enabled(Rule::StringOrBytesTooLong) {
                 flake8_pyi::rules::string_or_bytes_too_long(checker, expr);
             }
         }
@@ -1242,18 +1221,12 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 }
             }
             if checker.enabled(Rule::HardcodedTempFile) {
-                if let Some(diagnostic) = flake8_bandit::rules::hardcoded_tmp_directory(
-                    expr,
-                    value,
-                    &checker.settings.flake8_bandit.hardcoded_tmp_directory,
-                ) {
-                    checker.diagnostics.push(diagnostic);
-                }
+                flake8_bandit::rules::hardcoded_tmp_directory(checker, expr, value);
             }
             if checker.enabled(Rule::UnicodeKindPrefix) {
                 pyupgrade::rules::unicode_kind_prefix(checker, expr, kind.as_deref());
             }
-            if checker.is_stub {
+            if checker.source_type.is_stub() {
                 if checker.enabled(Rule::StringOrBytesTooLong) {
                     flake8_pyi::rules::string_or_bytes_too_long(checker, expr);
                 }
@@ -1261,7 +1234,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
         }
         Expr::Lambda(
             lambda @ ast::ExprLambda {
-                args: _,
+                parameters: _,
                 body: _,
                 range: _,
             },

crates/ruff/src/checkers/ast/analyze/mod.rs

@@ -1,5 +1,3 @@
-pub(super) use argument::argument;
-pub(super) use arguments::arguments;
 pub(super) use bindings::bindings;
 pub(super) use comprehension::comprehension;
 pub(super) use deferred_for_loops::deferred_for_loops;
@@ -8,12 +6,12 @@ pub(super) use definitions::definitions;
 pub(super) use except_handler::except_handler;
 pub(super) use expression::expression;
 pub(super) use module::module;
+pub(super) use parameter::parameter;
+pub(super) use parameters::parameters;
 pub(super) use statement::statement;
 pub(super) use suite::suite;
 pub(super) use unresolved_references::unresolved_references;
 
-mod argument;
-mod arguments;
 mod bindings;
 mod comprehension;
 mod deferred_for_loops;
@@ -22,6 +20,8 @@ mod definitions;
 mod except_handler;
 mod expression;
 mod module;
+mod parameter;
+mod parameters;
 mod statement;
 mod suite;
 mod unresolved_references;

crates/ruff/src/checkers/ast/analyze/parameter.rs

@@ -1,27 +1,28 @@
-use ruff_python_ast::{Arg, Ranged};
+use ruff_python_ast::{Parameter, Ranged};
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
 use crate::rules::{flake8_builtins, pep8_naming, pycodestyle};
 
-/// Run lint rules over an [`Arg`] syntax node.
-pub(crate) fn argument(arg: &Arg, checker: &mut Checker) {
+/// Run lint rules over a [`Parameter`] syntax node.
+pub(crate) fn parameter(parameter: &Parameter, checker: &mut Checker) {
     if checker.enabled(Rule::AmbiguousVariableName) {
-        if let Some(diagnostic) = pycodestyle::rules::ambiguous_variable_name(&arg.arg, arg.range())
+        if let Some(diagnostic) =
+            pycodestyle::rules::ambiguous_variable_name(&parameter.name, parameter.range())
         {
             checker.diagnostics.push(diagnostic);
         }
     }
     if checker.enabled(Rule::InvalidArgumentName) {
         if let Some(diagnostic) = pep8_naming::rules::invalid_argument_name(
-            &arg.arg,
-            arg,
+            &parameter.name,
+            parameter,
             &checker.settings.pep8_naming.ignore_names,
         ) {
             checker.diagnostics.push(diagnostic);
         }
     }
     if checker.enabled(Rule::BuiltinArgumentShadowing) {
-        flake8_builtins::rules::builtin_argument_shadowing(checker, arg);
+        flake8_builtins::rules::builtin_argument_shadowing(checker, parameter);
     }
 }

crates/ruff/src/checkers/ast/analyze/parameters.rs

@@ -1,26 +1,23 @@
-use ruff_python_ast::Arguments;
+use ruff_python_ast::Parameters;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
 use crate::rules::{flake8_bugbear, flake8_pyi, ruff};
 
-/// Run lint rules over a [`Arguments`] syntax node.
-pub(crate) fn arguments(arguments: &Arguments, checker: &mut Checker) {
-    if checker.enabled(Rule::MutableArgumentDefault) {
-        flake8_bugbear::rules::mutable_argument_default(checker, arguments);
-    }
+/// Run lint rules over a [`Parameters`] syntax node.
+pub(crate) fn parameters(parameters: &Parameters, checker: &mut Checker) {
     if checker.enabled(Rule::FunctionCallInDefaultArgument) {
-        flake8_bugbear::rules::function_call_in_argument_default(checker, arguments);
+        flake8_bugbear::rules::function_call_in_argument_default(checker, parameters);
     }
     if checker.settings.rules.enabled(Rule::ImplicitOptional) {
-        ruff::rules::implicit_optional(checker, arguments);
+        ruff::rules::implicit_optional(checker, parameters);
     }
-    if checker.is_stub {
+    if checker.source_type.is_stub() {
         if checker.enabled(Rule::TypedArgumentDefaultInStub) {
-            flake8_pyi::rules::typed_argument_simple_defaults(checker, arguments);
+            flake8_pyi::rules::typed_argument_simple_defaults(checker, parameters);
         }
         if checker.enabled(Rule::ArgumentDefaultInStub) {
-            flake8_pyi::rules::argument_simple_defaults(checker, arguments);
+            flake8_pyi::rules::argument_simple_defaults(checker, parameters);
         }
     }
 }

crates/ruff/src/checkers/ast/analyze/statement.rs

@@ -53,7 +53,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::BreakOutsideLoop) {
                 if let Some(diagnostic) = pyflakes::rules::break_outside_loop(
                     stmt,
-                    &mut checker.semantic.parents().skip(1),
+                    &mut checker.semantic.current_statements().skip(1),
                 ) {
                     checker.diagnostics.push(diagnostic);
                 }
@@ -63,28 +63,24 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::ContinueOutsideLoop) {
                 if let Some(diagnostic) = pyflakes::rules::continue_outside_loop(
                     stmt,
-                    &mut checker.semantic.parents().skip(1),
+                    &mut checker.semantic.current_statements().skip(1),
                 ) {
                     checker.diagnostics.push(diagnostic);
                 }
             }
         }
-        Stmt::FunctionDef(ast::StmtFunctionDef {
-            name,
-            decorator_list,
-            returns,
-            args,
-            body,
-            ..
-        })
-        | Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
-            name,
-            decorator_list,
-            returns,
-            args,
-            body,
-            ..
-        }) => {
+        Stmt::FunctionDef(
+            function_def @ ast::StmtFunctionDef {
+                is_async,
+                name,
+                decorator_list,
+                returns,
+                parameters,
+                body,
+                type_params,
+                range: _,
+            },
+        ) => {
             if checker.enabled(Rule::DjangoNonLeadingReceiverDecorator) {
                 flake8_django::rules::non_leading_receiver_decorator(checker, decorator_list);
             }
@@ -111,10 +107,10 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 if let Some(diagnostic) =
                     pep8_naming::rules::invalid_first_argument_name_for_class_method(
                         checker,
-                        checker.semantic.scope(),
+                        checker.semantic.current_scope(),
                         name,
                         decorator_list,
-                        args,
+                        parameters,
                     )
                 {
                     checker.diagnostics.push(diagnostic);
@@ -123,15 +119,15 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::InvalidFirstArgumentNameForMethod) {
                 if let Some(diagnostic) = pep8_naming::rules::invalid_first_argument_name_for_method(
                     checker,
-                    checker.semantic.scope(),
+                    checker.semantic.current_scope(),
                     name,
                     decorator_list,
-                    args,
+                    parameters,
                 ) {
                     checker.diagnostics.push(diagnostic);
                 }
             }
-            if checker.is_stub {
+            if checker.source_type.is_stub() {
                 if checker.enabled(Rule::PassStatementStubBody) {
                     flake8_pyi::rules::pass_statement_stub_body(checker, body);
                 }
@@ -141,41 +137,52 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 if checker.enabled(Rule::StubBodyMultipleStatements) {
                     flake8_pyi::rules::stub_body_multiple_statements(checker, stmt, body);
                 }
-                if checker.enabled(Rule::AnyEqNeAnnotation) {
-                    flake8_pyi::rules::any_eq_ne_annotation(checker, name, args);
-                }
-                if checker.enabled(Rule::NonSelfReturnType) {
-                    flake8_pyi::rules::non_self_return_type(
-                        checker,
-                        stmt,
-                        name,
-                        decorator_list,
-                        returns.as_ref().map(AsRef::as_ref),
-                        args,
-                        stmt.is_async_function_def_stmt(),
-                    );
-                }
+            }
+            if checker.enabled(Rule::AnyEqNeAnnotation) {
+                flake8_pyi::rules::any_eq_ne_annotation(checker, name, parameters);
+            }
+            if checker.enabled(Rule::NonSelfReturnType) {
+                flake8_pyi::rules::non_self_return_type(
+                    checker,
+                    stmt,
+                    *is_async,
+                    name,
+                    decorator_list,
+                    returns.as_ref().map(AsRef::as_ref),
+                    parameters,
+                );
+            }
+            if checker.enabled(Rule::CustomTypeVarReturnType) {
+                flake8_pyi::rules::custom_type_var_return_type(
+                    checker,
+                    name,
+                    decorator_list,
+                    returns.as_ref().map(AsRef::as_ref),
+                    parameters,
+                    type_params.as_ref(),
+                );
+            }
+            if checker.source_type.is_stub() {
                 if checker.enabled(Rule::StrOrReprDefinedInStub) {
                     flake8_pyi::rules::str_or_repr_defined_in_stub(checker, stmt);
                 }
+            }
+            if checker.source_type.is_stub()
+                || checker.settings.target_version >= PythonVersion::Py311
+            {
                 if checker.enabled(Rule::NoReturnArgumentAnnotationInStub) {
-                    flake8_pyi::rules::no_return_argument_annotation(checker, args);
-                }
-                if checker.enabled(Rule::BadExitAnnotation) {
-                    flake8_pyi::rules::bad_exit_annotation(
-                        checker,
-                        stmt.is_async_function_def_stmt(),
-                        name,
-                        args,
-                    );
-                }
-                if checker.enabled(Rule::RedundantNumericUnion) {
-                    flake8_pyi::rules::redundant_numeric_union(checker, args);
+                    flake8_pyi::rules::no_return_argument_annotation(checker, parameters);
                 }
             }
+            if checker.enabled(Rule::BadExitAnnotation) {
+                flake8_pyi::rules::bad_exit_annotation(checker, *is_async, name, parameters);
+            }
+            if checker.enabled(Rule::RedundantNumericUnion) {
+                flake8_pyi::rules::redundant_numeric_union(checker, parameters);
+            }
             if checker.enabled(Rule::DunderFunctionName) {
                 if let Some(diagnostic) = pep8_naming::rules::dunder_function_name(
-                    checker.semantic.scope(),
+                    checker.semantic.current_scope(),
                     stmt,
                     name,
                     &checker.settings.pep8_naming.ignore_names,
@@ -199,6 +206,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::CachedInstanceMethod) {
                 flake8_bugbear::rules::cached_instance_method(checker, decorator_list);
             }
+            if checker.enabled(Rule::MutableArgumentDefault) {
+                flake8_bugbear::rules::mutable_argument_default(checker, function_def);
+            }
             if checker.any_enabled(&[
                 Rule::UnnecessaryReturnNone,
                 Rule::ImplicitReturnValue,
@@ -230,13 +240,13 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 }
             }
             if checker.enabled(Rule::HardcodedPasswordDefault) {
-                flake8_bandit::rules::hardcoded_password_default(checker, args);
+                flake8_bandit::rules::hardcoded_password_default(checker, parameters);
             }
             if checker.enabled(Rule::PropertyWithParameters) {
-                pylint::rules::property_with_parameters(checker, stmt, decorator_list, args);
+                pylint::rules::property_with_parameters(checker, stmt, decorator_list, parameters);
             }
             if checker.enabled(Rule::TooManyArguments) {
-                pylint::rules::too_many_arguments(checker, args, stmt);
+                pylint::rules::too_many_arguments(checker, parameters, stmt);
             }
             if checker.enabled(Rule::TooManyReturnStatements) {
                 if let Some(diagnostic) = pylint::rules::too_many_return_statements(
@@ -282,7 +292,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     checker,
                     stmt,
                     name,
-                    args,
+                    parameters,
                     decorator_list,
                     body,
                 );
@@ -290,6 +300,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.any_enabled(&[
                 Rule::PytestParametrizeNamesWrongType,
                 Rule::PytestParametrizeValuesWrongType,
+                Rule::PytestDuplicateParametrizeTestCases,
             ]) {
                 flake8_pytest_style::rules::parametrize(checker, decorator_list);
             }
@@ -299,20 +310,20 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             ]) {
                 flake8_pytest_style::rules::marks(checker, decorator_list);
             }
-            if checker.enabled(Rule::BooleanPositionalArgInFunctionDefinition) {
-                flake8_boolean_trap::rules::check_positional_boolean_in_def(
+            if checker.enabled(Rule::BooleanTypeHintPositionalArgument) {
+                flake8_boolean_trap::rules::boolean_type_hint_positional_argument(
                     checker,
                     name,
                     decorator_list,
-                    args,
+                    parameters,
                 );
             }
-            if checker.enabled(Rule::BooleanDefaultValueInFunctionDefinition) {
-                flake8_boolean_trap::rules::check_boolean_default_value_in_function_definition(
+            if checker.enabled(Rule::BooleanDefaultValuePositionalArgument) {
+                flake8_boolean_trap::rules::boolean_default_value_positional_argument(
                     checker,
                     name,
                     decorator_list,
-                    args,
+                    parameters,
                 );
             }
             if checker.enabled(Rule::UnexpectedSpecialMethodSignature) {
@@ -321,7 +332,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     stmt,
                     name,
                     decorator_list,
-                    args,
+                    parameters,
                 );
             }
             if checker.enabled(Rule::FStringDocstring) {
@@ -330,7 +341,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::YieldInForLoop) {
                 pyupgrade::rules::yield_in_for_loop(checker, stmt);
             }
-            if let ScopeKind::Class(class_def) = checker.semantic.scope().kind {
+            if let ScopeKind::Class(class_def) = checker.semantic.current_scope().kind {
                 if checker.enabled(Rule::BuiltinAttributeShadowing) {
                     flake8_builtins::rules::builtin_method_shadowing(
                         checker,
@@ -363,8 +374,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
         Stmt::ClassDef(
             class_def @ ast::StmtClassDef {
                 name,
-                bases,
-                keywords,
+                arguments,
                 type_params: _,
                 decorator_list,
                 body,
@@ -375,23 +385,29 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 flake8_django::rules::nullable_model_string_field(checker, body);
             }
             if checker.enabled(Rule::DjangoExcludeWithModelForm) {
-                if let Some(diagnostic) =
-                    flake8_django::rules::exclude_with_model_form(checker, bases, body)
-                {
+                if let Some(diagnostic) = flake8_django::rules::exclude_with_model_form(
+                    checker,
+                    arguments.as_deref(),
+                    body,
+                ) {
                     checker.diagnostics.push(diagnostic);
                 }
             }
             if checker.enabled(Rule::DjangoAllWithModelForm) {
                 if let Some(diagnostic) =
-                    flake8_django::rules::all_with_model_form(checker, bases, body)
+                    flake8_django::rules::all_with_model_form(checker, arguments.as_deref(), body)
                 {
                     checker.diagnostics.push(diagnostic);
                 }
             }
             if checker.enabled(Rule::DjangoUnorderedBodyContentInModel) {
-                flake8_django::rules::unordered_body_content_in_model(checker, bases, body);
+                flake8_django::rules::unordered_body_content_in_model(
+                    checker,
+                    arguments.as_deref(),
+                    body,
+                );
             }
-            if !checker.is_stub {
+            if !checker.source_type.is_stub() {
                 if checker.enabled(Rule::DjangoModelWithoutDunderStr) {
                     flake8_django::rules::model_without_dunder_str(checker, class_def);
                 }
@@ -425,33 +441,37 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::ErrorSuffixOnExceptionName) {
                 if let Some(diagnostic) = pep8_naming::rules::error_suffix_on_exception_name(
                     stmt,
-                    bases,
+                    arguments.as_deref(),
                     name,
                     &checker.settings.pep8_naming.ignore_names,
                 ) {
                     checker.diagnostics.push(diagnostic);
                 }
             }
-            if !checker.is_stub {
+            if !checker.source_type.is_stub() {
                 if checker.any_enabled(&[
                     Rule::AbstractBaseClassWithoutAbstractMethod,
                     Rule::EmptyMethodWithoutAbstractDecorator,
                 ]) {
                     flake8_bugbear::rules::abstract_base_class(
-                        checker, stmt, name, bases, keywords, body,
+                        checker,
+                        stmt,
+                        name,
+                        arguments.as_deref(),
+                        body,
                     );
                 }
             }
-            if checker.is_stub {
+            if checker.source_type.is_stub() {
                 if checker.enabled(Rule::PassStatementStubBody) {
                     flake8_pyi::rules::pass_statement_stub_body(checker, body);
                 }
                 if checker.enabled(Rule::PassInClassBody) {
                     flake8_pyi::rules::pass_in_class_body(checker, stmt, body);
                 }
-                if checker.enabled(Rule::EllipsisInNonEmptyClassBody) {
-                    flake8_pyi::rules::ellipsis_in_non_empty_class_body(checker, stmt, body);
-                }
+            }
+            if checker.enabled(Rule::EllipsisInNonEmptyClassBody) {
+                flake8_pyi::rules::ellipsis_in_non_empty_class_body(checker, stmt, body);
             }
             if checker.enabled(Rule::PytestIncorrectMarkParenthesesStyle) {
                 flake8_pytest_style::rules::marks(checker, decorator_list);
@@ -478,7 +498,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 flake8_builtins::rules::builtin_variable_shadowing(checker, name, name.range());
             }
             if checker.enabled(Rule::DuplicateBases) {
-                pylint::rules::duplicate_bases(checker, name, bases);
+                pylint::rules::duplicate_bases(checker, name, arguments.as_deref());
             }
             if checker.enabled(Rule::NoSlotsInStrSubclass) {
                 flake8_slots::rules::no_slots_in_str_subclass(checker, stmt, class_def);
@@ -492,17 +512,16 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::SingleStringSlots) {
                 pylint::rules::single_string_slots(checker, class_def);
             }
+            if checker.enabled(Rule::BadDunderMethodName) {
+                pylint::rules::bad_dunder_method_name(checker, body);
+            }
         }
         Stmt::Import(ast::StmtImport { names, range: _ }) => {
             if checker.enabled(Rule::MultipleImportsOnOneLine) {
                 pycodestyle::rules::multiple_imports_on_one_line(checker, stmt, names);
             }
             if checker.enabled(Rule::ModuleImportNotAtTopOfFile) {
-                pycodestyle::rules::module_import_not_at_top_of_file(
-                    checker,
-                    stmt,
-                    checker.locator,
-                );
+                pycodestyle::rules::module_import_not_at_top_of_file(checker, stmt);
             }
             if checker.enabled(Rule::GlobalStatement) {
                 for name in names {
@@ -538,13 +557,30 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     }
                 }
                 if checker.enabled(Rule::BannedApi) {
-                    flake8_tidy_imports::rules::name_or_parent_is_banned(
+                    flake8_tidy_imports::rules::banned_api(
                         checker,
-                        &alias.name,
-                        alias,
+                        &flake8_tidy_imports::matchers::NameMatchPolicy::MatchNameOrParent(
+                            flake8_tidy_imports::matchers::MatchNameOrParent {
+                                module: &alias.name,
+                            },
+                        ),
+                        &alias,
                     );
                 }
-                if !checker.is_stub {
+
+                if checker.enabled(Rule::BannedModuleLevelImports) {
+                    flake8_tidy_imports::rules::banned_module_level_imports(
+                        checker,
+                        &flake8_tidy_imports::matchers::NameMatchPolicy::MatchNameOrParent(
+                            flake8_tidy_imports::matchers::MatchNameOrParent {
+                                module: &alias.name,
+                            },
+                        ),
+                        &alias,
+                    );
+                }
+
+                if !checker.source_type.is_stub() {
                     if checker.enabled(Rule::UselessImportAlias) {
                         pylint::rules::useless_import_alias(checker, alias);
                     }
@@ -658,11 +694,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             let module = module.as_deref();
             let level = level.map(|level| level.to_u32());
             if checker.enabled(Rule::ModuleImportNotAtTopOfFile) {
-                pycodestyle::rules::module_import_not_at_top_of_file(
-                    checker,
-                    stmt,
-                    checker.locator,
-                );
+                pycodestyle::rules::module_import_not_at_top_of_file(checker, stmt);
             }
             if checker.enabled(Rule::GlobalStatement) {
                 for name in names {
@@ -698,16 +730,56 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 if let Some(module) =
                     helpers::resolve_imported_module_path(level, module, checker.module_path)
                 {
-                    flake8_tidy_imports::rules::name_or_parent_is_banned(checker, &module, stmt);
+                    flake8_tidy_imports::rules::banned_api(
+                        checker,
+                        &flake8_tidy_imports::matchers::NameMatchPolicy::MatchNameOrParent(
+                            flake8_tidy_imports::matchers::MatchNameOrParent { module: &module },
+                        ),
+                        &stmt,
+                    );
 
                     for alias in names {
                         if &alias.name == "*" {
                             continue;
                         }
-                        flake8_tidy_imports::rules::name_is_banned(
+                        flake8_tidy_imports::rules::banned_api(
                             checker,
-                            format!("{module}.{}", alias.name),
-                            alias,
+                            &flake8_tidy_imports::matchers::NameMatchPolicy::MatchName(
+                                flake8_tidy_imports::matchers::MatchName {
+                                    module: &module,
+                                    member: &alias.name,
+                                },
+                            ),
+                            &alias,
+                        );
+                    }
+                }
+            }
+            if checker.enabled(Rule::BannedModuleLevelImports) {
+                if let Some(module) =
+                    helpers::resolve_imported_module_path(level, module, checker.module_path)
+                {
+                    flake8_tidy_imports::rules::banned_module_level_imports(
+                        checker,
+                        &flake8_tidy_imports::matchers::NameMatchPolicy::MatchNameOrParent(
+                            flake8_tidy_imports::matchers::MatchNameOrParent { module: &module },
+                        ),
+                        &stmt,
+                    );
+
+                    for alias in names {
+                        if &alias.name == "*" {
+                            continue;
+                        }
+                        flake8_tidy_imports::rules::banned_module_level_imports(
+                            checker,
+                            &flake8_tidy_imports::matchers::NameMatchPolicy::MatchName(
+                                flake8_tidy_imports::matchers::MatchName {
+                                    module: &module,
+                                    member: &alias.name,
+                                },
+                            ),
+                            &alias,
                         );
                     }
                 }
@@ -719,7 +791,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     checker.diagnostics.push(diagnostic);
                 }
             }
-            if checker.is_stub {
+            if checker.source_type.is_stub() {
                 if checker.enabled(Rule::FutureAnnotationsInStub) {
                     flake8_pyi::rules::from_future_import(checker, import_from);
                 }
@@ -739,7 +811,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     }
                 } else if &alias.name == "*" {
                     if checker.enabled(Rule::UndefinedLocalWithNestedImportStarUsage) {
-                        if !matches!(checker.semantic.scope().kind, ScopeKind::Module) {
+                        if !matches!(checker.semantic.current_scope().kind, ScopeKind::Module) {
                             checker.diagnostics.push(Diagnostic::new(
                                 pyflakes::rules::UndefinedLocalWithNestedImportStarUsage {
                                     name: helpers::format_import_from(level, module),
@@ -864,7 +936,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                             checker.diagnostics.push(diagnostic);
                         }
                     }
-                    if !checker.is_stub {
+                    if !checker.source_type.is_stub() {
                         if checker.enabled(Rule::UselessImportAlias) {
                             pylint::rules::useless_import_alias(checker, alias);
                         }
@@ -955,7 +1027,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 flake8_simplify::rules::nested_if_statements(
                     checker,
                     if_,
-                    checker.semantic.stmt_parent(),
+                    checker.semantic.current_statement_parent(),
                 );
             }
             if checker.enabled(Rule::IfWithSameArms) {
@@ -977,7 +1049,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 tryceratops::rules::type_check_without_type_error(
                     checker,
                     if_,
-                    checker.semantic.stmt_parent(),
+                    checker.semantic.current_statement_parent(),
                 );
             }
             if checker.enabled(Rule::OutdatedVersionBlock) {
@@ -988,7 +1060,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     checker.diagnostics.push(diagnostic);
                 }
             }
-            if checker.is_stub {
+            if checker.source_type.is_stub() {
                 if checker.any_enabled(&[
                     Rule::UnrecognizedVersionInfoCheck,
                     Rule::PatchVersionComparison,
@@ -1070,8 +1142,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 pygrep_hooks::rules::non_existent_mock_method(checker, test);
             }
         }
-        Stmt::With(ast::StmtWith { items, body, .. })
-        | Stmt::AsyncWith(ast::StmtAsyncWith { items, body, .. }) => {
+        Stmt::With(with_ @ ast::StmtWith { items, body, .. }) => {
             if checker.enabled(Rule::AssertRaisesException) {
                 flake8_bugbear::rules::assert_raises_exception(checker, items);
             }
@@ -1081,9 +1152,8 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::MultipleWithStatements) {
                 flake8_simplify::rules::multiple_with_statements(
                     checker,
-                    stmt,
-                    body,
-                    checker.semantic.stmt_parent(),
+                    with_,
+                    checker.semantic.current_statement_parent(),
                 );
             }
             if checker.enabled(Rule::RedefinedLoopName) {
@@ -1107,13 +1177,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             iter,
             orelse,
             ..
-        })
-        | Stmt::AsyncFor(ast::StmtAsyncFor {
-            target,
-            body,
-            iter,
-            orelse,
-            ..
         }) => {
             if checker.any_enabled(&[Rule::UnusedLoopControlVariable, Rule::IncorrectDictIterator])
             {
@@ -1163,14 +1226,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             handlers,
             orelse,
             finalbody,
-            range: _,
-        })
-        | Stmt::TryStar(ast::StmtTryStar {
-            body,
-            handlers,
-            orelse,
-            finalbody,
-            range: _,
+            ..
         }) => {
             if checker.enabled(Rule::JumpStatementInFinally) {
                 flake8_bugbear::rules::jump_statement_in_finally(checker, finalbody);
@@ -1300,7 +1356,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.settings.rules.enabled(Rule::TypeBivariance) {
                 pylint::rules::type_bivariance(checker, value);
             }
-            if checker.is_stub {
+            if checker.source_type.is_stub() {
                 if checker.any_enabled(&[
                     Rule::UnprefixedTypeParam,
                     Rule::AssignmentDefaultInStub,
@@ -1311,8 +1367,8 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     // Ignore assignments in function bodies; those are covered by other rules.
                     if !checker
                         .semantic
-                        .scopes()
-                        .any(|scope| scope.kind.is_any_function())
+                        .current_scopes()
+                        .any(|scope| scope.kind.is_function())
                     {
                         if checker.enabled(Rule::UnprefixedTypeParam) {
                             flake8_pyi::rules::prefix_type_params(checker, value, targets);
@@ -1337,12 +1393,14 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 }
             }
         }
-        Stmt::AnnAssign(ast::StmtAnnAssign {
-            target,
-            value,
-            annotation,
-            ..
-        }) => {
+        Stmt::AnnAssign(
+            assign_stmt @ ast::StmtAnnAssign {
+                target,
+                value,
+                annotation,
+                ..
+            },
+        ) => {
             if let Some(value) = value {
                 if checker.enabled(Rule::LambdaAssignment) {
                     pycodestyle::rules::lambda_assignment(
@@ -1365,14 +1423,17 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     stmt,
                 );
             }
-            if checker.is_stub {
+            if checker.enabled(Rule::NonPEP695TypeAlias) {
+                pyupgrade::rules::non_pep695_type_alias(checker, assign_stmt);
+            }
+            if checker.source_type.is_stub() {
                 if let Some(value) = value {
                     if checker.enabled(Rule::AssignmentDefaultInStub) {
                         // Ignore assignments in function bodies; those are covered by other rules.
                         if !checker
                             .semantic
-                            .scopes()
-                            .any(|scope| scope.kind.is_any_function())
+                            .current_scopes()
+                            .any(|scope| scope.kind.is_function())
                         {
                             flake8_pyi::rules::annotated_assignment_default_in_stub(
                                 checker, target, value, annotation,
@@ -1386,13 +1447,13 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                         );
                     }
                 }
-                if checker.semantic.match_typing_expr(annotation, "TypeAlias") {
-                    if checker.enabled(Rule::SnakeCaseTypeAlias) {
-                        flake8_pyi::rules::snake_case_type_alias(checker, target);
-                    }
-                    if checker.enabled(Rule::TSuffixedTypeAlias) {
-                        flake8_pyi::rules::t_suffixed_type_alias(checker, target);
-                    }
+            }
+            if checker.semantic.match_typing_expr(annotation, "TypeAlias") {
+                if checker.enabled(Rule::SnakeCaseTypeAlias) {
+                    flake8_pyi::rules::snake_case_type_alias(checker, target);
+                }
+                if checker.enabled(Rule::TSuffixedTypeAlias) {
+                    flake8_pyi::rules::t_suffixed_type_alias(checker, target);
                 }
             }
         }

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

@@ -31,18 +31,21 @@ use std::path::Path;
 use itertools::Itertools;
 use log::error;
 use ruff_python_ast::{
-    self as ast, Arg, ArgWithDefault, Arguments, Comprehension, Constant, ElifElseClause,
-    ExceptHandler, Expr, ExprContext, Keyword, Pattern, Ranged, Stmt, Suite, UnaryOp,
+    self as ast, Arguments, Comprehension, Constant, ElifElseClause, ExceptHandler, Expr,
+    ExprContext, Keyword, Parameter, ParameterWithDefault, Parameters, Pattern, Ranged, Stmt,
+    Suite, UnaryOp,
 };
 use ruff_text_size::{TextRange, TextSize};
 
 use ruff_diagnostics::{Diagnostic, IsolationLevel};
 use ruff_python_ast::all::{extract_all_names, DunderAllFlags};
-use ruff_python_ast::helpers::{extract_handled_exceptions, to_module_path};
+use ruff_python_ast::helpers::{
+    collect_import_from_member, extract_handled_exceptions, to_module_path,
+};
 use ruff_python_ast::identifier::Identifier;
 use ruff_python_ast::str::trailing_quote;
 use ruff_python_ast::visitor::{walk_except_handler, walk_pattern, Visitor};
-use ruff_python_ast::{helpers, str, visitor};
+use ruff_python_ast::{helpers, str, visitor, PySourceType};
 use ruff_python_codegen::{Generator, Quote, Stylist};
 use ruff_python_index::Indexer;
 use ruff_python_parser::typing::{parse_type_annotation, AnnotationKind};
@@ -52,7 +55,6 @@ use ruff_python_semantic::{
     ModuleKind, ScopeId, ScopeKind, SemanticModel, SemanticModelFlags, StarImport, SubmoduleImport,
 };
 use ruff_python_stdlib::builtins::{BUILTINS, MAGIC_GLOBALS};
-use ruff_python_stdlib::path::is_python_stub_file;
 use ruff_source_file::Locator;
 
 use crate::checkers::ast::deferred::Deferred;
@@ -74,8 +76,8 @@ pub(crate) struct Checker<'a> {
     package: Option<&'a Path>,
     /// The module representation of the current file (e.g., `foo.bar`).
     module_path: Option<&'a [String]>,
-    /// Whether the current file is a stub (`.pyi`) file.
-    is_stub: bool,
+    /// The [`PySourceType`] of the current file.
+    pub(crate) source_type: PySourceType,
     /// The [`flags::Noqa`] for the current analysis (i.e., whether to respect suppression
     /// comments).
     noqa: flags::Noqa,
@@ -117,6 +119,7 @@ impl<'a> Checker<'a> {
         stylist: &'a Stylist,
         indexer: &'a Indexer,
         importer: Importer<'a>,
+        source_type: PySourceType,
     ) -> Checker<'a> {
         Checker {
             settings,
@@ -125,7 +128,7 @@ impl<'a> Checker<'a> {
             path,
             package,
             module_path: module.path(),
-            is_stub: is_python_stub_file(path),
+            source_type,
             locator,
             stylist,
             indexer,
@@ -173,13 +176,12 @@ impl<'a> Checker<'a> {
     ///
     /// If the current expression in the context is not an f-string, returns ``None``.
     pub(crate) fn f_string_quote_style(&self) -> Option<Quote> {
-        let model = &self.semantic;
-        if !model.in_f_string() {
+        if !self.semantic.in_f_string() {
             return None;
         }
 
         // Find the quote character used to start the containing f-string.
-        let expr = model.expr()?;
+        let expr = self.semantic.current_expression()?;
         let string_range = self.indexer.f_string_range(expr.start())?;
         let trailing_quote = trailing_quote(self.locator.slice(string_range))?;
 
@@ -199,7 +201,7 @@ impl<'a> Checker<'a> {
     /// thus be applied whenever we delete a statement, but can otherwise be omitted.
     pub(crate) fn isolation(&self, parent: Option<&Stmt>) -> IsolationLevel {
         parent
-            .and_then(|stmt| self.semantic.stmts.node_id(stmt))
+            .and_then(|stmt| self.semantic.statement_id(stmt))
             .map_or(IsolationLevel::default(), |node_id| {
                 IsolationLevel::Group(node_id.into())
             })
@@ -261,7 +263,7 @@ where
 {
     fn visit_stmt(&mut self, stmt: &'b Stmt) {
         // Step 0: Pre-processing
-        self.semantic.push_stmt(stmt);
+        self.semantic.push_statement(stmt);
 
         // Track whether we've seen docstrings, non-imports, etc.
         match stmt {
@@ -285,7 +287,7 @@ where
                 self.semantic.flags |= SemanticModelFlags::FUTURES_BOUNDARY;
                 if !self.semantic.seen_import_boundary()
                     && !helpers::is_assignment_to_a_dunder(stmt)
-                    && !helpers::in_nested_block(self.semantic.parents())
+                    && !helpers::in_nested_block(self.semantic.current_statements())
                 {
                     self.semantic.flags |= SemanticModelFlags::IMPORT_BOUNDARY;
                 }
@@ -319,11 +321,11 @@ where
                         // Given `import foo.bar`, `name` would be "foo", and `qualified_name` would be
                         // "foo.bar".
                         let name = alias.name.split('.').next().unwrap();
-                        let qualified_name = &alias.name;
+                        let call_path: Box<[&str]> = alias.name.split('.').collect();
                         self.add_binding(
                             name,
                             alias.identifier(),
-                            BindingKind::SubmoduleImport(SubmoduleImport { qualified_name }),
+                            BindingKind::SubmoduleImport(SubmoduleImport { call_path }),
                             BindingFlags::EXTERNAL,
                         );
                     } else {
@@ -334,17 +336,17 @@ where
                         if alias
                             .asname
                             .as_ref()
-                            .map_or(false, |asname| asname.as_str() == alias.name.as_str())
+                            .is_some_and(|asname| asname.as_str() == alias.name.as_str())
                         {
                             flags |= BindingFlags::EXPLICIT_EXPORT;
                         }
 
                         let name = alias.asname.as_ref().unwrap_or(&alias.name);
-                        let qualified_name = &alias.name;
+                        let call_path: Box<[&str]> = alias.name.split('.').collect();
                         self.add_binding(
                             name,
                             alias.identifier(),
-                            BindingKind::Import(Import { qualified_name }),
+                            BindingKind::Import(Import { call_path }),
                             flags,
                         );
                     }
@@ -369,7 +371,7 @@ where
                         );
                     } else if &alias.name == "*" {
                         self.semantic
-                            .scope_mut()
+                            .current_scope_mut()
                             .add_star_import(StarImport { level, module });
                     } else {
                         let mut flags = BindingFlags::EXTERNAL;
@@ -379,7 +381,7 @@ where
                         if alias
                             .asname
                             .as_ref()
-                            .map_or(false, |asname| asname.as_str() == alias.name.as_str())
+                            .is_some_and(|asname| asname.as_str() == alias.name.as_str())
                         {
                             flags |= BindingFlags::EXPLICIT_EXPORT;
                         }
@@ -388,12 +390,16 @@ where
                         // be "foo.bar". Given `from foo import bar as baz`, `name` would be "baz"
                         // and `qualified_name` would be "foo.bar".
                         let name = alias.asname.as_ref().unwrap_or(&alias.name);
-                        let qualified_name =
-                            helpers::format_import_from_member(level, module, &alias.name);
+
+                        // Attempt to resolve any relative imports; but if we don't know the current
+                        // module path, or the relative import extends beyond the package root,
+                        // fallback to a literal representation (e.g., `[".", "foo"]`).
+                        let call_path = collect_import_from_member(level, module, &alias.name)
+                            .into_boxed_slice();
                         self.add_binding(
                             name,
                             alias.identifier(),
-                            BindingKind::FromImport(FromImport { qualified_name }),
+                            BindingKind::FromImport(FromImport { call_path }),
                             flags,
                         );
                     }
@@ -414,7 +420,7 @@ where
                             BindingKind::Global,
                             BindingFlags::GLOBAL,
                         );
-                        let scope = self.semantic.scope_mut();
+                        let scope = self.semantic.current_scope_mut();
                         scope.add(name, binding_id);
                     }
                 }
@@ -437,7 +443,7 @@ where
                                 BindingKind::Nonlocal(scope_id),
                                 BindingFlags::NONLOCAL,
                             );
-                            let scope = self.semantic.scope_mut();
+                            let scope = self.semantic.current_scope_mut();
                             scope.add(name, binding_id);
                         }
                     }
@@ -448,22 +454,16 @@ where
 
         // Step 2: Traversal
         match stmt {
-            Stmt::FunctionDef(ast::StmtFunctionDef {
-                body,
-                args,
-                decorator_list,
-                returns,
-                type_params,
-                ..
-            })
-            | Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
-                body,
-                args,
-                decorator_list,
-                type_params,
-                returns,
-                ..
-            }) => {
+            Stmt::FunctionDef(
+                function_def @ ast::StmtFunctionDef {
+                    body,
+                    parameters,
+                    decorator_list,
+                    returns,
+                    type_params,
+                    ..
+                },
+            ) => {
                 // Visit the decorators and arguments, but avoid the body, which will be
                 // deferred.
                 for decorator in decorator_list {
@@ -476,28 +476,28 @@ where
 
                 self.semantic.push_scope(ScopeKind::Type);
 
-                for type_param in type_params {
-                    self.visit_type_param(type_param);
+                if let Some(type_params) = type_params {
+                    self.visit_type_params(type_params);
                 }
 
-                for arg_with_default in args
+                for parameter_with_default in parameters
                     .posonlyargs
                     .iter()
-                    .chain(&args.args)
-                    .chain(&args.kwonlyargs)
+                    .chain(&parameters.args)
+                    .chain(&parameters.kwonlyargs)
                 {
-                    if let Some(expr) = &arg_with_default.def.annotation {
+                    if let Some(expr) = &parameter_with_default.parameter.annotation {
                         if runtime_annotation {
                             self.visit_runtime_annotation(expr);
                         } else {
                             self.visit_annotation(expr);
                         };
                     }
-                    if let Some(expr) = &arg_with_default.default {
+                    if let Some(expr) = &parameter_with_default.default {
                         self.visit_expr(expr);
                     }
                 }
-                if let Some(arg) = &args.vararg {
+                if let Some(arg) = &parameters.vararg {
                     if let Some(expr) = &arg.annotation {
                         if runtime_annotation {
                             self.visit_runtime_annotation(expr);
@@ -506,7 +506,7 @@ where
                         };
                     }
                 }
-                if let Some(arg) = &args.kwarg {
+                if let Some(arg) = &parameters.kwarg {
                     if let Some(expr) = &arg.annotation {
                         if runtime_annotation {
                             self.visit_runtime_annotation(expr);
@@ -524,8 +524,7 @@ where
                 }
 
                 let definition = docstrings::extraction::extract_definition(
-                    ExtractionTarget::Function,
-                    stmt,
+                    ExtractionTarget::Function(function_def),
                     self.semantic.definition_id,
                     &self.semantic.definitions,
                 );
@@ -533,8 +532,7 @@ where
 
                 self.semantic.push_scope(match &stmt {
                     Stmt::FunctionDef(stmt) => ScopeKind::Function(stmt),
-                    Stmt::AsyncFunctionDef(stmt) => ScopeKind::AsyncFunction(stmt),
-                    _ => unreachable!("Expected Stmt::FunctionDef | Stmt::AsyncFunctionDef"),
+                    _ => unreachable!("Expected Stmt::FunctionDef"),
                 });
 
                 self.deferred.functions.push(self.semantic.snapshot());
@@ -547,8 +545,7 @@ where
             Stmt::ClassDef(
                 class_def @ ast::StmtClassDef {
                     body,
-                    bases,
-                    keywords,
+                    arguments,
                     decorator_list,
                     type_params,
                     ..
@@ -560,19 +557,16 @@ where
 
                 self.semantic.push_scope(ScopeKind::Type);
 
-                for type_param in type_params {
-                    self.visit_type_param(type_param);
+                if let Some(type_params) = type_params {
+                    self.visit_type_params(type_params);
                 }
-                for expr in bases {
-                    self.visit_expr(expr);
-                }
-                for keyword in keywords {
-                    self.visit_keyword(keyword);
+
+                if let Some(arguments) = arguments {
+                    self.visit_arguments(arguments);
                 }
 
                 let definition = docstrings::extraction::extract_definition(
-                    ExtractionTarget::Class,
-                    stmt,
+                    ExtractionTarget::Class(class_def),
                     self.semantic.definition_id,
                     &self.semantic.definitions,
                 );
@@ -587,14 +581,14 @@ where
                 self.visit_body(body);
             }
             Stmt::TypeAlias(ast::StmtTypeAlias {
-                range: _range,
+                range: _,
                 name,
                 type_params,
                 value,
             }) => {
                 self.semantic.push_scope(ScopeKind::Type);
-                for type_param in type_params {
-                    self.visit_type_param(type_param);
+                if let Some(type_params) = type_params {
+                    self.visit_type_params(type_params);
                 }
                 self.visit_expr(value);
                 self.semantic.pop_scope();
@@ -605,14 +599,7 @@ where
                 handlers,
                 orelse,
                 finalbody,
-                range: _,
-            })
-            | Stmt::TryStar(ast::StmtTryStar {
-                body,
-                handlers,
-                orelse,
-                finalbody,
-                range: _,
+                ..
             }) => {
                 let mut handled_exceptions = Exceptions::empty();
                 for type_ in extract_handled_exceptions(handlers) {
@@ -653,7 +640,7 @@ where
                 // available at runtime.
                 // See: https://docs.python.org/3/reference/simple_stmts.html#annotated-assignment-statements
                 let runtime_annotation = if self.semantic.future_annotations() {
-                    if self.semantic.scope().kind.is_class() {
+                    if self.semantic.current_scope().kind.is_class() {
                         let baseclasses = &self
                             .settings
                             .flake8_type_checking
@@ -672,7 +659,7 @@ where
                     }
                 } else {
                     matches!(
-                        self.semantic.scope().kind,
+                        self.semantic.current_scope().kind,
                         ScopeKind::Class(_) | ScopeKind::Module
                     )
                 };
@@ -739,8 +726,7 @@ where
 
         // Step 3: Clean-up
         match stmt {
-            Stmt::FunctionDef(ast::StmtFunctionDef { name, .. })
-            | Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef { name, .. }) => {
+            Stmt::FunctionDef(ast::StmtFunctionDef { name, .. }) => {
                 let scope_id = self.semantic.scope_id;
                 self.deferred.scopes.push(scope_id);
                 self.semantic.pop_scope(); // Function scope
@@ -773,7 +759,7 @@ where
         analyze::statement(stmt, self);
 
         self.semantic.flags = flags_snapshot;
-        self.semantic.pop_stmt();
+        self.semantic.pop_statement();
     }
 
     fn visit_annotation(&mut self, expr: &'b Expr) {
@@ -809,7 +795,7 @@ where
             return;
         }
 
-        self.semantic.push_expr(expr);
+        self.semantic.push_expression(expr);
 
         // Store the flags prior to any further descent, so that we can restore them after visiting
         // the node.
@@ -832,13 +818,12 @@ where
         match expr {
             Expr::Call(ast::ExprCall {
                 func,
-                args: _,
-                keywords: _,
+                arguments: _,
                 range: _,
             }) => {
                 if let Expr::Name(ast::ExprName { id, ctx, range: _ }) = func.as_ref() {
                     if id == "locals" && ctx.is_load() {
-                        let scope = self.semantic.scope_mut();
+                        let scope = self.semantic.current_scope_mut();
                         scope.set_uses_locals();
                     }
                 }
@@ -883,21 +868,21 @@ where
             }
             Expr::Lambda(
                 lambda @ ast::ExprLambda {
-                    args,
+                    parameters,
                     body: _,
                     range: _,
                 },
             ) => {
                 // Visit the default arguments, but avoid the body, which will be deferred.
-                for ArgWithDefault {
+                for ParameterWithDefault {
                     default,
-                    def: _,
+                    parameter: _,
                     range: _,
-                } in args
+                } in parameters
                     .posonlyargs
                     .iter()
-                    .chain(&args.args)
-                    .chain(&args.kwonlyargs)
+                    .chain(&parameters.args)
+                    .chain(&parameters.kwonlyargs)
                 {
                     if let Some(expr) = &default {
                         self.visit_expr(expr);
@@ -919,8 +904,12 @@ where
             }
             Expr::Call(ast::ExprCall {
                 func,
-                args,
-                keywords,
+                arguments:
+                    Arguments {
+                        args,
+                        keywords,
+                        range: _,
+                    },
                 range: _,
             }) => {
                 self.visit_expr(func);
@@ -1098,7 +1087,7 @@ where
                                     arg,
                                     range: _,
                                 } = keyword;
-                                if arg.as_ref().map_or(false, |arg| arg == "type") {
+                                if arg.as_ref().is_some_and(|arg| arg == "type") {
                                     self.visit_type_definition(value);
                                 } else {
                                     self.visit_non_type_definition(value);
@@ -1200,7 +1189,7 @@ where
                     ));
                 }
             }
-            Expr::JoinedStr(_) => {
+            Expr::FString(_) => {
                 self.semantic.flags |= SemanticModelFlags::F_STRING;
                 visitor::walk_expr(self, expr);
             }
@@ -1224,7 +1213,7 @@ where
         analyze::expression(expr, self);
 
         self.semantic.flags = flags_snapshot;
-        self.semantic.pop_expr();
+        self.semantic.pop_expression();
     }
 
     fn visit_except_handler(&mut self, except_handler: &'b ExceptHandler) {
@@ -1279,7 +1268,7 @@ where
 
     fn visit_format_spec(&mut self, format_spec: &'b Expr) {
         match format_spec {
-            Expr::JoinedStr(ast::ExprJoinedStr { values, range: _ }) => {
+            Expr::FString(ast::ExprFString { values, .. }) => {
                 for value in values {
                     self.visit_expr(value);
                 }
@@ -1288,43 +1277,43 @@ where
         }
     }
 
-    fn visit_arguments(&mut self, arguments: &'b Arguments) {
+    fn visit_parameters(&mut self, parameters: &'b Parameters) {
         // Step 1: Binding.
         // Bind, but intentionally avoid walking default expressions, as we handle them
         // upstream.
-        for arg_with_default in &arguments.posonlyargs {
-            self.visit_arg(&arg_with_default.def);
+        for parameter_with_default in &parameters.posonlyargs {
+            self.visit_parameter(&parameter_with_default.parameter);
         }
-        for arg_with_default in &arguments.args {
-            self.visit_arg(&arg_with_default.def);
+        for parameter_with_default in &parameters.args {
+            self.visit_parameter(&parameter_with_default.parameter);
         }
-        if let Some(arg) = &arguments.vararg {
-            self.visit_arg(arg);
+        if let Some(arg) = &parameters.vararg {
+            self.visit_parameter(arg);
         }
-        for arg_with_default in &arguments.kwonlyargs {
-            self.visit_arg(&arg_with_default.def);
+        for parameter_with_default in &parameters.kwonlyargs {
+            self.visit_parameter(&parameter_with_default.parameter);
         }
-        if let Some(arg) = &arguments.kwarg {
-            self.visit_arg(arg);
+        if let Some(arg) = &parameters.kwarg {
+            self.visit_parameter(arg);
         }
 
         // Step 4: Analysis
-        analyze::arguments(arguments, self);
+        analyze::parameters(parameters, self);
     }
 
-    fn visit_arg(&mut self, arg: &'b Arg) {
+    fn visit_parameter(&mut self, parameter: &'b Parameter) {
         // Step 1: Binding.
         // Bind, but intentionally avoid walking the annotation, as we handle it
         // upstream.
         self.add_binding(
-            &arg.arg,
-            arg.identifier(),
+            &parameter.name,
+            parameter.identifier(),
             BindingKind::Argument,
             BindingFlags::empty(),
         );
 
         // Step 4: Analysis
-        analyze::argument(arg, self);
+        analyze::parameter(parameter, self);
     }
 
     fn visit_pattern(&mut self, pattern: &'b Pattern) {
@@ -1604,7 +1593,7 @@ impl<'a> Checker<'a> {
     }
 
     fn handle_node_store(&mut self, id: &'a str, expr: &Expr) {
-        let parent = self.semantic.stmt();
+        let parent = self.semantic.current_statement();
 
         if matches!(
             parent,
@@ -1619,7 +1608,7 @@ impl<'a> Checker<'a> {
             return;
         }
 
-        if matches!(parent, Stmt::For(_) | Stmt::AsyncFor(_)) {
+        if parent.is_for_stmt() {
             self.add_binding(
                 id,
                 expr.range(),
@@ -1639,7 +1628,7 @@ impl<'a> Checker<'a> {
             return;
         }
 
-        let scope = self.semantic.scope();
+        let scope = self.semantic.current_scope();
 
         if scope.kind.is_module()
             && match parent {
@@ -1691,8 +1680,8 @@ impl<'a> Checker<'a> {
 
         if self
             .semantic
-            .expr_ancestors()
-            .any(|expr| expr.is_named_expr_expr())
+            .current_expressions()
+            .any(Expr::is_named_expr_expr)
         {
             self.add_binding(
                 id,
@@ -1718,7 +1707,7 @@ impl<'a> Checker<'a> {
 
         self.semantic.resolve_del(id, expr.range());
 
-        if helpers::on_conditional_branch(&mut self.semantic.parents()) {
+        if helpers::on_conditional_branch(&mut self.semantic.current_statements()) {
             return;
         }
 
@@ -1726,11 +1715,12 @@ impl<'a> Checker<'a> {
         let binding_id =
             self.semantic
                 .push_binding(expr.range(), BindingKind::Deletion, BindingFlags::empty());
-        let scope = self.semantic.scope_mut();
+        let scope = self.semantic.current_scope_mut();
         scope.add(id, binding_id);
     }
 
     fn visit_deferred_future_type_definitions(&mut self) {
+        let snapshot = self.semantic.snapshot();
         while !self.deferred.future_type_definitions.is_empty() {
             let type_definitions = std::mem::take(&mut self.deferred.future_type_definitions);
             for (expr, snapshot) in type_definitions {
@@ -1741,9 +1731,11 @@ impl<'a> Checker<'a> {
                 self.visit_expr(expr);
             }
         }
+        self.semantic.restore(snapshot);
     }
 
     fn visit_deferred_type_param_definitions(&mut self) {
+        let snapshot = self.semantic.snapshot();
         while !self.deferred.type_param_definitions.is_empty() {
             let type_params = std::mem::take(&mut self.deferred.type_param_definitions);
             for (type_param, snapshot) in type_params {
@@ -1757,9 +1749,11 @@ impl<'a> Checker<'a> {
                 }
             }
         }
+        self.semantic.restore(snapshot);
     }
 
     fn visit_deferred_string_type_definitions(&mut self, allocator: &'a typed_arena::Arena<Expr>) {
+        let snapshot = self.semantic.snapshot();
         while !self.deferred.string_type_definitions.is_empty() {
             let type_definitions = std::mem::take(&mut self.deferred.string_type_definitions);
             for (range, value, snapshot) in type_definitions {
@@ -1770,12 +1764,12 @@ impl<'a> Checker<'a> {
 
                     self.semantic.restore(snapshot);
 
-                    if self.semantic.in_typing_only_annotation() {
+                    if self.semantic.in_annotation() && self.semantic.future_annotations() {
                         if self.enabled(Rule::QuotedAnnotation) {
                             pyupgrade::rules::quoted_annotation(self, value, range);
                         }
                     }
-                    if self.is_stub {
+                    if self.source_type.is_stub() {
                         if self.enabled(Rule::QuotedAnnotationInStub) {
                             flake8_pyi::rules::quoted_annotation_in_stub(self, value, range);
                         }
@@ -1803,51 +1797,57 @@ impl<'a> Checker<'a> {
                 }
             }
         }
+        self.semantic.restore(snapshot);
     }
 
     fn visit_deferred_functions(&mut self) {
+        let snapshot = self.semantic.snapshot();
         while !self.deferred.functions.is_empty() {
             let deferred_functions = std::mem::take(&mut self.deferred.functions);
             for snapshot in deferred_functions {
                 self.semantic.restore(snapshot);
 
-                match &self.semantic.stmt() {
-                    Stmt::FunctionDef(ast::StmtFunctionDef { body, args, .. })
-                    | Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef { body, args, .. }) => {
-                        self.visit_arguments(args);
-                        self.visit_body(body);
-                    }
-                    _ => {
-                        unreachable!("Expected Stmt::FunctionDef | Stmt::AsyncFunctionDef")
-                    }
+                if let Stmt::FunctionDef(ast::StmtFunctionDef {
+                    body, parameters, ..
+                }) = self.semantic.current_statement()
+                {
+                    self.visit_parameters(parameters);
+                    self.visit_body(body);
+                } else {
+                    unreachable!("Expected Stmt::FunctionDef")
                 }
             }
         }
+        self.semantic.restore(snapshot);
     }
 
     fn visit_deferred_lambdas(&mut self) {
+        let snapshot = self.semantic.snapshot();
         while !self.deferred.lambdas.is_empty() {
             let lambdas = std::mem::take(&mut self.deferred.lambdas);
             for (expr, snapshot) in lambdas {
                 self.semantic.restore(snapshot);
 
                 if let Expr::Lambda(ast::ExprLambda {
-                    args,
+                    parameters,
                     body,
                     range: _,
                 }) = expr
                 {
-                    self.visit_arguments(args);
+                    self.visit_parameters(parameters);
                     self.visit_expr(body);
                 } else {
                     unreachable!("Expected Expr::Lambda");
                 }
             }
         }
+        self.semantic.restore(snapshot);
     }
 
     /// Run any lint rules that operate over the module exports (i.e., members of `__all__`).
     fn visit_exports(&mut self) {
+        let snapshot = self.semantic.snapshot();
+
         let exports: Vec<(&str, TextRange)> = self
             .semantic
             .global_scope()
@@ -1890,6 +1890,8 @@ impl<'a> Checker<'a> {
                 }
             }
         }
+
+        self.semantic.restore(snapshot);
     }
 }
 
@@ -1904,6 +1906,7 @@ pub(crate) fn check_ast(
     noqa: flags::Noqa,
     path: &Path,
     package: Option<&Path>,
+    source_type: PySourceType,
 ) -> Vec<Diagnostic> {
     let module_path = package.and_then(|package| to_module_path(package, path));
     let module = Module {
@@ -1931,6 +1934,7 @@ pub(crate) fn check_ast(
         stylist,
         indexer,
         Importer::new(python_ast, locator, stylist),
+        source_type,
     );
     checker.bind_builtins();
 

crates/ruff/src/checkers/imports.rs

@@ -2,7 +2,7 @@
 use std::borrow::Cow;
 use std::path::Path;
 
-use ruff_python_ast::{self as ast, Ranged, Stmt, Suite};
+use ruff_python_ast::{self as ast, PySourceType, Ranged, Stmt, Suite};
 
 use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::helpers::to_module_path;
@@ -10,7 +10,7 @@ use ruff_python_ast::imports::{ImportMap, ModuleImport};
 use ruff_python_ast::statement_visitor::StatementVisitor;
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
-use ruff_python_stdlib::path::is_python_stub_file;
+
 use ruff_source_file::Locator;
 
 use crate::directives::IsortDirectives;
@@ -87,12 +87,12 @@ pub(crate) fn check_imports(
     path: &Path,
     package: Option<&Path>,
     source_kind: Option<&SourceKind>,
+    source_type: PySourceType,
 ) -> (Vec<Diagnostic>, Option<ImportMap>) {
-    let is_stub = is_python_stub_file(path);
-
     // Extract all import blocks from the AST.
     let tracker = {
-        let mut tracker = BlockBuilder::new(locator, directives, is_stub, source_kind);
+        let mut tracker =
+            BlockBuilder::new(locator, directives, source_type.is_stub(), source_kind);
         tracker.visit_body(python_ast);
         tracker
     };
@@ -104,7 +104,13 @@ pub(crate) fn check_imports(
         for block in &blocks {
             if !block.imports.is_empty() {
                 if let Some(diagnostic) = isort::rules::organize_imports(
-                    block, locator, stylist, indexer, settings, package,
+                    block,
+                    locator,
+                    stylist,
+                    indexer,
+                    settings,
+                    package,
+                    source_type,
                 ) {
                     diagnostics.push(diagnostic);
                 }
@@ -113,7 +119,11 @@ pub(crate) fn check_imports(
     }
     if settings.rules.enabled(Rule::MissingRequiredImport) {
         diagnostics.extend(isort::rules::add_required_imports(
-            python_ast, locator, stylist, settings, is_stub,
+            python_ast,
+            locator,
+            stylist,
+            settings,
+            source_type,
         ));
     }
 

crates/ruff/src/checkers/noqa.rs

@@ -94,8 +94,15 @@ pub(crate) fn check_noqa(
         }
     }
 
-    // Enforce that the noqa directive was actually used (RUF100).
-    if analyze_directives && settings.rules.enabled(Rule::UnusedNOQA) {
+    // Enforce that the noqa directive was actually used (RUF100), unless RUF100 was itself
+    // suppressed.
+    if settings.rules.enabled(Rule::UnusedNOQA)
+        && analyze_directives
+        && !exemption.is_some_and(|exemption| match exemption {
+            FileExemption::All => true,
+            FileExemption::Codes(codes) => codes.contains(&Rule::UnusedNOQA.noqa_code()),
+        })
+    {
         for line in noqa_directives.lines() {
             match &line.directive {
                 Directive::All(directive) => {