Remove nested f-string flag (#5966)

## Summary

Not worth taking up a slot in the semantic model flags.

.github/workflows/benchmark.yaml

@@ -2,6 +2,14 @@ name: Benchmark
 
 on:
   pull_request:
+    paths:
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+      - 'rust-toolchain'
+      - 'crates/**'
+      - '!crates/ruff_dev'
+      - '!crates/ruff_shrinking'
+
   workflow_dispatch:
 
 concurrency:

.github/workflows/ci.yaml

@@ -19,6 +19,39 @@ env:
   PYTHON_VERSION: "3.11" # to build abi3 wheels
 
 jobs:
+  determine_changes:
+    name: "Determine changes"
+    runs-on: ubuntu-latest
+    outputs:
+      linter: ${{ steps.changed.outputs.linter_any_changed }}
+      formatter: ${{ steps.changed.outputs.formatter_any_changed }}
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - uses: tj-actions/changed-files@v37
+        id: changed
+        with:
+          files_yaml: |
+            linter:
+              - Cargo.toml
+              - Cargo.lock
+              - crates/**
+              - "!crates/ruff_python_formatter/**"
+              - "!crates/ruff_formatter/**"
+              - "!crates/ruff_dev/**"
+              - "!crates/ruff_shrinking/**"
+
+            formatter:
+              - Cargo.toml
+              - Cargo.lock
+              - crates/ruff_python_formatter/**
+              - crates/ruff_formatter/**
+              - crates/ruff_python_trivia/**
+              - crates/ruff_python_ast/**
+
+
   cargo-fmt:
     name: "cargo fmt"
     runs-on: ubuntu-latest
@@ -53,10 +86,12 @@ jobs:
       - uses: actions/checkout@v3
       - name: "Install Rust toolchain"
         run: rustup show
-      - uses: Swatinem/rust-cache@v2
-      # cargo insta 1.30.0 fails for some reason (https://github.com/mitsuhiko/insta/issues/392)
-      - run: cargo install cargo-insta@=1.29.0
+      - name: "Install cargo insta"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-insta
       - run: pip install black[d]==23.1.0
+      - uses: Swatinem/rust-cache@v2
       - name: "Run tests (Ubuntu)"
         if: ${{ matrix.os == 'ubuntu-latest' }}
         run: cargo insta test --all --all-features --unreferenced reject
@@ -135,9 +170,11 @@ jobs:
   ecosystem:
     name: "ecosystem"
     runs-on: ubuntu-latest
-    needs: cargo-test
+    needs:
+      - cargo-test
+      - determine_changes
     # Only runs on pull requests, since that is the only we way we can find the base version for comparison.
-    if: github.event_name == 'pull_request'
+    if: github.event_name == 'pull_request' && needs.determine_changes.outputs.linter == 'true'
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
@@ -285,6 +322,8 @@ jobs:
   check-formatter-stability:
     name: "Check formatter stability"
     runs-on: ubuntu-latest
+    needs: determine_changes
+    if: needs.determine_changes.outputs.formatter == 'true'
     steps:
       - uses: actions/checkout@v3
       - name: "Install Rust toolchain"

.github/workflows/release.yaml

@@ -9,7 +9,7 @@ on:
       sha:
         description: "Optionally, the full sha of the commit to be released"
         type: string
-  push:
+  pull_request:
     paths:
       # When we change pyproject.toml, we want to ensure that the maturin builds still work
       - pyproject.toml

.gitignore

@@ -10,7 +10,7 @@ schemastore
 # `maturin develop` and ecosystem_all_check.sh
 .venv*
 # Formatter debugging (crates/ruff_python_formatter/README.md)
-scratch.py
+scratch.*
 # Created by `perf` (CONTRIBUTING.md)
 perf.data
 perf.data.old

.markdownlint.yaml

@@ -1,6 +1,10 @@
 # default to true for all rules
 default: true
 
+# MD007/unordered-list-indent
+MD007:
+  indent: 4
+
 # MD033/no-inline-html
 MD033: false
 
@@ -8,7 +12,4 @@ MD033: false
 MD041: false
 
 # MD013/line-length
-MD013:
-  line_length: 100
-  code_blocks: false
-  ignore_code_blocks: true
+MD013: false

.pre-commit-config.yaml

@@ -22,6 +22,7 @@ repos:
     hooks:
       - id: mdformat
         additional_dependencies:
+          - mdformat-mkdocs
           - mdformat-black
           - black==23.1.0 # Must be the latest version of Black
 

BREAKING_CHANGES.md

@@ -48,12 +48,12 @@ Taking `UP006` (rewrite `List[int]` to `list[int]`) as an example, the setting n
 follows:
 
 - On Python 3.7 and Python 3.8, setting `keep-runtime-typing = true` will cause Ruff to ignore
-  `UP006` violations, even if `from __future__ import annotations` is present in the file.
-  While such annotations are valid in Python 3.7 and Python 3.8 when combined with
-  `from __future__ import annotations`, they aren't supported by libraries like Pydantic and
-  FastAPI, which rely on runtime type checking.
+    `UP006` violations, even if `from __future__ import annotations` is present in the file.
+    While such annotations are valid in Python 3.7 and Python 3.8 when combined with
+    `from __future__ import annotations`, they aren't supported by libraries like Pydantic and
+    FastAPI, which rely on runtime type checking.
 - On Python 3.9 and above, the setting has no effect, as `list[int]` is a valid type annotation,
-  and libraries like Pydantic and FastAPI support it without issue.
+    and libraries like Pydantic and FastAPI support it without issue.
 
 In short: `keep-runtime-typing` can be used to ensure that Ruff doesn't introduce type annotations
 that are not supported at runtime by the current Python version, which are unsupported by libraries
@@ -203,25 +203,25 @@ This change is largely backwards compatible -- most users should experience
 no change in behavior. However, please note the following exceptions:
 
 - Subcommands will now fail when invoked with unsupported arguments, instead
-  of silently ignoring them. For example, the following will now fail:
+    of silently ignoring them. For example, the following will now fail:
 
-  ```console
-  ruff --clean --respect-gitignore
-  ```
+    ```console
+    ruff --clean --respect-gitignore
+    ```
 
-  (the `clean` command doesn't support `--respect-gitignore`.)
+    (the `clean` command doesn't support `--respect-gitignore`.)
 
 - The semantics of `ruff <arg>` have changed slightly when `<arg>` is a valid subcommand.
-  For example, prior to this release, running `ruff rule` would run `ruff` over a file or
-  directory called `rule`. Now, `ruff rule` would invoke the `rule` subcommand. This should
-  only impact projects with files or directories named `rule`, `check`, `explain`, `clean`,
-  or `generate-shell-completion`.
+    For example, prior to this release, running `ruff rule` would run `ruff` over a file or
+    directory called `rule`. Now, `ruff rule` would invoke the `rule` subcommand. This should
+    only impact projects with files or directories named `rule`, `check`, `explain`, `clean`,
+    or `generate-shell-completion`.
 
 - Scripts that invoke ruff should supply `--` before any positional arguments.
-  (The semantics of `ruff -- <arg>` have not changed.)
+    (The semantics of `ruff -- <arg>` have not changed.)
 
 - `--explain` previously treated `--format grouped` as a synonym for `--format text`.
-  This is no longer supported; instead, use `--format text`.
+    This is no longer supported; instead, use `--format text`.
 
 ## 0.0.226
 

CODE_OF_CONDUCT.md

@@ -6,10 +6,10 @@
 - [Scope](#scope)
 - [Enforcement](#enforcement)
 - [Enforcement Guidelines](#enforcement-guidelines)
-  - [1. Correction](#1-correction)
-  - [2. Warning](#2-warning)
-  - [3. Temporary Ban](#3-temporary-ban)
-  - [4. Permanent Ban](#4-permanent-ban)
+    - [1. Correction](#1-correction)
+    - [2. Warning](#2-warning)
+    - [3. Temporary Ban](#3-temporary-ban)
+    - [4. Permanent Ban](#4-permanent-ban)
 - [Attribution](#attribution)
 
 ## Our Pledge
@@ -33,20 +33,20 @@ community include:
 - Being respectful of differing opinions, viewpoints, and experiences
 - Giving and gracefully accepting constructive feedback
 - Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
+    and learning from the experience
 - Focusing on what is best not just for us as individuals, but for the
-  overall community
+    overall community
 
 Examples of unacceptable behavior include:
 
 - The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
+    advances of any kind
 - Trolling, insulting or derogatory comments, and personal or political attacks
 - Public or private harassment
 - Publishing others' private information, such as a physical or email
-  address, without their explicit permission
+    address, without their explicit permission
 - Other conduct which could reasonably be considered inappropriate in a
-  professional setting
+    professional setting
 
 ## Enforcement Responsibilities
 

CONTRIBUTING.md

@@ -3,16 +3,29 @@
 Welcome! We're happy to have you here. Thank you in advance for your contribution to Ruff.
 
 - [The Basics](#the-basics)
-  - [Prerequisites](#prerequisites)
-  - [Development](#development)
-  - [Project Structure](#project-structure)
-  - [Example: Adding a new lint rule](#example-adding-a-new-lint-rule)
-    - [Rule naming convention](#rule-naming-convention)
-    - [Rule testing: fixtures and snapshots](#rule-testing-fixtures-and-snapshots)
-  - [Example: Adding a new configuration option](#example-adding-a-new-configuration-option)
+    - [Prerequisites](#prerequisites)
+    - [Development](#development)
+    - [Project Structure](#project-structure)
+    - [Example: Adding a new lint rule](#example-adding-a-new-lint-rule)
+        - [Rule naming convention](#rule-naming-convention)
+        - [Rule testing: fixtures and snapshots](#rule-testing-fixtures-and-snapshots)
+    - [Example: Adding a new configuration option](#example-adding-a-new-configuration-option)
 - [MkDocs](#mkdocs)
 - [Release Process](#release-process)
-- [Benchmarks](#benchmarking-and-profiling)
+    - [Creating a new release](#creating-a-new-release)
+- [Ecosystem CI](#ecosystem-ci)
+- [Benchmarking and Profiling](#benchmarking-and-profiling)
+    - [CPython Benchmark](#cpython-benchmark)
+    - [Microbenchmarks](#microbenchmarks)
+        - [Benchmark-driven Development](#benchmark-driven-development)
+        - [PR Summary](#pr-summary)
+        - [Tips](#tips)
+    - [Profiling Projects](#profiling-projects)
+        - [Linux](#linux)
+        - [Mac](#mac)
+- [`cargo dev`](#cargo-dev)
+- [Subsystems](#subsystems)
+    - [Compilation Pipeline](#compilation-pipeline)
 
 ## The Basics
 
@@ -23,7 +36,10 @@ For small changes (e.g., bug fixes), feel free to submit a PR.
 For larger changes (e.g., new lint rules, new functionality, new configuration options), consider
 creating an [**issue**](https://github.com/astral-sh/ruff/issues) outlining your proposed change.
 You can also join us on [**Discord**](https://discord.gg/c9MhzV8aU5) to discuss your idea with the
-community.
+community. We've labeled [beginner-friendly tasks](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)
+in the issue tracker, along with [bugs](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3Abug)
+and [improvements](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3Aaccepted)
+that are ready for contributions.
 
 If you're looking for a place to start, we recommend implementing a new lint rule (see:
 [_Adding a new lint rule_](#example-adding-a-new-lint-rule), which will allow you to learn from and
@@ -34,6 +50,8 @@ As a concrete example: consider taking on one of the rules from the [`flake8-pyi
 plugin, and looking to the originating [Python source](https://github.com/PyCQA/flake8-pyi) for
 guidance.
 
+If you have suggestions on how we might improve the contributing documentation, [let us know](https://github.com/astral-sh/ruff/discussions/5693)!
+
 ### Prerequisites
 
 Ruff is written in Rust. You'll need to install the
@@ -92,48 +110,56 @@ The vast majority of the code, including all lint rules, lives in the `ruff` cra
 At time of writing, the repository includes the following crates:
 
 - `crates/ruff`: library crate containing all lint rules and the core logic for running them.
+    If you're working on a rule, this is the crate for you.
 - `crates/ruff_benchmark`: binary crate for running micro-benchmarks.
 - `crates/ruff_cache`: library crate for caching lint results.
 - `crates/ruff_cli`: binary crate containing Ruff's command-line interface.
 - `crates/ruff_dev`: binary crate containing utilities used in the development of Ruff itself (e.g.,
-  `cargo dev generate-all`).
-- `crates/ruff_diagnostics`: library crate for the lint diagnostics APIs.
-- `crates/ruff_formatter`: library crate for generic code formatting logic based on an intermediate
-  representation.
+    `cargo dev generate-all`), see the [`cargo dev`](#cargo-dev) section below.
+- `crates/ruff_diagnostics`: library crate for the rule-independent abstractions in the lint
+    diagnostics APIs.
+- `crates/ruff_formatter`: library crate for language agnostic code formatting logic based on an
+    intermediate representation. The backend for `ruff_python_formatter`.
 - `crates/ruff_index`: library crate inspired by `rustc_index`.
-- `crates/ruff_macros`: library crate containing macros used by Ruff.
-- `crates/ruff_python_ast`: library crate containing Python-specific AST types and utilities.
-- `crates/ruff_python_formatter`: library crate containing Python-specific code formatting logic.
+- `crates/ruff_macros`: proc macro crate containing macros used by Ruff.
+- `crates/ruff_python_ast`: library crate containing Python-specific AST types and utilities. Note
+    that the AST schema itself is defined in the
+    [rustpython-ast](https://github.com/astral-sh/RustPython-Parser) crate.
+- `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.
 - `crates/ruff_python_semantic`: library crate containing Python-specific semantic analysis logic,
-  including Ruff's semantic model.
-- `crates/ruff_python_stdlib`: library crate containing Python-specific standard library data.
-- `crates/ruff_python_whitespace`: library crate containing Python-specific whitespace analysis
-  logic.
+    including Ruff's semantic model. Used to resolve queries like "What import does this variable
+    refer to?"
+- `crates/ruff_python_stdlib`: library crate containing Python-specific standard library data, e.g.
+    the names of all built-in exceptions and which standard library types are immutable.
+- `crates/ruff_python_trivia`: library crate containing Python-specific trivia utilities (e.g.,
+    for analyzing indentation, newlines, etc.).
 - `crates/ruff_rustpython`: library crate containing `RustPython`-specific utilities.
-- `crates/ruff_testing_macros`: library crate containing macros used for testing Ruff.
 - `crates/ruff_textwrap`: library crate to indent and dedent Python source code.
-- `crates/ruff_wasm`: library crate for exposing Ruff as a WebAssembly module.
+- `crates/ruff_wasm`: library crate for exposing Ruff as a WebAssembly module. Powers the
+    [Ruff Playground](https://play.ruff.rs/).
 
 ### Example: Adding a new lint rule
 
 At a high level, the steps involved in adding a new lint rule are as follows:
 
 1. Determine a name for the new rule as per our [rule naming convention](#rule-naming-convention)
-   (e.g., `AssertFalse`, as in, "allow `assert False`").
+    (e.g., `AssertFalse`, as in, "allow `assert False`").
 
 1. Create a file for your rule (e.g., `crates/ruff/src/rules/flake8_bugbear/rules/assert_false.rs`).
 
 1. In that file, define a violation struct (e.g., `pub struct AssertFalse`). You can grep for
-   `#[violation]` to see examples.
+    `#[violation]` to see examples.
 
 1. In that file, define a function that adds the violation to the diagnostic list as appropriate
-   (e.g., `pub(crate) fn assert_false`) based on whatever inputs are required for the rule (e.g.,
-   an `ast::StmtAssert` node).
+    (e.g., `pub(crate) fn assert_false`) based on whatever inputs are required for the rule (e.g.,
+    an `ast::StmtAssert` node).
 
 1. Define the logic for triggering the violation in `crates/ruff/src/checkers/ast/mod.rs` (for
-   AST-based checks), `crates/ruff/src/checkers/tokens.rs` (for token-based checks),
-   `crates/ruff/src/checkers/lines.rs` (for text-based checks), or
-   `crates/ruff/src/checkers/filesystem.rs` (for filesystem-based checks).
+    AST-based checks), `crates/ruff/src/checkers/tokens.rs` (for token-based checks),
+    `crates/ruff/src/checkers/lines.rs` (for text-based checks), or
+    `crates/ruff/src/checkers/filesystem.rs` (for filesystem-based checks).
 
 1. Map the violation struct to a rule code in `crates/ruff/src/codes.rs` (e.g., `B011`).
 
@@ -166,13 +192,13 @@ suppression comment would be framed as "allow `assert False`".
 As such, rule names should...
 
 - Highlight the pattern that is being linted against, rather than the preferred alternative.
-  For example, `AssertFalse` guards against `assert False` statements.
+    For example, `AssertFalse` guards against `assert False` statements.
 
 - _Not_ contain instructions on how to fix the violation, which instead belong in the rule
-  documentation and the `autofix_title`.
+    documentation and the `autofix_title`.
 
 - _Not_ contain a redundant prefix, like `Disallow` or `Banned`, which are already implied by the
-  convention.
+    convention.
 
 When re-implementing rules from other linters, we prioritize adhering to this convention over
 preserving the original rule name.
@@ -187,25 +213,25 @@ Ruff's output for each fixture, which you can then commit alongside your changes
 Once you've completed the code for the rule itself, you can define tests with the following steps:
 
 1. Add a Python file to `crates/ruff/resources/test/fixtures/[linter]` that contains the code you
-   want to test. The file name should match the rule name (e.g., `E402.py`), and it should include
-   examples of both violations and non-violations.
+    want to test. The file name should match the rule name (e.g., `E402.py`), and it should include
+    examples of both violations and non-violations.
 
 1. Run Ruff locally against your file and verify the output is as expected. Once you're satisfied
-   with the output (you see the violations you expect, and no others), proceed to the next step.
-   For example, if you're adding a new rule named `E402`, you would run:
+    with the output (you see the violations you expect, and no others), proceed to the next step.
+    For example, if you're adding a new rule named `E402`, you would run:
 
-   ```shell
-   cargo run -p ruff_cli -- check crates/ruff/resources/test/fixtures/pycodestyle/E402.py --no-cache
-   ```
+    ```shell
+    cargo run -p ruff_cli -- check crates/ruff/resources/test/fixtures/pycodestyle/E402.py --no-cache
+    ```
 
 1. Add the test to the relevant `crates/ruff/src/rules/[linter]/mod.rs` file. If you're contributing
-   a rule to a pre-existing set, you should be able to find a similar example to pattern-match
-   against. If you're adding a new linter, you'll need to create a new `mod.rs` file (see,
-   e.g., `crates/ruff/src/rules/flake8_bugbear/mod.rs`)
+    a rule to a pre-existing set, you should be able to find a similar example to pattern-match
+    against. If you're adding a new linter, you'll need to create a new `mod.rs` file (see,
+    e.g., `crates/ruff/src/rules/flake8_bugbear/mod.rs`)
 
 1. Run `cargo test`. Your test will fail, but you'll be prompted to follow-up
-   with `cargo insta review`. Run `cargo insta review`, review and accept the generated snapshot,
-   then commit the snapshot file alongside the rest of your changes.
+    with `cargo insta review`. Run `cargo insta review`, review and accept the generated snapshot,
+    then commit the snapshot file alongside the rest of your changes.
 
 1. Run `cargo test` again to ensure that your test passes.
 
@@ -243,25 +269,25 @@ To preview any changes to the documentation locally:
 
 1. Install MkDocs and Material for MkDocs with:
 
-   ```shell
-   pip install -r docs/requirements.txt
-   ```
+    ```shell
+    pip install -r docs/requirements.txt
+    ```
 
 1. Generate the MkDocs site with:
 
-   ```shell
-   python scripts/generate_mkdocs.py
-   ```
+    ```shell
+    python scripts/generate_mkdocs.py
+    ```
 
 1. Run the development server with:
 
-   ```shell
-   # For contributors.
-   mkdocs serve -f mkdocs.generated.yml
+    ```shell
+    # For contributors.
+    mkdocs serve -f mkdocs.generated.yml
 
-   # For members of the Astral org, which has access to MkDocs Insiders via sponsorship.
-   mkdocs serve -f mkdocs.insiders.yml
-   ```
+    # For members of the Astral org, which has access to MkDocs Insiders via sponsorship.
+    mkdocs serve -f mkdocs.insiders.yml
+    ```
 
 The documentation should then be available locally at
 [http://127.0.0.1:8000/docs/](http://127.0.0.1:8000/docs/).
@@ -282,20 +308,19 @@ even patch releases may contain [non-backwards-compatible changes](https://semve
 1. Create a PR with the version and `BREAKING_CHANGES.md` updated
 1. Merge the PR
 1. Run the release workflow with the version number (without starting `v`) as input. Make sure
-   main has your merged PR as last commit
+    main has your merged PR as last commit
 1. The release workflow will do the following:
-   1. Build all the assets. If this fails (even though we tested in step 4), we haven’t tagged or
-      uploaded anything, you can restart after pushing a fix
-   1. Upload to pypi
-   1. Create and push the git tag (from pyproject.toml). We create the git tag only here
-      because we can't change it ([#4468](https://github.com/charliermarsh/ruff/issues/4468)), so
-      we want to make sure everything up to and including publishing to pypi worked.
-   1. Attach artifacts to draft GitHub release
-   1. Trigger downstream repositories. This can fail without causing fallout, it is possible (if
-      inconvenient) to trigger the downstream jobs manually
-1. Create release notes in GitHub UI and promote from draft to proper release(<https://github.com/charliermarsh/ruff/releases/new>)
+    1. Build all the assets. If this fails (even though we tested in step 4), we haven’t tagged or
+        uploaded anything, you can restart after pushing a fix.
+    1. Upload to PyPI.
+    1. Create and push the Git tag (as extracted from `pyproject.toml`). We create the Git tag only
+        after building the wheels and uploading to PyPI, since we can't delete or modify the tag ([#4468](https://github.com/charliermarsh/ruff/issues/4468)).
+    1. Attach artifacts to draft GitHub release
+    1. Trigger downstream repositories. This can fail non-catastrophically, as we can run any
+        downstream jobs manually if needed.
+1. Create release notes in GitHub UI and promote from draft.
 1. If needed, [update the schemastore](https://github.com/charliermarsh/ruff/blob/main/scripts/update_schemastore.py)
-1. If needed, update ruff-lsp and ruff-vscode
+1. If needed, update the `ruff-lsp` and `ruff-vscode` repositories.
 
 ## Ecosystem CI
 
@@ -394,6 +419,13 @@ Summary
   159.43 ± 2.48 times faster than 'pycodestyle crates/ruff/resources/test/cpython'
 ```
 
+To benchmark a subset of rules, e.g. `LineTooLong` and `DocLineTooLong`:
+
+```shell
+cargo build --release && hyperfine --warmup 10 \
+  "./target/release/ruff ./crates/ruff/resources/test/cpython/ --no-cache -e --select W505,E501"
+```
+
 You can run `poetry install` from `./scripts/benchmarks` to create a working environment for the
 above. All reported benchmarks were computed using the versions specified by
 `./scripts/benchmarks/pyproject.toml` on Python 3.11.
@@ -438,7 +470,7 @@ Benchmark 1: find . -type f -name "*.py" | xargs -P 0 pyupgrade --py311-plus
   Range (min … max):   29.813 s … 30.356 s    10 runs
 ```
 
-## Microbenchmarks
+### Microbenchmarks
 
 The `ruff_benchmark` crate benchmarks the linter and the formatter on individual files.
 
@@ -448,7 +480,7 @@ You can run the benchmarks with
 cargo benchmark
 ```
 
-### Benchmark driven Development
+#### Benchmark-driven Development
 
 Ruff uses [Criterion.rs](https://bheisler.github.io/criterion.rs/book/) for benchmarks. You can use
 `--save-baseline=<name>` to store an initial baseline benchmark (e.g. on `main`) and then use
@@ -463,7 +495,7 @@ cargo benchmark --save-baseline=main
 cargo benchmark --baseline=main
 ```
 
-### PR Summary
+#### PR Summary
 
 You can use `--save-baseline` and `critcmp` to get a pretty comparison between two recordings.
 This is useful to illustrate the improvements of a PR.
@@ -484,21 +516,21 @@ You must install [`critcmp`](https://github.com/BurntSushi/critcmp) for the comp
 cargo install critcmp
 ```
 
-### Tips
+#### Tips
 
 - Use `cargo benchmark <filter>` to only run specific benchmarks. For example: `cargo benchmark linter/pydantic`
-  to only run the pydantic tests.
+    to only run the pydantic tests.
 - Use `cargo benchmark --quiet` for a more cleaned up output (without statistical relevance)
 - Use `cargo benchmark --quick` to get faster results (more prone to noise)
 
-## Profiling Projects
+### Profiling Projects
 
 You can either use the microbenchmarks from above or a project directory for benchmarking. There
 are a lot of profiling tools out there,
 [The Rust Performance Book](https://nnethercote.github.io/perf-book/profiling.html) lists some
 examples.
 
-### Linux
+#### Linux
 
 Install `perf` and build `ruff_benchmark` with the `release-debug` profile and then run it with perf
 
@@ -531,7 +563,7 @@ An alternative is to convert the perf data to `flamegraph.svg` using
 flamegraph --perfdata perf.data
 ```
 
-### Mac
+#### Mac
 
 Install [`cargo-instruments`](https://crates.io/crates/cargo-instruments):
 
@@ -546,7 +578,7 @@ cargo instruments -t time --bench linter --profile release-debug -p ruff_benchma
 ```
 
 - `-t`: Specifies what to profile. Useful options are `time` to profile the wall time and `alloc`
-  for profiling the allocations.
+    for profiling the allocations.
 - You may want to pass an additional filter to run a single test file
 
 Otherwise, follow the instructions from the linux section.
@@ -557,10 +589,10 @@ Otherwise, follow the instructions from the linux section.
 utils with it:
 
 - `cargo dev print-ast <file>`: Print the AST of a python file using the
-  [RustPython parser](https://github.com/astral-sh/RustPython-Parser/tree/main/parser) that is
-  mainly used in Ruff. For `if True: pass # comment`, you can see the syntax tree, the byte offsets
-  for start and stop of each node and also how the `:` token, the comment and whitespace are not
-  represented anymore:
+    [RustPython parser](https://github.com/astral-sh/RustPython-Parser/tree/main/parser) that is
+    mainly used in Ruff. For `if True: pass # comment`, you can see the syntax tree, the byte offsets
+    for start and stop of each node and also how the `:` token, the comment and whitespace are not
+    represented anymore:
 
 ```text
 [
@@ -590,7 +622,7 @@ utils with it:
 ```
 
 - `cargo dev print-tokens <file>`: Print the tokens that the AST is built upon. Again for
-  `if True: pass # comment`:
+    `if True: pass # comment`:
 
 ```text
 0 If 2
@@ -604,8 +636,8 @@ utils with it:
 ```
 
 - `cargo dev print-cst <file>`: Print the CST of a python file using
-  [LibCST](https://github.com/Instagram/LibCST), which is used in addition to the RustPython parser
-  in Ruff. E.g. for `if True: pass # comment` everything including the whitespace is represented:
+    [LibCST](https://github.com/Instagram/LibCST), which is used in addition to the RustPython parser
+    in Ruff. E.g. for `if True: pass # comment` everything including the whitespace is represented:
 
 ```text
 Module {
@@ -671,13 +703,54 @@ Module {
 ```
 
 - `cargo dev generate-all`: Update `ruff.schema.json`, `docs/configuration.md` and `docs/rules`.
-  You can also set `RUFF_UPDATE_SCHEMA=1` to update `ruff.schema.json` during `cargo test`.
+    You can also set `RUFF_UPDATE_SCHEMA=1` to update `ruff.schema.json` during `cargo test`.
 - `cargo dev generate-cli-help`, `cargo dev generate-docs` and `cargo dev generate-json-schema`:
-  Update just `docs/configuration.md`, `docs/rules` and `ruff.schema.json` respectively.
+    Update just `docs/configuration.md`, `docs/rules` and `ruff.schema.json` respectively.
 - `cargo dev generate-options`: Generate a markdown-compatible table of all `pyproject.toml`
-  options. Used for <https://beta.ruff.rs/docs/settings/>
+    options. Used for <https://beta.ruff.rs/docs/settings/>
 - `cargo dev generate-rules-table`: Generate a markdown-compatible table of all rules. Used for <https://beta.ruff.rs/docs/rules/>
 - `cargo dev round-trip <python file or jupyter notebook>`: Read a Python file or Jupyter Notebook,
-  parse it, serialize the parsed representation and write it back. Used to check how good our
-  representation is so that fixes don't rewrite irrelevant parts of a file.
+    parse it, serialize the parsed representation and write it back. Used to check how good our
+    representation is so that fixes don't rewrite irrelevant parts of a file.
 - `cargo dev format_dev`: See ruff_python_formatter README.md
+
+## Subsystems
+
+### Compilation Pipeline
+
+If we view Ruff as a compiler, in which the inputs are paths to Python files and the outputs are
+diagnostics, then our current compilation pipeline proceeds as follows:
+
+1. **File discovery**: Given paths like `foo/`, locate all Python files in any specified subdirectories, taking into account our hierarchical settings system and any `exclude` options.
+
+1. **Package resolution**: Determine the “package root” for every file by traversing over its parent directories and looking for `__init__.py` files.
+
+1. **Cache initialization**: For every “package root”, initialize an empty cache.
+
+1. **Analysis**: For every file, in parallel:
+
+    1. **Cache read**: If the file is cached (i.e., its modification timestamp hasn't changed since it was last analyzed), short-circuit, and return the cached diagnostics.
+
+    1. **Tokenization**: Run the lexer over the file to generate a token stream.
+
+    1. **Indexing**: Extract metadata from the token stream, such as: comment ranges, `# noqa` locations, `# isort: off` locations, “doc lines”, etc.
+
+    1. **Token-based rule evaluation**: Run any lint rules that are based on the contents of the token stream (e.g., commented-out code).
+
+    1. **Filesystem-based rule evaluation**: Run any lint rules that are based on the contents of the filesystem (e.g., lack of `__init__.py` file in a package).
+
+    1. **Logical line-based rule evaluation**: Run any lint rules that are based on logical lines (e.g., stylistic rules).
+
+    1. **Parsing**: Run the parser over the token stream to produce an AST. (This consumes the token stream, so anything that relies on the token stream needs to happen before parsing.)
+
+    1. **AST-based rule evaluation**: Run any lint rules that are based on the AST. This includes the vast majority of lint rules. As part of this step, we also build the semantic model for the current file as we traverse over the AST. Some lint rules are evaluated eagerly, as we iterate over the AST, while others are evaluated in a deferred manner (e.g., unused imports, since we can’t determine whether an import is unused until we’ve finished analyzing the entire file), after we’ve finished the initial traversal.
+
+    1. **Import-based rule evaluation**: Run any lint rules that are based on the module’s imports (e.g., import sorting). These could, in theory, be included in the AST-based rule evaluation phase — they’re just separated for simplicity.
+
+    1. **Physical line-based rule evaluation**: Run any lint rules that are based on physical lines (e.g., line-length).
+
+    1. **Suppression enforcement**: Remove any violations that are suppressed via `# noqa` directives or `per-file-ignores`.
+
+    1. **Cache write**: Write the generated diagnostics to the package cache using the file as a key.
+
+1. **Reporting**: Print diagnostics in the specified format (text, JSON, etc.), to the specified output channel (stdout, a file, etc.).

Cargo.lock

@@ -188,7 +188,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05"
 dependencies = [
  "memchr",
- "regex-automata",
+ "regex-automata 0.3.0",
  "serde",
 ]
 
@@ -734,7 +734,7 @@ dependencies = [
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.278"
+version = "0.0.280"
 dependencies = [
  "anyhow",
  "clap",
@@ -776,6 +776,12 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "fs-err"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0845fa252299212f0389d64ba26f34fa32cfe41588355f21ed507c59a0f64541"
+
 [[package]]
 name = "fsevent-sys"
 version = "4.1.0"
@@ -963,6 +969,12 @@ dependencies = [
  "unicode-width",
 ]
 
+[[package]]
+name = "indoc"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c785eefb63ebd0e33416dfcb8d6da0bf27ce752843a45632a67bf10d4d4b5c4"
+
 [[package]]
 name = "inotify"
 version = "0.9.6"
@@ -985,14 +997,15 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.30.0"
+version = "1.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28491f7753051e5704d4d0ae7860d45fae3238d7d235bc4289dcd45c48d3cec3"
+checksum = "a0770b0a3d4c70567f0d58331f3088b0e4c4f56c9b8d764efe654b4a5d46de3a"
 dependencies = [
  "console",
  "globset",
  "lazy_static",
  "linked-hash-map",
+ "regex",
  "similar",
  "walkdir",
  "yaml-rust",
@@ -1192,6 +1205,15 @@ version = "0.4.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b06a4cde4c0f271a446782e3eff8de789548ce57dbc8eca9292c27f4a42004b4"
 
+[[package]]
+name = "matchers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+dependencies = [
+ "regex-automata 0.1.10",
+]
+
 [[package]]
 name = "matches"
 version = "0.1.10"
@@ -1307,6 +1329,16 @@ dependencies = [
  "windows-sys 0.45.0",
 ]
 
+[[package]]
+name = "nu-ansi-term"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+dependencies = [
+ "overload",
+ "winapi",
+]
+
 [[package]]
 name = "num-bigint"
 version = "0.4.3"
@@ -1389,6 +1421,12 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "overload"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+
 [[package]]
 name = "paste"
 version = "1.0.13"
@@ -1775,8 +1813,17 @@ checksum = "89089e897c013b3deb627116ae56a6955a72b8bed395c9526af31c9fe528b484"
 dependencies = [
  "aho-corasick 1.0.2",
  "memchr",
- "regex-automata",
- "regex-syntax",
+ "regex-automata 0.3.0",
+ "regex-syntax 0.7.3",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+dependencies = [
+ "regex-syntax 0.6.29",
 ]
 
 [[package]]
@@ -1787,9 +1834,15 @@ checksum = "fa250384981ea14565685dea16a9ccc4d1c541a13f82b9c168572264d1df8c56"
 dependencies = [
  "aho-corasick 1.0.2",
  "memchr",
- "regex-syntax",
+ "regex-syntax 0.7.3",
 ]
 
+[[package]]
+name = "regex-syntax"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
 [[package]]
 name = "regex-syntax"
 version = "0.7.3"
@@ -1835,7 +1888,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.278"
+version = "0.0.280"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1876,7 +1929,7 @@ dependencies = [
  "ruff_python_ast",
  "ruff_python_semantic",
  "ruff_python_stdlib",
- "ruff_python_whitespace",
+ "ruff_python_trivia",
  "ruff_rustpython",
  "ruff_text_size",
  "ruff_textwrap",
@@ -1893,12 +1946,14 @@ dependencies = [
  "smallvec",
  "strum",
  "strum_macros",
+ "tempfile",
  "test-case",
  "thiserror",
  "toml",
  "typed-arena",
  "unicode-width",
  "unicode_names2",
+ "wsl",
 ]
 
 [[package]]
@@ -1933,7 +1988,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_cli"
-version = "0.0.278"
+version = "0.0.280"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1950,6 +2005,7 @@ dependencies = [
  "filetime",
  "glob",
  "ignore",
+ "insta",
  "itertools",
  "itoa",
  "log",
@@ -1972,6 +2028,7 @@ dependencies = [
  "shellexpand",
  "similar",
  "strum",
+ "tempfile",
  "tikv-jemallocator",
  "ureq",
  "walkdir",
@@ -1986,6 +2043,7 @@ dependencies = [
  "clap",
  "ignore",
  "indicatif",
+ "indoc",
  "itertools",
  "libcst",
  "log",
@@ -2003,11 +2061,13 @@ dependencies = [
  "rustpython-format",
  "rustpython-parser",
  "schemars",
+ "serde",
  "serde_json",
  "similar",
  "strum",
  "strum_macros",
  "tempfile",
+ "toml",
 ]
 
 [[package]]
@@ -2068,7 +2128,7 @@ dependencies = [
  "num-bigint",
  "num-traits",
  "once_cell",
- "ruff_python_whitespace",
+ "ruff_python_trivia",
  "ruff_text_size",
  "rustc-hash",
  "rustpython-ast",
@@ -2092,7 +2152,7 @@ dependencies = [
  "once_cell",
  "ruff_formatter",
  "ruff_python_ast",
- "ruff_python_whitespace",
+ "ruff_python_trivia",
  "ruff_text_size",
  "rustc-hash",
  "rustpython-parser",
@@ -2101,7 +2161,6 @@ dependencies = [
  "similar",
  "smallvec",
  "thiserror",
- "unic-ucd-ident",
 ]
 
 [[package]]
@@ -2136,11 +2195,14 @@ name = "ruff_python_stdlib"
 version = "0.0.0"
 
 [[package]]
-name = "ruff_python_whitespace"
+name = "ruff_python_trivia"
 version = "0.0.0"
 dependencies = [
+ "insta",
  "memchr",
  "ruff_text_size",
+ "smallvec",
+ "unic-ucd-ident",
 ]
 
 [[package]]
@@ -2151,10 +2213,26 @@ dependencies = [
  "rustpython-parser",
 ]
 
+[[package]]
+name = "ruff_shrinking"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "fs-err",
+ "regex",
+ "ruff_python_ast",
+ "ruff_rustpython",
+ "rustpython-ast",
+ "shlex",
+ "tracing",
+ "tracing-subscriber",
+]
+
 [[package]]
 name = "ruff_text_size"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=c174bbf1f29527edd43d432326327f16f47ab9e0#c174bbf1f29527edd43d432326327f16f47ab9e0"
+source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=4d03b9b5b212fc869e4cfda151414438186a7779#4d03b9b5b212fc869e4cfda151414438186a7779"
 dependencies = [
  "schemars",
  "serde",
@@ -2164,7 +2242,7 @@ dependencies = [
 name = "ruff_textwrap"
 version = "0.0.0"
 dependencies = [
- "ruff_python_whitespace",
+ "ruff_python_trivia",
  "ruff_text_size",
 ]
 
@@ -2179,6 +2257,7 @@ dependencies = [
  "ruff",
  "ruff_diagnostics",
  "ruff_python_ast",
+ "ruff_python_formatter",
  "ruff_rustpython",
  "rustpython-parser",
  "serde",
@@ -2255,7 +2334,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.2.0"
-source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=c174bbf1f29527edd43d432326327f16f47ab9e0#c174bbf1f29527edd43d432326327f16f47ab9e0"
+source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=4d03b9b5b212fc869e4cfda151414438186a7779#4d03b9b5b212fc869e4cfda151414438186a7779"
 dependencies = [
  "is-macro",
  "num-bigint",
@@ -2266,7 +2345,7 @@ dependencies = [
 [[package]]
 name = "rustpython-format"
 version = "0.2.0"
-source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=c174bbf1f29527edd43d432326327f16f47ab9e0#c174bbf1f29527edd43d432326327f16f47ab9e0"
+source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=4d03b9b5b212fc869e4cfda151414438186a7779#4d03b9b5b212fc869e4cfda151414438186a7779"
 dependencies = [
  "bitflags 2.3.3",
  "itertools",
@@ -2278,7 +2357,7 @@ dependencies = [
 [[package]]
 name = "rustpython-literal"
 version = "0.2.0"
-source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=c174bbf1f29527edd43d432326327f16f47ab9e0#c174bbf1f29527edd43d432326327f16f47ab9e0"
+source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=4d03b9b5b212fc869e4cfda151414438186a7779#4d03b9b5b212fc869e4cfda151414438186a7779"
 dependencies = [
  "hexf-parse",
  "is-macro",
@@ -2290,7 +2369,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.2.0"
-source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=c174bbf1f29527edd43d432326327f16f47ab9e0#c174bbf1f29527edd43d432326327f16f47ab9e0"
+source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=4d03b9b5b212fc869e4cfda151414438186a7779#4d03b9b5b212fc869e4cfda151414438186a7779"
 dependencies = [
  "anyhow",
  "is-macro",
@@ -2313,7 +2392,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser-core"
 version = "0.2.0"
-source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=c174bbf1f29527edd43d432326327f16f47ab9e0#c174bbf1f29527edd43d432326327f16f47ab9e0"
+source = "git+https://github.com/astral-sh/RustPython-Parser.git?rev=4d03b9b5b212fc869e4cfda151414438186a7779#4d03b9b5b212fc869e4cfda151414438186a7779"
 dependencies = [
  "is-macro",
  "memchr",
@@ -2483,6 +2562,15 @@ dependencies = [
  "syn 2.0.23",
 ]
 
+[[package]]
+name = "sharded-slab"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31"
+dependencies = [
+ "lazy_static",
+]
+
 [[package]]
 name = "shellexpand"
 version = "3.1.0"
@@ -2492,6 +2580,12 @@ dependencies = [
  "dirs 5.0.1",
 ]
 
+[[package]]
+name = "shlex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
+
 [[package]]
 name = "similar"
 version = "2.2.1"
@@ -2845,6 +2939,36 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0955b8137a1df6f1a2e9a37d8a6656291ff0297c1a97c24e0d8425fe2312f79a"
 dependencies = [
  "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922"
+dependencies = [
+ "lazy_static",
+ "log",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30a651bc37f915e81f087d86e62a18eec5f79550c7faff886f7090b4ea757c77"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "regex",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
 ]
 
 [[package]]
@@ -2998,6 +3122,12 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d023da39d1fde5a8a3fe1f3e01ca9632ada0a63e9797de55a879d6e2236277be"
 
+[[package]]
+name = "valuable"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+
 [[package]]
 name = "version_check"
 version = "0.9.4"
@@ -3345,6 +3475,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "wsl"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dab7ac864710bdea6594becbea5b5050333cf34fefb0dc319567eb347950d4"
+
 [[package]]
 name = "yaml-rust"
 version = "0.4.5"

Cargo.toml

@@ -21,7 +21,7 @@ filetime = { version = "0.2.20" }
 glob = { version = "0.3.1" }
 globset = { version = "0.4.10" }
 ignore = { version = "0.4.20" }
-insta = { version = "1.30.0" }
+insta = { version = "1.31.0", feature = ["filters", "glob"] }
 is-macro = { version = "0.2.2" }
 itertools = { version = "0.10.5" }
 log = { version = "0.4.17" }
@@ -47,18 +47,16 @@ syn = { version = "2.0.15" }
 test-case = { version = "3.0.0" }
 thiserror = { version = "1.0.43" }
 toml = { version = "0.7.2" }
+wsl = { version = "0.1.0" }
 
 # v1.0.1
 libcst = { git = "https://github.com/Instagram/LibCST.git", rev = "3cacca1a1029f05707e50703b49fe3dd860aa839", default-features = false }
 
-# Please tag the RustPython version every time you update its revision here and in fuzz/Cargo.toml
-# Tagging the version ensures that older ruff versions continue to build from source even when we rebase our RustPython fork.
-# Current tag: v0.0.7
-ruff_text_size = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "c174bbf1f29527edd43d432326327f16f47ab9e0" }
-rustpython-ast = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "c174bbf1f29527edd43d432326327f16f47ab9e0" , default-features = false, features = ["num-bigint"]}
-rustpython-format = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "c174bbf1f29527edd43d432326327f16f47ab9e0", default-features = false, features = ["num-bigint"] }
-rustpython-literal = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "c174bbf1f29527edd43d432326327f16f47ab9e0", default-features = false }
-rustpython-parser = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "c174bbf1f29527edd43d432326327f16f47ab9e0" , default-features = false, features = ["full-lexer", "num-bigint"] }
+ruff_text_size = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "4d03b9b5b212fc869e4cfda151414438186a7779" }
+rustpython-ast = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "4d03b9b5b212fc869e4cfda151414438186a7779" , default-features = false, features = ["num-bigint"]}
+rustpython-format = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "4d03b9b5b212fc869e4cfda151414438186a7779", default-features = false, features = ["num-bigint"] }
+rustpython-literal = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "4d03b9b5b212fc869e4cfda151414438186a7779", default-features = false }
+rustpython-parser = { git = "https://github.com/astral-sh/RustPython-Parser.git", rev = "4d03b9b5b212fc869e4cfda151414438186a7779" , default-features = false, features = ["full-lexer", "num-bigint"] }
 
 [profile.release]
 lto = "fat"

README.md

@@ -32,10 +32,10 @@ An extremely fast Python linter, written in Rust.
 - 🔧 Autofix support, for automatic error correction (e.g., automatically remove unused imports)
 - 📏 Over [500 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
+    built-in Flake8 rule set
 - 🔌 Native re-implementations of dozens of Flake8 plugins, like flake8-bugbear
 - ⌨️ First-party [editor integrations](https://beta.ruff.rs/docs/editor-integrations/) for
-  [VS Code](https://github.com/astral-sh/ruff-vscode) and [more](https://github.com/astral-sh/ruff-lsp)
+    [VS Code](https://github.com/astral-sh/ruff-vscode) and [more](https://github.com/astral-sh/ruff-lsp)
 - 🌎 Monorepo-friendly, with [hierarchical and cascading configuration](https://beta.ruff.rs/docs/configuration/#pyprojecttoml-discovery)
 
 Ruff aims to be orders of magnitude faster than alternative tools while integrating more
@@ -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.278
+  rev: v0.0.280
   hooks:
     - id: ruff
 ```
@@ -364,8 +364,8 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [Great Expectations](https://github.com/great-expectations/great_expectations)
 - [HTTPX](https://github.com/encode/httpx)
 - Hugging Face ([Transformers](https://github.com/huggingface/transformers),
-  [Datasets](https://github.com/huggingface/datasets),
-  [Diffusers](https://github.com/huggingface/diffusers))
+    [Datasets](https://github.com/huggingface/datasets),
+    [Diffusers](https://github.com/huggingface/diffusers))
 - [Hatch](https://github.com/pypa/hatch)
 - [Home Assistant](https://github.com/home-assistant/core)
 - ING Bank ([popmon](https://github.com/ing-bank/popmon), [probatus](https://github.com/ing-bank/probatus))
@@ -377,8 +377,8 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [MegaLinter](https://github.com/oxsecurity/megalinter)
 - Meltano ([Meltano CLI](https://github.com/meltano/meltano), [Singer SDK](https://github.com/meltano/sdk))
 - Microsoft ([Semantic Kernel](https://github.com/microsoft/semantic-kernel),
-  [ONNX Runtime](https://github.com/microsoft/onnxruntime),
-  [LightGBM](https://github.com/microsoft/LightGBM))
+    [ONNX Runtime](https://github.com/microsoft/onnxruntime),
+    [LightGBM](https://github.com/microsoft/LightGBM))
 - Modern Treasury ([Python SDK](https://github.com/Modern-Treasury/modern-treasury-python-sdk))
 - Mozilla ([Firefox](https://github.com/mozilla/gecko-dev))
 - [Mypy](https://github.com/python/mypy)
@@ -397,7 +397,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [PyTorch](https://github.com/pytorch/pytorch)
 - [Pydantic](https://github.com/pydantic/pydantic)
 - [Pylint](https://github.com/PyCQA/pylint)
-- [Pynecone](https://github.com/pynecone-io/pynecone)
+- [Reflex](https://github.com/reflex-dev/reflex)
 - [Robyn](https://github.com/sansyrox/robyn)
 - Scale AI ([Launch SDK](https://github.com/scaleapi/launch-python-client))
 - Snowflake ([SnowCLI](https://github.com/Snowflake-Labs/snowcli))

crates/flake8_to_ruff/Cargo.toml

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

crates/flake8_to_ruff/README.md

@@ -82,12 +82,12 @@ flake8-to-ruff path/to/.flake8 --plugin flake8-builtins --plugin flake8-quotes
 ## Limitations
 
 1. Ruff only supports a subset of the Flake configuration options. `flake8-to-ruff` will warn on and
-   ignore unsupported options in the `.flake8` file (or equivalent). (Similarly, Ruff has a few
-   configuration options that don't exist in Flake8.)
+    ignore unsupported options in the `.flake8` file (or equivalent). (Similarly, Ruff has a few
+    configuration options that don't exist in Flake8.)
 1. Ruff will omit any rule codes that are unimplemented or unsupported by Ruff, including rule
-   codes from unsupported plugins. (See the
-   [documentation](https://beta.ruff.rs/docs/faq/#how-does-ruff-compare-to-flake8) for the complete
-   list of supported plugins.)
+    codes from unsupported plugins. (See the
+    [documentation](https://beta.ruff.rs/docs/faq/#how-does-ruff-compare-to-flake8) for the complete
+    list of supported plugins.)
 
 ## License
 

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.278"
+version = "0.0.280"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -19,7 +19,7 @@ ruff_cache = { path = "../ruff_cache" }
 ruff_diagnostics = { path = "../ruff_diagnostics", features = ["serde"] }
 ruff_index = { path = "../ruff_index" }
 ruff_macros = { path = "../ruff_macros" }
-ruff_python_whitespace = { path = "../ruff_python_whitespace" }
+ruff_python_trivia = { path = "../ruff_python_trivia" }
 ruff_python_ast = { path = "../ruff_python_ast", features = ["serde"] }
 ruff_python_semantic = { path = "../ruff_python_semantic" }
 ruff_python_stdlib = { path = "../ruff_python_stdlib" }
@@ -78,6 +78,7 @@ toml = { workspace = true }
 typed-arena = { version = "2.0.2" }
 unicode-width = { version = "0.1.10" }
 unicode_names2 = { version = "0.6.0", git = "https://github.com/youknowone/unicode_names2.git", rev = "4ce16aa85cbcdd9cc830410f1a72ef9a235f2fde" }
+wsl = { version = "0.1.0" }
 
 [dev-dependencies]
 insta = { workspace = true }
@@ -85,6 +86,7 @@ pretty_assertions = "1.3.0"
 test-case = { workspace = true }
 # Disable colored output in tests
 colored = { workspace = true, features = ["no-color"] }
+tempfile = "3.6.0"
 
 [features]
 default = []

crates/ruff/resources/test/fixtures/flake8_annotations/annotation_presence.py

@@ -1,4 +1,4 @@
-from typing import Any, Type
+from typing import Annotated, Any, Optional, Type, Union
 from typing_extensions import override
 
 # Error
@@ -95,27 +95,27 @@ class Foo:
     def foo(self: "Foo", a: int, *params: str, **options: Any) -> int:
         pass
 
-    # ANN401
+    # OK
     @override
     def foo(self: "Foo", a: Any, *params: str, **options: str) -> int:
         pass
 
-    # ANN401
+    # OK
     @override
     def foo(self: "Foo", a: int, *params: str, **options: str) -> Any:
         pass
 
-    # ANN401
+    # OK
     @override
     def foo(self: "Foo", a: int, *params: Any, **options: Any) -> int:
         pass
 
-    # ANN401
+    # OK
     @override
     def foo(self: "Foo", a: int, *params: Any, **options: str) -> int:
         pass
 
-    # ANN401
+    # OK
     @override
     def foo(self: "Foo", a: int, *params: str, **options: Any) -> int:
         pass
@@ -137,3 +137,18 @@ class Foo:
 
 # OK
 def f(*args: *tuple[int]) -> None: ...
+def f(a: object) -> None: ...
+def f(a: str | bytes) -> None: ...
+def f(a: Union[str, bytes]) -> None: ...
+def f(a: Optional[str]) -> None: ...
+def f(a: Annotated[str, ...]) -> None: ...
+def f(a: "Union[str, bytes]") -> None: ...
+def f(a: int + int) -> None: ...
+
+# ANN401
+def f(a: Any | int) -> None: ...
+def f(a: int | Any) -> None: ...
+def f(a: Union[str, bytes, Any]) -> None: ...
+def f(a: Optional[Any]) -> None: ...
+def f(a: Annotated[Any, ...]) -> None: ...
+def f(a: "Union[str, bytes, Any]") -> None: ...

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

@@ -177,6 +177,9 @@ def str_okay(value=str("foo")):
 def bool_okay(value=bool("bar")):
     pass
 
+# Allow immutable bytes() value
+def bytes_okay(value=bytes(1)):
+    pass
 
 # Allow immutable int() value
 def int_okay(value=int("12")):

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

@@ -97,3 +97,10 @@ def f():
 # variable name).
 for line_ in range(self.header_lines):
     fp.readline()
+
+# Regression test: visitor didn't walk the elif test
+for key, value in current_crawler_tags.items():
+    if key:
+        pass
+    elif wanted_tag_value != value:
+        pass

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

@@ -14,9 +14,10 @@ except AssertionError:
 except Exception as err:
     assert err
     raise Exception("No cause here...")
-except BaseException as base_err:
-    # Might use this instead of bare raise with the `.with_traceback()` method
-    raise base_err
+except BaseException as err:
+    raise err
+except BaseException as err:
+    raise some_other_err
 finally:
     raise Exception("Nothing to chain from, so no warning here")
 

crates/ruff/resources/test/fixtures/flake8_comprehensions/C414.py

@@ -12,7 +12,8 @@ set(reversed(x))
 sorted(list(x))
 sorted(tuple(x))
 sorted(sorted(x))
-sorted(sorted(x, key=lambda y: y))
+sorted(sorted(x, key=foo, reverse=False), reverse=False, key=foo)
+sorted(sorted(x, reverse=True), reverse=True)
 sorted(reversed(x))
 sorted(list(x), key=lambda y: y)
 tuple(
@@ -21,3 +22,9 @@ tuple(
         "o"]
     )
 )
+
+# Nested sorts with differing keyword arguments. Not flagged.
+sorted(sorted(x, key=lambda y: y))
+sorted(sorted(x, key=lambda y: y), key=lambda x: x)
+sorted(sorted(x), reverse=True)
+sorted(sorted(x, reverse=False), reverse=True)

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

@@ -59,7 +59,6 @@ field18: typing.Union[
     ],
 ]  # 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
 
@@ -71,3 +70,7 @@ 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]

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

@@ -0,0 +1,14 @@
+var: int
+a = var  # OK
+
+b = c = int  # OK
+
+a.b = int  # OK
+
+d, e = int, str  # OK
+
+f, g, h = int, str, TypeVar("T")  # OK
+
+i: TypeAlias = int | str  # OK
+
+j: TypeAlias = int  # OK

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

@@ -0,0 +1,14 @@
+var: int
+a = var  # OK
+
+b = c = int  # PYI017
+
+a.b = int  # PYI017
+
+d, e = int, str  # PYI017
+
+f, g, h = int, str, TypeVar("T")  # PYI017
+
+i: TypeAlias = int | str  # OK
+
+j: TypeAlias = int  # OK

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

@@ -0,0 +1,19 @@
+import typing
+from typing import TypeAlias, Literal, Any
+
+NewAny = Any
+OptionalStr = typing.Optional[str]
+Foo = Literal["foo"]
+IntOrStr = int | str
+AliasNone = None
+
+NewAny: typing.TypeAlias = Any
+OptionalStr: TypeAlias = typing.Optional[str]
+Foo: typing.TypeAlias = Literal["foo"]
+IntOrStr: TypeAlias = int | str
+IntOrFloat: Foo = int | float
+AliasNone: typing.TypeAlias = None
+
+# these are ok
+VarAlias = str
+AliasFoo = Foo

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

@@ -0,0 +1,18 @@
+from typing import Literal, Any
+
+NewAny = Any
+OptionalStr = typing.Optional[str]
+Foo = Literal["foo"]
+IntOrStr = int | str
+AliasNone = None
+
+NewAny: typing.TypeAlias = Any
+OptionalStr: TypeAlias = typing.Optional[str]
+Foo: typing.TypeAlias = Literal["foo"]
+IntOrStr: TypeAlias = int | str
+IntOrFloat: Foo = int | float
+AliasNone: typing.TypeAlias = None
+
+# these are ok
+VarAlias = str
+AliasFoo = Foo

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

@@ -0,0 +1,75 @@
+import builtins
+import types
+import typing
+from collections.abc import Awaitable
+from types import TracebackType
+from typing import Any, Type
+
+import _typeshed
+import typing_extensions
+from _typeshed import Unused
+
+class GoodOne:
+    def __exit__(self, *args: object) -> None: ...
+    async def __aexit__(self, *args) -> str: ...
+
+class GoodTwo:
+    def __exit__(self, typ: type[builtins.BaseException] | None, *args: builtins.object) -> bool | None: ...
+    async def __aexit__(self, /, typ: Type[BaseException] | None, *args: object, **kwargs) -> bool: ...
+
+class GoodThree:
+    def __exit__(self, __typ: typing.Type[BaseException] | None, exc: BaseException | None, *args: object) -> None: ...
+    async def __aexit__(self, typ: typing_extensions.Type[BaseException] | None, __exc: BaseException | None, *args: object) -> None: ...
+
+class GoodFour:
+    def __exit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None) -> None: ...
+    async def __aexit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None, *args: list[None]) -> None: ...
+
+class GoodFive:
+    def __exit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None, weird_extra_arg: int = ..., *args: int, **kwargs: str) -> None: ...
+    async def __aexit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None) -> Awaitable[None]: ...
+
+class GoodSix:
+    def __exit__(self, typ: object, exc: builtins.object, tb: object) -> None: ...
+    async def __aexit__(self, typ: object, exc: object, tb: builtins.object) -> None: ...
+
+class GoodSeven:
+    def __exit__(self, *args: Unused) -> bool: ...
+    async def __aexit__(self, typ: Type[BaseException] | None, *args: _typeshed.Unused) -> Awaitable[None]: ...
+
+class GoodEight:
+    def __exit__(self, __typ: typing.Type[BaseException] | None, exc: BaseException | None, *args: _typeshed.Unused) -> bool: ...
+    async def __aexit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None, weird_extra_arg: int = ..., *args: Unused, **kwargs: Unused) -> Awaitable[None]: ...
+
+class GoodNine:
+    def __exit__(self, __typ: typing.Union[typing.Type[BaseException] , None], exc: typing.Union[BaseException , None], *args: _typeshed.Unused) -> bool: ...
+    async def __aexit__(self, typ: typing.Union[typing.Type[BaseException], None], exc: typing.Union[BaseException , None], tb: typing.Union[TracebackType , None], weird_extra_arg: int = ..., *args: Unused, **kwargs: Unused) -> Awaitable[None]: ...
+
+class GoodTen:
+    def __exit__(self, __typ: typing.Optional[typing.Type[BaseException]], exc: typing.Optional[BaseException], *args: _typeshed.Unused) -> bool: ...
+    async def __aexit__(self, typ: typing.Optional[typing.Type[BaseException]], exc: typing.Optional[BaseException], tb: typing.Optional[TracebackType], weird_extra_arg: int = ..., *args: Unused, **kwargs: Unused) -> Awaitable[None]: ...
+
+
+class BadOne:
+    def __exit__(self, *args: Any) -> None: ... # PYI036: Bad star-args annotation
+    async def __aexit__(self) -> None: ... # PYI036: Missing args
+
+class BadTwo:
+    def __exit__(self, typ, exc, tb, weird_extra_arg) -> None: ... # PYI036: Extra arg must have default
+    async def __aexit__(self, typ, exc, tb, *, weird_extra_arg) -> None: ...# PYI036: Extra arg must have default
+
+class BadThree:
+    def __exit__(self, typ: type[BaseException], exc: BaseException | None, tb: TracebackType | None) -> None: ... # PYI036: First arg has bad annotation
+    async def __aexit__(self, __typ: type[BaseException] | None, __exc: BaseException, __tb: TracebackType) -> bool | None: ... # PYI036: Second arg has bad annotation
+
+class BadFour:
+    def __exit__(self, typ: typing.Optional[type[BaseException]], exc: typing.Union[BaseException, None], tb: TracebackType) -> None: ... # PYI036: Third arg has bad annotation
+    async def __aexit__(self, __typ: type[BaseException] | None, __exc: BaseException | None, __tb: typing.Union[TracebackType, None, int]) -> bool | None: ... # PYI036: Third arg has bad annotation
+
+class BadFive:
+    def __exit__(self, typ: BaseException | None, *args: list[str]) -> bool: ... # PYI036: Bad star-args annotation
+    async def __aexit__(self, /, typ: type[BaseException] | None, *args: Any) -> Awaitable[None]: ... # PYI036: Bad star-args annotation
+
+class BadSix:
+    def __exit__(self, typ, exc, tb, weird_extra_arg, extra_arg2 = None) -> None: ... # PYI036: Extra arg must have default
+    async def __aexit__(self, typ, exc, tb, *, weird_extra_arg) -> None: ... # PYI036: kwargs must have default

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

@@ -0,0 +1,75 @@
+import builtins
+import types
+import typing
+from collections.abc import Awaitable
+from types import TracebackType
+from typing import Any, Type
+
+import _typeshed
+import typing_extensions
+from _typeshed import Unused
+
+class GoodOne:
+    def __exit__(self, *args: object) -> None: ...
+    async def __aexit__(self, *args) -> str: ...
+
+class GoodTwo:
+    def __exit__(self, typ: type[builtins.BaseException] | None, *args: builtins.object) -> bool | None: ...
+    async def __aexit__(self, /, typ: Type[BaseException] | None, *args: object, **kwargs) -> bool: ...
+
+class GoodThree:
+    def __exit__(self, __typ: typing.Type[BaseException] | None, exc: BaseException | None, *args: object) -> None: ...
+    async def __aexit__(self, typ: typing_extensions.Type[BaseException] | None, __exc: BaseException | None, *args: object) -> None: ...
+
+class GoodFour:
+    def __exit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None) -> None: ...
+    async def __aexit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None, *args: list[None]) -> None: ...
+
+class GoodFive:
+    def __exit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None, weird_extra_arg: int = ..., *args: int, **kwargs: str) -> None: ...
+    async def __aexit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None) -> Awaitable[None]: ...
+
+class GoodSix:
+    def __exit__(self, typ: object, exc: builtins.object, tb: object) -> None: ...
+    async def __aexit__(self, typ: object, exc: object, tb: builtins.object) -> None: ...
+
+class GoodSeven:
+    def __exit__(self, *args: Unused) -> bool: ...
+    async def __aexit__(self, typ: Type[BaseException] | None, *args: _typeshed.Unused) -> Awaitable[None]: ...
+
+class GoodEight:
+    def __exit__(self, __typ: typing.Type[BaseException] | None, exc: BaseException | None, *args: _typeshed.Unused) -> bool: ...
+    async def __aexit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None, weird_extra_arg: int = ..., *args: Unused, **kwargs: Unused) -> Awaitable[None]: ...
+
+class GoodNine:
+    def __exit__(self, __typ: typing.Union[typing.Type[BaseException] , None], exc: typing.Union[BaseException , None], *args: _typeshed.Unused) -> bool: ...
+    async def __aexit__(self, typ: typing.Union[typing.Type[BaseException], None], exc: typing.Union[BaseException , None], tb: typing.Union[TracebackType , None], weird_extra_arg: int = ..., *args: Unused, **kwargs: Unused) -> Awaitable[None]: ...
+
+class GoodTen:
+    def __exit__(self, __typ: typing.Optional[typing.Type[BaseException]], exc: typing.Optional[BaseException], *args: _typeshed.Unused) -> bool: ...
+    async def __aexit__(self, typ: typing.Optional[typing.Type[BaseException]], exc: typing.Optional[BaseException], tb: typing.Optional[TracebackType], weird_extra_arg: int = ..., *args: Unused, **kwargs: Unused) -> Awaitable[None]: ...
+
+
+class BadOne:
+    def __exit__(self, *args: Any) -> None: ... # PYI036: Bad star-args annotation
+    async def __aexit__(self) -> None: ... # PYI036: Missing args
+
+class BadTwo:
+    def __exit__(self, typ, exc, tb, weird_extra_arg) -> None: ... # PYI036: Extra arg must have default
+    async def __aexit__(self, typ, exc, tb, *, weird_extra_arg1, weird_extra_arg2) -> None: ...# PYI036: kwargs must have default
+
+class BadThree:
+    def __exit__(self, typ: type[BaseException], exc: BaseException | None, tb: TracebackType | None) -> None: ... # PYI036: First arg has bad annotation
+    async def __aexit__(self, __typ: type[BaseException] | None, __exc: BaseException, __tb: TracebackType) -> bool | None: ... # PYI036: Second arg has bad annotation
+
+class BadFour:
+    def __exit__(self, typ: typing.Optional[type[BaseException]], exc: typing.Union[BaseException, None], tb: TracebackType) -> None: ... # PYI036: Third arg has bad annotation
+    async def __aexit__(self, __typ: type[BaseException] | None, __exc: BaseException | None, __tb: typing.Union[TracebackType, None, int]) -> bool | None: ... # PYI036: Third arg has bad annotation
+
+class BadFive:
+    def __exit__(self, typ: BaseException | None, *args: list[str]) -> bool: ... # PYI036: Bad star-args annotation
+    async def __aexit__(self, /, typ: type[BaseException] | None, *args: Any) -> Awaitable[None]: ... # PYI036: Bad star-args annotation
+
+class BadSix:
+    def __exit__(self, typ, exc, tb, weird_extra_arg, extra_arg2 = None) -> None: ... # PYI036: Extra arg must have default
+    async def __aexit__(self, typ, exc, tb, *, weird_extra_arg) -> None: ... # PYI036: kwargs must have default

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

@@ -0,0 +1,47 @@
+from typing import (
+    Union,
+)
+
+from typing_extensions import (
+    TypeAlias,
+)
+
+TA0: TypeAlias = int
+TA1: TypeAlias = int | float | bool
+TA2: TypeAlias = Union[int, float, bool]
+
+
+def good1(arg: int) -> int | bool:
+    ...
+
+
+def good2(arg: int, arg2: int | bool) -> None:
+    ...
+
+
+def f0(arg1: float | int) -> None:
+    ...
+
+
+def f1(arg1: float, *, arg2: float | list[str] | type[bool] | complex) -> None:
+    ...
+
+
+def f2(arg1: int, /, arg2: int | int | float) -> None:
+    ...
+
+
+def f3(arg1: int, *args: Union[int | int | float]) -> None:
+    ...
+
+
+async def f4(**kwargs: int | int | float) -> None:
+    ...
+
+
+class Foo:
+    def good(self, arg: int) -> None:
+        ...
+
+    def bad(self, arg: int | float | complex) -> None:
+        ...

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

@@ -0,0 +1,39 @@
+from typing import (
+    Union,
+)
+
+from typing_extensions import (
+    TypeAlias,
+)
+
+# Type aliases not flagged
+TA0: TypeAlias = int
+TA1: TypeAlias = int | float | bool
+TA2: TypeAlias = Union[int, float, bool]
+
+
+def good1(arg: int) -> int | bool: ...
+
+
+def good2(arg: int, arg2: int | bool) -> None: ...
+
+
+def f0(arg1: float | int) -> None: ...  # PYI041
+
+
+def f1(arg1: float, *, arg2: float | list[str] | type[bool] | complex) -> None: ...  # PYI041
+
+
+def f2(arg1: int, /, arg2: int | int | float) -> None: ...  # PYI041
+
+
+def f3(arg1: int, *args: Union[int | int | float]) -> None: ...  # PYI041
+
+
+async def f4(**kwargs: int | int | float) -> None: ...  # PYI041
+
+
+class Foo:
+    def good(self, arg: int) -> None: ...
+
+    def bad(self, arg: int | float | complex) -> None: ...  # PYI041

crates/ruff/resources/test/fixtures/flake8_simplify/SIM102.py

@@ -100,6 +100,14 @@ if node.module0123456789:
     ):
         print("Bad module!")
 
+# SIM102
+# Regression test for https://github.com/apache/airflow/blob/145b16caaa43f0c42bffd97344df916c602cddde/airflow/configuration.py#L1161
+if a:
+    if b:
+        if c:
+            print("if")
+elif d:
+    print("elif")
 
 # OK
 if a:

crates/ruff/resources/test/fixtures/flake8_simplify/SIM108.py

@@ -23,7 +23,7 @@ elif a:
 else:
     b = 2
 
-# OK (false negative)
+# SIM108
 if True:
     pass
 else:

crates/ruff/resources/test/fixtures/flake8_simplify/SIM114.py

@@ -94,3 +94,10 @@ if result.eofs == "F":
     errors = 1
 else:
     errors = 1
+
+if a:
+    # Ignore branches with diverging comments because it means we're repeating
+    # the bodies because we have different reasons for each branch
+    x = 1
+elif c:
+    x = 1

crates/ruff/resources/test/fixtures/flake8_simplify/SIM116.py

@@ -84,3 +84,15 @@ elif func_name == "remove":
     return "D"
 elif func_name == "move":
     return "MV"
+
+# OK
+def no_return_in_else(platform):
+    if platform == "linux":
+        return "auditwheel repair -w {dest_dir} {wheel}"
+    elif platform == "macos":
+        return "delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}"
+    elif platform == "windows":
+        return ""
+    else:
+        msg = f"Unknown platform: {platform!r}"
+        raise ValueError(msg)

crates/ruff/resources/test/fixtures/flake8_simplify/SIM401.py

@@ -38,6 +38,15 @@ if key in a_dict:
 else:
     vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789"
 
+# SIM401
+if foo():
+    pass
+else:
+    if key in a_dict:
+        vars[idx] = a_dict[key]
+    else:
+        vars[idx] = "default"
+
 ###
 # Negative cases
 ###
@@ -105,12 +114,3 @@ elif key in a_dict:
     vars[idx] = a_dict[key]
 else:
     vars[idx] = "default"
-
-# OK (false negative for nested else)
-if foo():
-    pass
-else:
-    if key in a_dict:
-        vars[idx] = a_dict[key]
-    else:
-        vars[idx] = "default"

crates/ruff/resources/test/fixtures/flake8_slots/SLOT000.py

@@ -4,3 +4,10 @@ class Bad(str):  # SLOT000
 
 class Good(str):  # Ok
     __slots__ = ["foo"]
+
+
+from enum import Enum
+
+
+class Fine(str, Enum):  # Ok
+    __slots__ = ["foo"]

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

@@ -0,0 +1,14 @@
+from pathlib import Path, PurePath
+from pathlib import Path as pth
+
+# match
+_ = Path(".")
+_ = pth(".")
+_ = PurePath(".")
+
+# no match
+_ = Path()
+print(".")
+Path("file.txt")
+Path(".", "folder")
+PurePath(".", "folder")

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

@@ -0,0 +1,14 @@
+import os.path
+from pathlib import Path
+from os.path import getsize
+
+
+os.path.getsize("filename")
+os.path.getsize(b"filename")
+os.path.getsize(Path("filename"))
+os.path.getsize(__file__)
+
+getsize("filename")
+getsize(b"filename")
+getsize(Path("filename"))
+getsize(__file__)

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

@@ -0,0 +1,12 @@
+import os.path
+from pathlib import Path
+from os.path import getatime
+
+os.path.getatime("filename")
+os.path.getatime(b"filename")
+os.path.getatime(Path("filename"))
+
+
+getatime("filename")
+getatime(b"filename")
+getatime(Path("filename"))

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

@@ -0,0 +1,13 @@
+import os.path
+from pathlib import Path
+from os.path import getmtime
+
+
+os.path.getmtime("filename")
+os.path.getmtime(b"filename")
+os.path.getmtime(Path("filename"))
+
+
+getmtime("filename")
+getmtime(b"filename")
+getmtime(Path("filename"))

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

@@ -0,0 +1,12 @@
+import os.path
+from pathlib import Path
+from os.path import getctime
+
+
+os.path.getctime("filename")
+os.path.getctime(b"filename")
+os.path.getctime(Path("filename"))
+
+getctime("filename")
+getctime(b"filename")
+getctime(Path("filename"))

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

@@ -2,6 +2,7 @@ import os
 import os.path
 
 p = "/foo"
+q = "bar"
 
 a = os.path.abspath(p)
 aa = os.chmod(p)
@@ -21,7 +22,9 @@ bbbbb = os.path.islink(p)
 os.readlink(p)
 os.stat(p)
 os.path.isabs(p)
-os.path.join(p)
+os.path.join(p, q)
+os.sep.join([p, q])
+os.sep.join((p, q))
 os.path.basename(p)
 os.path.dirname(p)
 os.path.samefile(p)

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

@@ -2,6 +2,7 @@ import os as foo
 import os.path as foo_p
 
 p = "/foo"
+q = "bar"
 
 a = foo_p.abspath(p)
 aa = foo.chmod(p)
@@ -21,7 +22,9 @@ bbbbb = foo_p.islink(p)
 foo.readlink(p)
 foo.stat(p)
 foo_p.isabs(p)
-foo_p.join(p)
+foo_p.join(p, q)
+foo.sep.join([p, q])
+foo.sep.join((p, q))
 foo_p.basename(p)
 foo_p.dirname(p)
 foo_p.samefile(p)

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

@@ -1,9 +1,10 @@
-from os import chmod, mkdir, makedirs, rename, replace, rmdir
+from os import chmod, mkdir, makedirs, rename, replace, rmdir, sep
 from os import remove, unlink, getcwd, readlink, stat
 from os.path import abspath, exists, expanduser, isdir, isfile, islink
 from os.path import isabs, join, basename, dirname, samefile, splitext
 
 p = "/foo"
+q = "bar"
 
 a = abspath(p)
 aa = chmod(p)
@@ -23,7 +24,9 @@ bbbbb = islink(p)
 readlink(p)
 stat(p)
 isabs(p)
-join(p)
+join(p, q)
+sep.join((p, q))
+sep.join([p, q])
 basename(p)
 dirname(p)
 samefile(p)

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

@@ -1,4 +1,4 @@
-from os import chmod as xchmod, mkdir as xmkdir
+from os import chmod as xchmod, mkdir as xmkdir, sep as s
 from os import makedirs as xmakedirs, rename as xrename, replace as xreplace
 from os import rmdir as xrmdir, remove as xremove, unlink as xunlink
 from os import getcwd as xgetcwd, readlink as xreadlink, stat as xstat
@@ -9,6 +9,7 @@ from os.path import join as xjoin, basename as xbasename, dirname as xdirname
 from os.path import samefile as xsamefile, splitext as xsplitext
 
 p = "/foo"
+q = "bar"
 
 a = xabspath(p)
 aa = xchmod(p)
@@ -28,7 +29,9 @@ bbbbb = xislink(p)
 xreadlink(p)
 xstat(p)
 xisabs(p)
-xjoin(p)
+xjoin(p, q)
+s.join((p, q))
+s.join([p, q])
 xbasename(p)
 xdirname(p)
 xsamefile(p)

crates/ruff/resources/test/fixtures/isort/if_elif_else.py

@@ -0,0 +1,7 @@
+if "sdist" in cmds:
+    _sdist = cmds["sdist"]
+elif "setuptools" in sys.modules:
+    from setuptools.command.sdist import sdist as _sdist
+else:
+    from setuptools.command.sdist import sdist as _sdist
+    from distutils.command.sdist import sdist as _sdist

crates/ruff/resources/test/fixtures/isort/match_case.py

@@ -0,0 +1,7 @@
+match 1:
+    case 1:
+        import sys
+        import os
+    case 2:
+        import collections
+        import abc

crates/ruff/resources/test/fixtures/pandas_vet/PD101.py

@@ -0,0 +1,27 @@
+import pandas as pd
+
+
+data = pd.Series(range(1000))
+
+# PD101
+data.nunique() <= 1
+data.nunique(dropna=True) <= 1
+data.nunique(dropna=False) <= 1
+data.nunique() == 1
+data.nunique(dropna=True) == 1
+data.nunique(dropna=False) == 1
+data.nunique() != 1
+data.nunique(dropna=True) != 1
+data.nunique(dropna=False) != 1
+data.nunique() > 1
+data.dropna().nunique() == 1
+data[data.notnull()].nunique() == 1
+
+# No violation of this rule
+data.nunique() == 0  # empty
+data.nunique() >= 1  # not-empty
+data.nunique() < 1  # empty
+data.nunique() == 2  # not constant
+data.unique() == 1  # not `nunique`
+
+{"hello": "world"}.nunique() == 1  # no pd.Series

crates/ruff/resources/test/fixtures/pandas_vet/pandas_use_of_dot_read_table.py

@@ -0,0 +1,20 @@
+import pandas as pd
+
+# Errors.
+df = pd.read_table("data.csv", sep=",")
+df = pd.read_table("data.csv", sep=",", header=0)
+filename = "data.csv"
+df = pd.read_table(filename, sep=",")
+df = pd.read_table(filename, sep=",", header=0)
+
+# Non-errors.
+df = pd.read_csv("data.csv")
+df = pd.read_table("data.tsv")
+df = pd.read_table("data.tsv", sep="\t")
+df = pd.read_table("data.tsv", sep=",,")
+df = pd.read_table("data.tsv", sep=", ")
+df = pd.read_table("data.tsv", sep=" ,")
+df = pd.read_table("data.tsv", sep=" , ")
+not_pd.read_table("data.csv", sep=",")
+data = read_table("data.csv", sep=",")
+data = read_table

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

@@ -1,71 +1,101 @@
 some_dict = {"a": 12, "b": 32, "c": 44}
 
-for _, value in some_dict.items():  # PERF102
-    print(value)
+
+def f():
+    for _, value in some_dict.items():  # PERF102
+        print(value)
 
 
-for key, _ in some_dict.items():  # PERF102
-    print(key)
+def f():
+    for key, _ in some_dict.items():  # PERF102
+        print(key)
 
 
-for weird_arg_name, _ in some_dict.items():  # PERF102
-    print(weird_arg_name)
+def f():
+    for weird_arg_name, _ in some_dict.items():  # PERF102
+        print(weird_arg_name)
 
 
-for name, (_, _) in some_dict.items():  # PERF102
-    pass
+def f():
+    for name, (_, _) in some_dict.items():  # PERF102
+        print(name)
 
 
-for name, (value1, _) in some_dict.items():  # OK
-    pass
+def f():
+    for name, (value1, _) in some_dict.items():  # OK
+        print(name, value1)
 
 
-for (key1, _), (_, _) in some_dict.items():  # PERF102
-    pass
+def f():
+    for (key1, _), (_, _) in some_dict.items():  # PERF102
+        print(key1)
 
 
-for (_, (_, _)), (value, _) in some_dict.items():  # PERF102
-    pass
+def f():
+    for (_, (_, _)), (value, _) in some_dict.items():  # PERF102
+        print(value)
 
 
-for (_, key2), (value1, _) in some_dict.items():  # OK
-    pass
+def f():
+    for (_, key2), (value1, _) in some_dict.items():  # OK
+        print(key2, value1)
 
 
-for ((_, key2), (value1, _)) in some_dict.items():  # OK
-    pass
+def f():
+    for ((_, key2), (value1, _)) in some_dict.items():  # OK
+        print(key2, value1)
 
 
-for ((_, key2), (_, _)) in some_dict.items():  # PERF102
-    pass
+def f():
+    for ((_, key2), (_, _)) in some_dict.items():  # PERF102
+        print(key2)
 
 
-for (_, _, _, variants), (r_language, _, _, _) in some_dict.items():  # OK
-    pass
+def f():
+    for (_, _, _, variants), (r_language, _, _, _) in some_dict.items():  # OK
+        print(variants, r_language)
 
 
-for (_, _, (_, variants)), (_, (_, (r_language, _))) in some_dict.items():  # OK
-    pass
+def f():
+    for (_, _, (_, variants)), (_, (_, (r_language, _))) in some_dict.items():  # OK
+        print(variants, r_language)
 
 
-for key, value in some_dict.items():  # OK
-    print(key, value)
+def f():
+    for key, value in some_dict.items():  # OK
+        print(key, value)
 
 
-for _, value in some_dict.items(12):  # OK
-    print(value)
+def f():
+    for _, value in some_dict.items(12):  # OK
+        print(value)
 
 
-for key in some_dict.keys():  # OK
-    print(key)
+def f():
+    for key in some_dict.keys():  # OK
+        print(key)
 
 
-for value in some_dict.values():  # OK
-    print(value)
+def f():
+    for value in some_dict.values():  # OK
+        print(value)
 
 
-for name, (_, _) in (some_function()).items():  # PERF102
-    pass
+def f():
+    for name, (_, _) in (some_function()).items():  # PERF102
+        print(name)
 
-for name, (_, _) in (some_function().some_attribute).items():  # PERF102
-    pass
+
+def f():
+    for name, (_, _) in (some_function().some_attribute).items():  # PERF102
+        print(name)
+
+
+def f():
+    for name, unused_value in some_dict.items():  # PERF102
+        print(name)
+
+
+def f():
+    for unused_name, value in some_dict.items():  # PERF102
+        print(value)

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

@@ -36,3 +36,4 @@ if (True) == TrueElement or x == TrueElement:
 assert (not foo) in bar
 assert {"x": not foo} in bar
 assert [42, not foo] in bar
+assert not (re.search(r"^.:\\Users\\[^\\]*\\Downloads\\.*") is None)

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

@@ -36,3 +36,4 @@ if (True) == TrueElement or x == TrueElement:
 assert (not foo) in bar
 assert {"x": not foo} in bar
 assert [42, not foo] in bar
+assert not (re.search(r"^.:\\Users\\[^\\]*\\Downloads\\.*") is None)

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

@@ -1,6 +1,11 @@
 if (1, 2):
     pass
 
+if (3, 4):
+    pass
+elif foo:
+    pass
+
 for _ in range(5):
     if True:
         pass

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

@@ -0,0 +1,15 @@
+# Regression test for branch detection from
+# https://github.com/pypa/build/blob/5800521541e5e749d4429617420d1ef8cdb40b46/src/build/_importlib.py
+import sys
+
+if sys.version_info < (3, 8):
+    import importlib_metadata as metadata
+elif sys.version_info < (3, 9, 10) or (3, 10, 0) <= sys.version_info < (3, 10, 2):
+    try:
+        import importlib_metadata as metadata
+    except ModuleNotFoundError:
+        from importlib import metadata
+else:
+    from importlib import metadata
+
+__all__ = ["metadata"]

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

@@ -0,0 +1,6 @@
+class Class:
+    def func(self):
+        pass
+
+    def func(self):
+        pass

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

@@ -25,3 +25,17 @@ def dec(x):
 def f():
     dec = 1
     return dec
+
+
+class Class:
+    def f(self):
+        print(my_var)
+        my_var = 1
+
+
+class Class:
+    my_var = 0
+
+    def f(self):
+        print(my_var)
+        my_var = 1

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

@@ -47,3 +47,17 @@ def not_ok1():
             pass
         else:
             pass
+
+
+# Regression test for https://github.com/apache/airflow/blob/f1e1cdcc3b2826e68ba133f350300b5065bbca33/airflow/models/dag.py#L1737
+def not_ok2():
+    if True:
+        print(1)
+    elif True:
+        print(2)
+    else:
+        if True:
+            print(3)
+        else:
+            print(4)
+

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

@@ -80,3 +80,8 @@ def multiple_assignment():
     global CONSTANT  # [global-statement]
     CONSTANT = 1
     CONSTANT = 2
+
+
+def no_assignment():
+    """Shouldn't warn"""
+    global CONSTANT

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

@@ -0,0 +1,34 @@
+# Errors.
+foo == "a" or foo == "b"
+
+foo != "a" and foo != "b"
+
+foo == "a" or foo == "b" or foo == "c"
+
+foo != "a" and foo != "b" and foo != "c"
+
+foo == a or foo == "b" or foo == 3  # Mixed types.
+
+# False negatives (the current implementation doesn't support Yoda conditions).
+"a" == foo or "b" == foo or "c" == foo
+
+"a" != foo and "b" != foo and "c" != foo
+
+"a" == foo or foo == "b" or "c" == foo
+
+# OK
+foo == "a" and foo == "b" and foo == "c"  # `and` mixed with `==`.
+
+foo != "a" or foo != "b" or foo != "c"  # `or` mixed with `!=`.
+
+foo == a or foo == b() or foo == c  # Call expression.
+
+foo != a or foo() != b or foo != c  # Call expression.
+
+foo in {"a", "b", "c"}  # Uses membership test already.
+
+foo not in {"a", "b", "c"}  # Uses membership test already.
+
+foo == "a"  # Single comparison.
+
+foo != "a"  # Single comparison.

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

@@ -27,6 +27,14 @@ def f(x: typing.Union[(str, int), float]) -> None:
     ...
 
 
+def f(x: typing.Union[(int,)]) -> None:
+    ...
+
+
+def f(x: typing.Union[()]) -> None:
+    ...
+
+
 def f(x: "Union[str, int, Union[float, bytes]]") -> None:
     ...
 

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

@@ -4,23 +4,9 @@ import typing
 # with complex annotations
 MyType = NamedTuple("MyType", [("a", int), ("b", tuple[str, ...])])
 
-# with default values as list
-MyType = NamedTuple(
-    "MyType",
-    [("a", int), ("b", str), ("c", list[bool])],
-    defaults=["foo", [True]],
-)
-
 # with namespace
 MyType = typing.NamedTuple("MyType", [("a", int), ("b", str)])
 
-# too many default values (OK)
-MyType = NamedTuple(
-    "MyType",
-    [("a", int), ("b", str)],
-    defaults=[1, "bar", "baz"],
-)
-
 # invalid identifiers (OK)
 MyType = NamedTuple("MyType", [("x-y", int), ("b", tuple[str, ...])])
 
@@ -29,3 +15,10 @@ MyType = typing.NamedTuple("MyType")
 
 # empty fields
 MyType = typing.NamedTuple("MyType", [])
+
+# keywords
+MyType = typing.NamedTuple("MyType", a=int, b=tuple[str, ...])
+
+# unfixable
+MyType = typing.NamedTuple("MyType", [("a", int)], [("b", str)])
+MyType = typing.NamedTuple("MyType", [("a", int)], b=str)

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

@@ -62,6 +62,16 @@ print("foo {} ".format(x))
     1111111111111111111111111111111111111111111111111111111111111111111111111,
 )
 
+"""
+{}
+""".format(1)
+
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = """
+{}
+""".format(
+    111111
+)
+
 ###
 # Non-errors
 ###
@@ -99,6 +109,21 @@ r'"\N{snowman} {}".format(a)'
     11111111111111111111111111111111111111111111111111111111111111111111111111,
 )
 
+"""
+{}
+{}
+{}
+""".format(
+1,
+2,
+111111111111111111111111111111111111111111111111111111111111111111111111111111111111111,
+)
+
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = """{}
+""".format(
+    111111
+)
+
 async def c():
     return "{}".format(await 3)
 

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

@@ -7,20 +7,20 @@ if True:
 
 if True:
     if foo:
-        pass
+        print()
     elif sys.version_info < (3, 3):
         cmd = [sys.executable, "-m", "test.regrtest"]
 
 if True:
     if foo:
-        pass
+        print()
     elif sys.version_info < (3, 3):
         cmd = [sys.executable, "-m", "test.regrtest"]
     elif foo:
         cmd = [sys.executable, "-m", "test", "-j0"]
 
     if foo:
-        pass
+        print()
     elif sys.version_info < (3, 3):
         cmd = [sys.executable, "-m", "test.regrtest"]
 
@@ -28,7 +28,7 @@ if True:
         cmd = [sys.executable, "-m", "test.regrtest"]
 
     if foo:
-        pass
+        print()
     elif sys.version_info < (3, 3):
         cmd = [sys.executable, "-m", "test.regrtest"]
     else:

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

@@ -1,3 +1,5 @@
+"""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

@@ -0,0 +1,108 @@
+"""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/ruff/RUF013_0.py

@@ -48,6 +48,10 @@ def f(arg: typing.Optional[int] = None):
 # Union
 
 
+def f(arg: Union[None] = None):
+    pass
+
+
 def f(arg: Union[None, int] = None):
     pass
 
@@ -68,6 +72,10 @@ def f(arg: Union = None):  # RUF013
     pass
 
 
+def f(arg: Union[int] = None):  # RUF013
+    pass
+
+
 def f(arg: Union[int, str] = None):  # RUF013
     pass
 
@@ -106,10 +114,18 @@ def f(arg: None = None):
     pass
 
 
+def f(arg: Literal[None] = None):
+    pass
+
+
 def f(arg: Literal[1, 2, None, 3] = None):
     pass
 
 
+def f(arg: Literal[1] = None):  # RUF013
+    pass
+
+
 def f(arg: Literal[1, "foo"] = None):  # RUF013
     pass
 

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

@@ -34,11 +34,23 @@ list(x)[::]
 [i for i in x][::2]
 [i for i in x][::]
 
-# OK (doesn't mirror the underlying list)
+# RUF015 (doesn't mirror the underlying list)
 [i + 1 for i in x][0]
 [i for i in x if i > 5][0]
 [(i, i + 1) for i in x][0]
 
-# OK (multiple generators)
+# RUF015 (multiple generators)
 y = range(10)
 [i + j for i in x for j in y][0]
+
+# RUF015
+list(range(10))[0]
+list(x.y)[0]
+list(x["y"])[0]
+
+# RUF015 (multi-line)
+revision_heads_map_ast = [
+    a
+    for a in revision_heads_map_ast_obj.body
+    if isinstance(a, ast.Assign) and a.targets[0].id == "REVISION_HEADS_MAP"
+][0]

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

@@ -230,6 +230,15 @@ def incorrect_multi_conditional(arg1, arg2):
         raise Exception("...")  # should be typeerror
 
 
+def multiple_is_instance_checks(some_arg):
+    if isinstance(some_arg, str):
+        pass
+    elif isinstance(some_arg, int):
+        pass
+    else:
+        raise Exception("...")   # should be typeerror
+
+
 class MyCustomTypeValidation(Exception):
     pass
 
@@ -296,6 +305,17 @@ def multiple_ifs(some_args):
                 pass
 
 
+def else_body(obj):
+    if isinstance(obj, datetime.timedelta):
+        return "TimeDelta"
+    elif isinstance(obj, relativedelta.relativedelta):
+        return "RelativeDelta"
+    elif isinstance(obj, CronExpression):
+        return "CronExpression"
+    else:
+        raise Exception(f"Unknown object type: {obj.__class__.__name__}")
+
+
 def early_return():
     if isinstance(this, some_type):
         if x in this:

crates/ruff/src/autofix/edits.rs

@@ -7,7 +7,7 @@ use rustpython_parser::{lexer, Mode};
 use ruff_diagnostics::Edit;
 use ruff_python_ast::helpers;
 use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
-use ruff_python_whitespace::{is_python_whitespace, NewlineWithTrailingNewline, PythonWhitespace};
+use ruff_python_trivia::{is_python_whitespace, NewlineWithTrailingNewline, PythonWhitespace};
 
 use crate::autofix::codemods;
 
@@ -190,12 +190,24 @@ fn is_lone_child(child: &Stmt, parent: &Stmt) -> bool {
         }
         Stmt::For(ast::StmtFor { body, orelse, .. })
         | Stmt::AsyncFor(ast::StmtAsyncFor { body, orelse, .. })
-        | Stmt::While(ast::StmtWhile { body, orelse, .. })
-        | Stmt::If(ast::StmtIf { body, orelse, .. }) => {
+        | Stmt::While(ast::StmtWhile { body, orelse, .. }) => {
             if is_only(body, child) || is_only(orelse, child) {
                 return true;
             }
         }
+        Stmt::If(ast::StmtIf {
+            body,
+            elif_else_clauses,
+            ..
+        }) => {
+            if is_only(body, child)
+                || elif_else_clauses
+                    .iter()
+                    .any(|ast::ElifElseClause { body, .. }| is_only(body, child))
+            {
+                return true;
+            }
+        }
         Stmt::Try(ast::StmtTry {
             body,
             handlers,

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

@@ -14,5 +14,4 @@ pub(crate) struct Deferred<'a> {
     pub(crate) functions: Vec<Snapshot>,
     pub(crate) lambdas: Vec<(&'a Expr, Snapshot)>,
     pub(crate) for_loops: Vec<Snapshot>,
-    pub(crate) assignments: Vec<Snapshot>,
 }

crates/ruff/src/checkers/noqa.rs

@@ -1,5 +1,7 @@
 //! `NoQA` enforcement and validation.
 
+use std::path::Path;
+
 use itertools::Itertools;
 use ruff_text_size::{TextLen, TextRange, TextSize};
 use rustpython_parser::ast::Ranged;
@@ -16,6 +18,7 @@ use crate::settings::Settings;
 
 pub(crate) fn check_noqa(
     diagnostics: &mut Vec<Diagnostic>,
+    path: &Path,
     locator: &Locator,
     comment_ranges: &[TextRange],
     noqa_line_for: &NoqaMapping,
@@ -23,10 +26,10 @@ pub(crate) fn check_noqa(
     settings: &Settings,
 ) -> Vec<usize> {
     // Identify any codes that are globally exempted (within the current file).
-    let exemption = FileExemption::try_extract(locator.contents(), comment_ranges, locator);
+    let exemption = FileExemption::try_extract(locator.contents(), comment_ranges, path, locator);
 
     // Extract all `noqa` directives.
-    let mut noqa_directives = NoqaDirectives::from_commented_ranges(comment_ranges, locator);
+    let mut noqa_directives = NoqaDirectives::from_commented_ranges(comment_ranges, path, locator);
 
     // Indices of diagnostics that were ignored by a `noqa` directive.
     let mut ignored_diagnostics = vec![];

crates/ruff/src/checkers/physical_lines.rs

@@ -5,11 +5,11 @@ use ruff_text_size::TextSize;
 
 use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
-use ruff_python_whitespace::UniversalNewlines;
+use ruff_python_trivia::UniversalNewlines;
 
+use crate::comments::shebang::ShebangDirective;
 use crate::registry::Rule;
 use crate::rules::flake8_copyright::rules::missing_copyright_notice;
-use crate::rules::flake8_executable::helpers::ShebangDirective;
 use crate::rules::flake8_executable::rules::{
     shebang_missing, shebang_newline, shebang_not_executable, shebang_python, shebang_whitespace,
 };
@@ -115,7 +115,6 @@ pub(crate) fn check_physical_lines(
                             diagnostics.push(diagnostic);
                         }
                     }
-                } else {
                 }
             }
         }

crates/ruff/src/codes.rs

@@ -209,6 +209,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "R0915") => (RuleGroup::Unspecified, rules::pylint::rules::TooManyStatements),
         (Pylint, "R1701") => (RuleGroup::Unspecified, rules::pylint::rules::RepeatedIsinstanceCalls),
         (Pylint, "R1711") => (RuleGroup::Unspecified, rules::pylint::rules::UselessReturn),
+        (Pylint, "R1714") => (RuleGroup::Unspecified, rules::pylint::rules::RepeatedEqualityComparisonTarget),
         (Pylint, "R1722") => (RuleGroup::Unspecified, rules::pylint::rules::SysExitAlias),
         (Pylint, "R2004") => (RuleGroup::Unspecified, rules::pylint::rules::MagicValueComparison),
         (Pylint, "R5501") => (RuleGroup::Unspecified, rules::pylint::rules::CollapsibleElseIf),
@@ -603,6 +604,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (PandasVet, "012") => (RuleGroup::Unspecified, rules::pandas_vet::rules::PandasUseOfDotReadTable),
         (PandasVet, "013") => (RuleGroup::Unspecified, rules::pandas_vet::rules::PandasUseOfDotStack),
         (PandasVet, "015") => (RuleGroup::Unspecified, rules::pandas_vet::rules::PandasUseOfPdMerge),
+        (PandasVet, "101") => (RuleGroup::Unspecified, rules::pandas_vet::rules::PandasNuniqueConstantSeriesCheck),
         (PandasVet, "901") => (RuleGroup::Unspecified, rules::pandas_vet::rules::PandasDfVariableName),
 
         // flake8-errmsg
@@ -627,16 +629,20 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Pyi, "014") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::ArgumentDefaultInStub),
         (Flake8Pyi, "015") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::AssignmentDefaultInStub),
         (Flake8Pyi, "016") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::DuplicateUnionMember),
+        (Flake8Pyi, "017") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::ComplexAssignmentInStub),
         (Flake8Pyi, "020") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::QuotedAnnotationInStub),
         (Flake8Pyi, "021") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::DocstringInStub),
         (Flake8Pyi, "024") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::CollectionsNamedTuple),
         (Flake8Pyi, "025") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::UnaliasedCollectionsAbcSetImport),
+        (Flake8Pyi, "026") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::TypeAliasWithoutAnnotation),
         (Flake8Pyi, "029") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::StrOrReprDefinedInStub),
         (Flake8Pyi, "030") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::UnnecessaryLiteralUnion),
         (Flake8Pyi, "032") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::AnyEqNeAnnotation),
         (Flake8Pyi, "033") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::TypeCommentInStub),
         (Flake8Pyi, "034") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::NonSelfReturnType),
         (Flake8Pyi, "035") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::UnassignedSpecialVariableInStub),
+        (Flake8Pyi, "036") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::BadExitAnnotation),
+        (Flake8Pyi, "041") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::RedundantNumericUnion),
         (Flake8Pyi, "042") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::SnakeCaseTypeAlias),
         (Flake8Pyi, "043") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::TSuffixedTypeAlias),
         (Flake8Pyi, "044") => (RuleGroup::Unspecified, rules::flake8_pyi::rules::FutureAnnotationsInStub),
@@ -743,6 +749,12 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8UsePathlib, "122") => (RuleGroup::Unspecified, rules::flake8_use_pathlib::violations::OsPathSplitext),
         (Flake8UsePathlib, "123") => (RuleGroup::Unspecified, rules::flake8_use_pathlib::violations::BuiltinOpen),
         (Flake8UsePathlib, "124") => (RuleGroup::Unspecified, rules::flake8_use_pathlib::violations::PyPath),
+        (Flake8UsePathlib, "201") => (RuleGroup::Unspecified, rules::flake8_use_pathlib::rules::PathConstructorCurrentDirectory),
+        (Flake8UsePathlib, "202") => (RuleGroup::Unspecified, rules::flake8_use_pathlib::rules::OsPathGetsize),
+        (Flake8UsePathlib, "202") => (RuleGroup::Unspecified, rules::flake8_use_pathlib::rules::OsPathGetsize),
+        (Flake8UsePathlib, "203") => (RuleGroup::Unspecified, rules::flake8_use_pathlib::rules::OsPathGetatime),
+        (Flake8UsePathlib, "204") => (RuleGroup::Unspecified, rules::flake8_use_pathlib::rules::OsPathGetmtime),
+        (Flake8UsePathlib, "205") => (RuleGroup::Unspecified, rules::flake8_use_pathlib::rules::OsPathGetctime),
 
         // flake8-logging-format
         (Flake8LoggingFormat, "001") => (RuleGroup::Unspecified, rules::flake8_logging_format::violations::LoggingStringFormat),
@@ -778,7 +790,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "011") => (RuleGroup::Unspecified, rules::ruff::rules::StaticKeyDictComprehension),
         (Ruff, "012") => (RuleGroup::Unspecified, rules::ruff::rules::MutableClassDefault),
         (Ruff, "013") => (RuleGroup::Unspecified, rules::ruff::rules::ImplicitOptional),
-        #[cfg(feature = "unreachable-code")]
+        #[cfg(feature = "unreachable-code")] // When removing this feature gate, also update rules_selector.rs
         (Ruff, "014") => (RuleGroup::Nursery, rules::ruff::rules::UnreachableCode),
         (Ruff, "015") => (RuleGroup::Unspecified, rules::ruff::rules::UnnecessaryIterableAllocationForFirstElement),
         (Ruff, "016") => (RuleGroup::Unspecified, rules::ruff::rules::InvalidIndexType),

crates/ruff/src/comments/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod shebang;

crates/ruff/src/comments/shebang.rs

@@ -0,0 +1,67 @@
+use ruff_python_trivia::{is_python_whitespace, Cursor};
+use ruff_text_size::{TextLen, TextSize};
+
+/// A shebang directive (e.g., `#!/usr/bin/env python3`).
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct ShebangDirective<'a> {
+    /// The offset of the directive contents (e.g., `/usr/bin/env python3`) from the start of the
+    /// line.
+    pub(crate) offset: TextSize,
+    /// The contents of the directive (e.g., `"/usr/bin/env python3"`).
+    pub(crate) contents: &'a str,
+}
+
+impl<'a> ShebangDirective<'a> {
+    /// Parse a shebang directive from a line, or return `None` if the line does not contain a
+    /// shebang directive.
+    pub(crate) fn try_extract(line: &'a str) -> Option<Self> {
+        let mut cursor = Cursor::new(line);
+
+        // Trim whitespace.
+        cursor.eat_while(is_python_whitespace);
+
+        // Trim the `#!` prefix.
+        if !cursor.eat_char('#') {
+            return None;
+        }
+        if !cursor.eat_char('!') {
+            return None;
+        }
+
+        Some(Self {
+            offset: line.text_len() - cursor.text_len(),
+            contents: cursor.chars().as_str(),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use insta::assert_debug_snapshot;
+
+    use super::ShebangDirective;
+
+    #[test]
+    fn shebang_non_match() {
+        let source = "not a match";
+        assert_debug_snapshot!(ShebangDirective::try_extract(source));
+    }
+
+    #[test]
+    fn shebang_end_of_line() {
+        let source = "print('test')  #!/usr/bin/python";
+        assert_debug_snapshot!(ShebangDirective::try_extract(source));
+    }
+
+    #[test]
+    fn shebang_match() {
+        let source = "#!/usr/bin/env python";
+        assert_debug_snapshot!(ShebangDirective::try_extract(source));
+    }
+
+    #[test]
+    fn shebang_leading_space() {
+        let source = "  #!/usr/bin/env python";
+        assert_debug_snapshot!(ShebangDirective::try_extract(source));
+    }
+}

crates/ruff/src/comments/snapshots/ruff__comments__shebang__tests__shebang_end_of_line.snap

@@ -1,5 +1,5 @@
 ---
-source: crates/ruff/src/rules/flake8_executable/helpers.rs
+source: crates/ruff/src/comments/shebang.rs
 expression: "ShebangDirective::try_extract(source)"
 ---
 None

crates/ruff/src/comments/snapshots/ruff__comments__shebang__tests__shebang_leading_space.snap

@@ -1,5 +1,5 @@
 ---
-source: crates/ruff/src/rules/flake8_executable/helpers.rs
+source: crates/ruff/src/comments/shebang.rs
 expression: "ShebangDirective::try_extract(source)"
 ---
 Some(

crates/ruff/src/comments/snapshots/ruff__comments__shebang__tests__shebang_match.snap

@@ -1,5 +1,5 @@
 ---
-source: crates/ruff/src/rules/flake8_executable/helpers.rs
+source: crates/ruff/src/comments/shebang.rs
 expression: "ShebangDirective::try_extract(source)"
 ---
 Some(

crates/ruff/src/comments/snapshots/ruff__comments__shebang__tests__shebang_non_match.snap

@@ -1,5 +1,5 @@
 ---
-source: crates/ruff/src/rules/flake8_executable/helpers.rs
+source: crates/ruff/src/comments/shebang.rs
 expression: "ShebangDirective::try_extract(source)"
 ---
 None

crates/ruff/src/doc_lines.rs

@@ -10,7 +10,7 @@ use rustpython_parser::Tok;
 
 use ruff_python_ast::source_code::Locator;
 use ruff_python_ast::statement_visitor::{walk_stmt, StatementVisitor};
-use ruff_python_whitespace::UniversalNewlineIterator;
+use ruff_python_trivia::UniversalNewlineIterator;
 
 /// Extract doc lines (standalone comments) from a token sequence.
 pub(crate) fn doc_lines_from_tokens(lxr: &[LexResult]) -> DocLines {

crates/ruff/src/docstrings/sections.rs

@@ -5,7 +5,7 @@ use ruff_python_ast::docstrings::{leading_space, leading_words};
 use ruff_text_size::{TextLen, TextRange, TextSize};
 use strum_macros::EnumIter;
 
-use ruff_python_whitespace::{Line, UniversalNewlineIterator, UniversalNewlines};
+use ruff_python_trivia::{Line, UniversalNewlineIterator, UniversalNewlines};
 
 use crate::docstrings::styles::SectionStyle;
 use crate::docstrings::{Docstring, DocstringBody};

crates/ruff/src/importer/insertion.rs

@@ -8,7 +8,7 @@ use rustpython_parser::{lexer, Mode, Tok};
 use ruff_diagnostics::Edit;
 use ruff_python_ast::helpers::is_docstring_stmt;
 use ruff_python_ast::source_code::{Locator, Stylist};
-use ruff_python_whitespace::{PythonWhitespace, UniversalNewlineIterator};
+use ruff_python_trivia::{PythonWhitespace, UniversalNewlineIterator};
 use ruff_textwrap::indent;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -305,7 +305,7 @@ mod tests {
     use rustpython_parser::Parse;
 
     use ruff_python_ast::source_code::{Locator, Stylist};
-    use ruff_python_whitespace::LineEnding;
+    use ruff_python_trivia::LineEnding;
 
     use super::Insertion;
 

crates/ruff/src/jupyter/notebook.rs

@@ -10,7 +10,7 @@ use serde::Serialize;
 use serde_json::error::Category;
 
 use ruff_diagnostics::Diagnostic;
-use ruff_python_whitespace::{NewlineWithTrailingNewline, UniversalNewlineIterator};
+use ruff_python_trivia::{NewlineWithTrailingNewline, UniversalNewlineIterator};
 use ruff_text_size::{TextRange, TextSize};
 
 use crate::autofix::source_map::{SourceMap, SourceMarker};

crates/ruff/src/lib.rs

@@ -14,6 +14,7 @@ pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 mod autofix;
 mod checkers;
 mod codes;
+mod comments;
 mod cst;
 pub mod directives;
 mod doc_lines;

crates/ruff/src/linter.rs

@@ -214,6 +214,7 @@ pub fn check_path(
     {
         let ignored = check_noqa(
             &mut diagnostics,
+            path,
             locator,
             indexer.comment_ranges(),
             &directives.noqa_line_for,
@@ -320,6 +321,7 @@ pub fn lint_only(
     package: Option<&Path>,
     settings: &Settings,
     noqa: flags::Noqa,
+    source_kind: Option<&SourceKind>,
 ) -> LinterResult<(Vec<Message>, Option<ImportMap>)> {
     // Tokenize once.
     let tokens: Vec<LexResult> = ruff_rustpython::tokenize(contents);
@@ -352,7 +354,7 @@ pub fn lint_only(
         &directives,
         settings,
         noqa,
-        None,
+        source_kind,
     );
 
     result.map(|(diagnostics, imports)| {

crates/ruff/src/noqa.rs

@@ -13,9 +13,10 @@ use rustpython_parser::ast::Ranged;
 
 use ruff_diagnostics::Diagnostic;
 use ruff_python_ast::source_code::Locator;
-use ruff_python_whitespace::LineEnding;
+use ruff_python_trivia::LineEnding;
 
 use crate::codes::NoqaCode;
+use crate::fs::relativize_path;
 use crate::registry::{AsRule, Rule, RuleSet};
 use crate::rule_redirects::get_redirect_target;
 
@@ -225,6 +226,7 @@ impl FileExemption {
     pub(crate) fn try_extract(
         contents: &str,
         comment_ranges: &[TextRange],
+        path: &Path,
         locator: &Locator,
     ) -> Option<Self> {
         let mut exempt_codes: Vec<NoqaCode> = vec![];
@@ -234,7 +236,8 @@ impl FileExemption {
                 Err(err) => {
                     #[allow(deprecated)]
                     let line = locator.compute_line_index(range.start());
-                    warn!("Invalid `# noqa` directive on line {line}: {err}");
+                    let path_display = relativize_path(path);
+                    warn!("Invalid `# noqa` directive on {path_display}:{line}: {err}");
                 }
                 Ok(Some(ParsedFileExemption::All)) => {
                     return Some(Self::All);
@@ -437,6 +440,7 @@ pub(crate) fn add_noqa(
     line_ending: LineEnding,
 ) -> Result<usize> {
     let (count, output) = add_noqa_inner(
+        path,
         diagnostics,
         locator,
         commented_lines,
@@ -448,6 +452,7 @@ pub(crate) fn add_noqa(
 }
 
 fn add_noqa_inner(
+    path: &Path,
     diagnostics: &[Diagnostic],
     locator: &Locator,
     commented_ranges: &[TextRange],
@@ -460,8 +465,8 @@ fn add_noqa_inner(
 
     // Whether the file is exempted from all checks.
     // Codes that are globally exempted (within the current file).
-    let exemption = FileExemption::try_extract(locator.contents(), commented_ranges, locator);
-    let directives = NoqaDirectives::from_commented_ranges(commented_ranges, locator);
+    let exemption = FileExemption::try_extract(locator.contents(), commented_ranges, path, locator);
+    let directives = NoqaDirectives::from_commented_ranges(commented_ranges, path, locator);
 
     // Mark any non-ignored diagnostics.
     for diagnostic in diagnostics {
@@ -625,6 +630,7 @@ pub(crate) struct NoqaDirectives<'a> {
 impl<'a> NoqaDirectives<'a> {
     pub(crate) fn from_commented_ranges(
         comment_ranges: &[TextRange],
+        path: &Path,
         locator: &'a Locator<'a>,
     ) -> Self {
         let mut directives = Vec::new();
@@ -634,7 +640,8 @@ impl<'a> NoqaDirectives<'a> {
                 Err(err) => {
                     #[allow(deprecated)]
                     let line = locator.compute_line_index(range.start());
-                    warn!("Invalid `# noqa` directive on line {line}: {err}");
+                    let path_display = relativize_path(path);
+                    warn!("Invalid `# noqa` directive on {path_display}:{line}: {err}");
                 }
                 Ok(Some(directive)) => {
                     // noqa comments are guaranteed to be single line.
@@ -758,12 +765,14 @@ impl FromIterator<TextRange> for NoqaMapping {
 
 #[cfg(test)]
 mod tests {
+    use std::path::Path;
+
     use insta::assert_debug_snapshot;
     use ruff_text_size::{TextRange, TextSize};
 
     use ruff_diagnostics::Diagnostic;
     use ruff_python_ast::source_code::Locator;
-    use ruff_python_whitespace::LineEnding;
+    use ruff_python_trivia::LineEnding;
 
     use crate::noqa::{add_noqa_inner, Directive, NoqaMapping, ParsedFileExemption};
     use crate::rules::pycodestyle::rules::AmbiguousVariableName;
@@ -946,9 +955,12 @@ mod tests {
 
     #[test]
     fn modification() {
+        let path = Path::new("/tmp/foo.txt");
+
         let contents = "x = 1";
         let noqa_line_for = NoqaMapping::default();
         let (count, output) = add_noqa_inner(
+            path,
             &[],
             &Locator::new(contents),
             &[],
@@ -968,6 +980,7 @@ mod tests {
         let contents = "x = 1";
         let noqa_line_for = NoqaMapping::default();
         let (count, output) = add_noqa_inner(
+            path,
             &diagnostics,
             &Locator::new(contents),
             &[],
@@ -992,6 +1005,7 @@ mod tests {
         let contents = "x = 1  # noqa: E741\n";
         let noqa_line_for = NoqaMapping::default();
         let (count, output) = add_noqa_inner(
+            path,
             &diagnostics,
             &Locator::new(contents),
             &[TextRange::new(TextSize::from(7), TextSize::from(19))],
@@ -1016,6 +1030,7 @@ mod tests {
         let contents = "x = 1  # noqa";
         let noqa_line_for = NoqaMapping::default();
         let (count, output) = add_noqa_inner(
+            path,
             &diagnostics,
             &Locator::new(contents),
             &[TextRange::new(TextSize::from(7), TextSize::from(13))],

crates/ruff/src/pyproject_toml.rs

@@ -1,4 +1,5 @@
-use anyhow::Result;
+use colored::Colorize;
+use log::warn;
 use pyproject_toml::{BuildSystem, Project};
 use ruff_text_size::{TextRange, TextSize};
 use serde::{Deserialize, Serialize};
@@ -22,34 +23,38 @@ struct PyProjectToml {
     project: Option<Project>,
 }
 
-pub fn lint_pyproject_toml(source_file: SourceFile, settings: &Settings) -> Result<Vec<Message>> {
-    let mut messages = vec![];
-
-    let err = match toml::from_str::<PyProjectToml>(source_file.source_text()) {
-        Ok(_) => return Ok(messages),
-        Err(err) => err,
+pub fn lint_pyproject_toml(source_file: SourceFile, settings: &Settings) -> Vec<Message> {
+    let Some(err) = toml::from_str::<PyProjectToml>(source_file.source_text()).err() else {
+        return Vec::default();
     };
 
+    let mut messages = Vec::new();
     let range = match err.span() {
         // This is bad but sometimes toml and/or serde just don't give us spans
         // TODO(konstin,micha): https://github.com/astral-sh/ruff/issues/4571
         None => TextRange::default(),
         Some(range) => {
             let Ok(end) = TextSize::try_from(range.end) else {
+                let message = format!(
+                    "{} is larger than 4GB, but ruff assumes all files to be smaller",
+                    source_file.name(),
+                );
                 if settings.rules.enabled(Rule::IOError) {
-                    let diagnostic = Diagnostic::new(
-                        IOError {
-                            message: "pyproject.toml is larger than 4GB".to_string(),
-                        },
-                        TextRange::default(),
-                    );
+                    let diagnostic = Diagnostic::new(IOError { message }, TextRange::default());
                     messages.push(Message::from_diagnostic(
                         diagnostic,
                         source_file,
                         TextSize::default(),
                     ));
+                } else {
+                    warn!(
+                        "{}{}{} {message}",
+                        "Failed to lint ".bold(),
+                        source_file.name().bold(),
+                        ":".bold()
+                    );
                 }
-                return Ok(messages);
+                return messages;
             };
             TextRange::new(
                 // start <= end, so if end < 4GB follows start < 4GB
@@ -69,5 +74,5 @@ pub fn lint_pyproject_toml(source_file: SourceFile, settings: &Settings) -> Resu
         ));
     }
 
-    Ok(messages)
+    messages
 }

crates/ruff/src/renamer.rs

@@ -245,6 +245,7 @@ impl Renamer {
             | BindingKind::NamedExprAssignment
             | BindingKind::UnpackedAssignment
             | BindingKind::Assignment
+            | BindingKind::BoundException
             | BindingKind::LoopVar
             | BindingKind::Global
             | BindingKind::Nonlocal(_)

crates/ruff/src/resolver.rs

@@ -262,6 +262,7 @@ pub fn python_files_in_path(
         builder.add(path);
     }
     builder.standard_filters(pyproject_config.settings.lib.respect_gitignore);
+    builder.require_git(false);
     builder.hidden(false);
     let walker = builder.build_parallel();
 
@@ -330,9 +331,12 @@ pub fn python_files_in_path(
             }
 
             if result.as_ref().map_or(true, |entry| {
-                if entry.depth() == 0 {
+                // Ignore directories
+                if entry.file_type().map_or(true, |ft| ft.is_dir()) {
+                    false
+                } else if entry.depth() == 0 {
                     // Accept all files that are passed-in directly.
-                    entry.file_type().map_or(false, |ft| ft.is_file())
+                    true
                 } else {
                     // Otherwise, check if the file is included.
                     let path = entry.path();

crates/ruff/src/rule_selector.rs

@@ -249,6 +249,9 @@ mod schema {
                                 (!prefix.is_empty()).then(|| prefix.to_string())
                             })),
                     )
+                    // Filter out rule gated behind `#[cfg(feature = "unreachable-code")]`, which is
+                    // off-by-default
+                    .filter(|prefix| prefix != "RUF014")
                     .sorted()
                     .map(Value::String)
                     .collect(),
@@ -342,24 +345,33 @@ mod clap_completion {
                             let prefix = l.common_prefix();
                             (!prefix.is_empty()).then(|| PossibleValue::new(prefix).help(l.name()))
                         })
-                        .chain(RuleCodePrefix::iter().map(|p| {
-                            let prefix = p.linter().common_prefix();
-                            let code = p.short_code();
+                        .chain(
+                            RuleCodePrefix::iter()
+                                // Filter out rule gated behind `#[cfg(feature = "unreachable-code")]`, which is
+                                // off-by-default
+                                .filter(|p| {
+                                    format!("{}{}", p.linter().common_prefix(), p.short_code())
+                                        != "RUF014"
+                                })
+                                .map(|p| {
+                                    let prefix = p.linter().common_prefix();
+                                    let code = p.short_code();
 
-                            let mut rules_iter = p.rules();
-                            let rule1 = rules_iter.next();
-                            let rule2 = rules_iter.next();
+                                    let mut rules_iter = p.rules();
+                                    let rule1 = rules_iter.next();
+                                    let rule2 = rules_iter.next();
 
-                            let value = PossibleValue::new(format!("{prefix}{code}"));
+                                    let value = PossibleValue::new(format!("{prefix}{code}"));
 
-                            if rule2.is_none() {
-                                let rule1 = rule1.unwrap();
-                                let name: &'static str = rule1.into();
-                                value.help(name)
-                            } else {
-                                value
-                            }
-                        })),
+                                    if rule2.is_none() {
+                                        let rule1 = rule1.unwrap();
+                                        let name: &'static str = rule1.into();
+                                        value.help(name)
+                                    } else {
+                                        value
+                                    }
+                                }),
+                        ),
                 ),
             ))
         }

crates/ruff/src/rules/airflow/rules/task_variable_name.rs

@@ -51,11 +51,9 @@ pub(crate) fn variable_name_task_id(
     value: &Expr,
 ) -> Option<Diagnostic> {
     // If we have more than one target, we can't do anything.
-    if targets.len() != 1 {
+    let [target] = targets else {
         return None;
-    }
-
-    let target = &targets[0];
+    };
     let Expr::Name(ast::ExprName { id, .. }) = target else {
         return None;
     };

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

@@ -26,7 +26,7 @@ pub(super) fn match_function_def(
         }) => (
             name,
             args,
-            returns.as_ref().map(|expr| &**expr),
+            returns.as_ref().map(AsRef::as_ref),
             body,
             decorator_list,
         ),