Set maturin version in release.yaml (#10257)

See: https://github.com/astral-sh/uv/pull/2219

.config/nextest.toml

@@ -0,0 +1,8 @@
+[profile.ci]
+# Print out output for failing tests as soon as they fail, and also at the end
+# of the run (for easy scrollability).
+failure-output = "immediate-final"
+# Do not cancel the test run on the first failure.
+fail-fast = false
+
+status-level = "skip"

.github/CODEOWNERS

@@ -7,3 +7,9 @@
 
 # Jupyter
 /crates/ruff_linter/src/jupyter/ @dhruvmanila
+/crates/ruff_formatter/ @MichaReiser
+/crates/ruff_python_formatter/ @MichaReiser
+/crates/ruff_python_parser/ @MichaReiser
+
+# flake8-pyi
+/crates/ruff_linter/src/rules/flake8_pyi/ @AlexWaygood

.github/workflows/ci.yaml

@@ -111,19 +111,29 @@ jobs:
       - uses: actions/checkout@v4
       - name: "Install Rust toolchain"
         run: rustup show
+      - name: "Install mold"
+        uses: rui314/setup-mold@v1
+      - name: "Install cargo nextest"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-nextest
       - name: "Install cargo insta"
         uses: taiki-e/install-action@v2
         with:
           tool: cargo-insta
       - uses: Swatinem/rust-cache@v2
       - name: "Run tests"
-        run: cargo insta test --all --all-features --unreferenced reject
+        shell: bash
+        env:
+          NEXTEST_PROFILE: "ci"
+        run: cargo insta test --all-features --unreferenced reject --test-runner nextest
+
       # Check for broken links in the documentation.
       - run: cargo doc --all --no-deps
         env:
           # Setting RUSTDOCFLAGS because `cargo doc --check` isn't yet implemented (https://github.com/rust-lang/cargo/issues/10025).
           RUSTDOCFLAGS: "-D warnings"
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: ruff
           path: target/debug/ruff
@@ -138,15 +148,16 @@ jobs:
       - uses: actions/checkout@v4
       - name: "Install Rust toolchain"
         run: rustup show
-      - name: "Install cargo insta"
+      - name: "Install cargo nextest"
         uses: taiki-e/install-action@v2
         with:
-          tool: cargo-insta
+          tool: cargo-nextest
       - uses: Swatinem/rust-cache@v2
       - name: "Run tests"
         shell: bash
-        # We can't reject unreferenced snapshots on windows because flake8_executable can't run on windows
-        run: cargo insta test --all --exclude ruff_dev --all-features
+        run: |
+          cargo nextest run --all-features --profile ci
+          cargo test --all-features --doc
 
   cargo-test-wasm:
     name: "cargo test (wasm)"
@@ -227,7 +238,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         name: Download comparison Ruff binary
         id: ruff-target
         with:
@@ -239,6 +250,7 @@ jobs:
         with:
           name: ruff
           branch: ${{ github.event.pull_request.base.ref }}
+          workflow: "ci.yaml"
           check_artifacts: true
 
       - name: Install ruff-ecosystem
@@ -313,13 +325,13 @@ jobs:
         run: |
           echo ${{ github.event.number }} > pr-number
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         name: Upload PR Number
         with:
           name: pr-number
           path: pr-number
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         name: Upload Results
         with:
           name: ecosystem-result
@@ -407,7 +419,7 @@ jobs:
       - uses: actions/setup-python@v5
       - name: "Add SSH key"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        uses: webfactory/ssh-agent@v0.8.0
+        uses: webfactory/ssh-agent@v0.9.0
         with:
           ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
       - name: "Install Rust toolchain"
@@ -460,7 +472,7 @@ jobs:
       - determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     steps:
-      - uses: extractions/setup-just@v1
+      - uses: extractions/setup-just@v2
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -473,7 +485,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         name: Download development ruff binary
         id: ruff-target
         with:

.github/workflows/docs.yaml

@@ -23,7 +23,7 @@ jobs:
       - uses: actions/setup-python@v5
       - name: "Add SSH key"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        uses: webfactory/ssh-agent@v0.8.0
+        uses: webfactory/ssh-agent@v0.9.0
         with:
           ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
       - name: "Install Rust toolchain"

.github/workflows/release.yaml

@@ -28,6 +28,7 @@ env:
   CARGO_NET_RETRY: 10
   CARGO_TERM_COLOR: always
   RUSTUP_MAX_RETRIES: 10
+  MATURIN_VERSION: "1.4.0"
 
 jobs:
   sdist:
@@ -44,6 +45,7 @@ jobs:
       - name: "Build sdist"
         uses: PyO3/maturin-action@v1
         with:
+          maturin-version: ${{ env.MATURIN_VERSION }}
           command: sdist
           args: --out dist
       - name: "Test sdist"
@@ -52,9 +54,9 @@ jobs:
           ruff --help
           python -m ruff --help
       - name: "Upload sdist"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-sdist
           path: dist
 
   macos-x86_64:
@@ -72,6 +74,7 @@ jobs:
       - name: "Build wheels - x86_64"
         uses: PyO3/maturin-action@v1
         with:
+          maturin-version: ${{ env.MATURIN_VERSION }}
           target: x86_64
           args: --release --locked --out dist
       - name: "Test wheel - x86_64"
@@ -80,9 +83,9 @@ jobs:
           ruff --help
           python -m ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-macos-x86_64
           path: dist
       - name: "Archive binary"
         run: |
@@ -90,9 +93,9 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/x86_64-apple-darwin/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-macos-x86_64
           path: |
             *.tar.gz
             *.sha256
@@ -112,6 +115,7 @@ jobs:
       - name: "Build wheels - universal2"
         uses: PyO3/maturin-action@v1
         with:
+          maturin-version: ${{ env.MATURIN_VERSION }}
           args: --release --locked --target universal2-apple-darwin --out dist
       - name: "Test wheel - universal2"
         run: |
@@ -119,9 +123,9 @@ jobs:
           ruff --help
           python -m ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-aarch64-apple-darwin
           path: dist
       - name: "Archive binary"
         run: |
@@ -129,9 +133,9 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/aarch64-apple-darwin/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-aarch64-apple-darwin
           path: |
             *.tar.gz
             *.sha256
@@ -160,6 +164,7 @@ jobs:
       - name: "Build wheels"
         uses: PyO3/maturin-action@v1
         with:
+          maturin-version: ${{ env.MATURIN_VERSION }}
           target: ${{ matrix.platform.target }}
           args: --release --locked --out dist
       - name: "Test wheel"
@@ -170,9 +175,9 @@ jobs:
           ruff --help
           python -m ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ matrix.platform.target }}
           path: dist
       - name: "Archive binary"
         shell: bash
@@ -181,9 +186,9 @@ jobs:
           7z a $ARCHIVE_FILE ./target/${{ matrix.platform.target }}/release/ruff.exe
           sha256sum $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-${{ matrix.platform.target }}
           path: |
             *.zip
             *.sha256
@@ -208,6 +213,7 @@ jobs:
       - name: "Build wheels"
         uses: PyO3/maturin-action@v1
         with:
+          maturin-version: ${{ env.MATURIN_VERSION }}
           target: ${{ matrix.target }}
           manylinux: auto
           args: --release --locked --out dist
@@ -218,9 +224,9 @@ jobs:
           ruff --help
           python -m ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ matrix.target }}
           path: dist
       - name: "Archive binary"
         run: |
@@ -228,9 +234,9 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/${{ matrix.target }}/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-${{ matrix.target }}
           path: |
             *.tar.gz
             *.sha256
@@ -251,8 +257,12 @@ jobs:
             arch: s390x
           - target: powerpc64le-unknown-linux-gnu
             arch: ppc64le
+            # see https://github.com/astral-sh/ruff/issues/10073
+            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
           - target: powerpc64-unknown-linux-gnu
             arch: ppc64
+            # see https://github.com/astral-sh/ruff/issues/10073
+            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
 
     steps:
       - uses: actions/checkout@v4
@@ -266,6 +276,7 @@ jobs:
       - name: "Build wheels"
         uses: PyO3/maturin-action@v1
         with:
+          maturin-version: ${{ env.MATURIN_VERSION }}
           target: ${{ matrix.platform.target }}
           manylinux: auto
           docker-options: ${{ matrix.platform.maturin_docker_options }}
@@ -285,9 +296,9 @@ jobs:
             pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
             ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ matrix.platform.target }}
           path: dist
       - name: "Archive binary"
         run: |
@@ -295,9 +306,9 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/${{ matrix.platform.target }}/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-${{ matrix.platform.target }}
           path: |
             *.tar.gz
             *.sha256
@@ -322,6 +333,7 @@ jobs:
       - name: "Build wheels"
         uses: PyO3/maturin-action@v1
         with:
+          maturin-version: ${{ env.MATURIN_VERSION }}
           target: ${{ matrix.target }}
           manylinux: musllinux_1_2
           args: --release --locked --out dist
@@ -337,9 +349,9 @@ jobs:
             .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
             .venv/bin/ruff check --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ matrix.target }}
           path: dist
       - name: "Archive binary"
         run: |
@@ -347,9 +359,9 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/${{ matrix.target }}/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-${{ matrix.target }}
           path: |
             *.tar.gz
             *.sha256
@@ -377,6 +389,7 @@ jobs:
       - name: "Build wheels"
         uses: PyO3/maturin-action@v1
         with:
+          maturin-version: ${{ env.MATURIN_VERSION }}
           target: ${{ matrix.platform.target }}
           manylinux: musllinux_1_2
           args: --release --locked --out dist
@@ -394,9 +407,9 @@ jobs:
             .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
             .venv/bin/ruff check --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ matrix.platform.target }}
           path: dist
       - name: "Archive binary"
         run: |
@@ -404,9 +417,9 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/${{ matrix.platform.target }}/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-${{ matrix.platform.target }}
           path: |
             *.tar.gz
             *.sha256
@@ -463,10 +476,11 @@ jobs:
       # For pypi trusted publishing
       id-token: write
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: wheels
+          pattern: wheels-*
           path: wheels
+          merge-multiple: true
       - name: Publish to PyPi
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
@@ -506,10 +520,11 @@ jobs:
       # For GitHub release publishing
       contents: write
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: binaries
+          pattern: binaries-*
           path: binaries
+          merge-multiple: true
       - name: "Publish to GitHub"
         uses: softprops/action-gh-release@v1
         with:

BREAKING_CHANGES.md

@@ -1,5 +1,56 @@
 # Breaking Changes
 
+## 0.3.0
+
+### Ruff 2024.2 style
+
+The formatter now formats code according to the Ruff 2024.2 style guide. Read the [changelog](./CHANGELOG.md#030) for a detailed list of stabilized style changes.
+
+### `isort`: Use one blank line after imports in typing stub files ([#9971](https://github.com/astral-sh/ruff/pull/9971))
+
+Previously, Ruff used one or two blank lines (or the number configured by `isort.lines-after-imports`) after imports in typing stub files (`.pyi` files).
+The [typing style guide for stubs](https://typing.readthedocs.io/en/latest/source/stubs.html#style-guide) recommends using at most 1 blank line for grouping.
+As of this release, `isort` now always uses one blank line after imports in stub files, the same as the formatter.
+
+### `build` is no longer excluded by default ([#10093](https://github.com/astral-sh/ruff/pull/10093))
+
+Ruff maintains a list of directories and files that are excluded by default. This list now consists of the following patterns:
+
+- `.bzr`
+- `.direnv`
+- `.eggs`
+- `.git`
+- `.git-rewrite`
+- `.hg`
+- `.ipynb_checkpoints`
+- `.mypy_cache`
+- `.nox`
+- `.pants.d`
+- `.pyenv`
+- `.pytest_cache`
+- `.pytype`
+- `.ruff_cache`
+- `.svn`
+- `.tox`
+- `.venv`
+- `.vscode`
+- `__pypackages__`
+- `_build`
+- `buck-out`
+- `dist`
+- `node_modules`
+- `site-packages`
+- `venv`
+
+Previously, the `build` directory was included in this list. However, the `build` directory tends to be a not-unpopular directory
+name, and excluding it by default caused confusion. Ruff now no longer excludes `build` except if it is excluded by a `.gitignore` file
+or because it is listed in `extend-exclude`.
+
+### `--format` is no longer a valid `rule` or `linter` command option
+
+Previously, `ruff rule` and `ruff linter` accepted the `--format <FORMAT>` option as an alias for `--output-format`. Ruff no longer
+supports this alias. Please use `ruff rule --output-format <FORMAT>` and `ruff linter --output-format <FORMAT>` instead.
+
 ## 0.1.9
 
 ### `site-packages` is now excluded by default ([#5513](https://github.com/astral-sh/ruff/pull/5513))

CHANGELOG.md

@@ -1,5 +1,166 @@
 # Changelog
 
+## 0.3.1
+
+### Preview features
+
+- \[`pycodestyle`\] Fix E301 not triggering on decorated methods. ([#10117](https://github.com/astral-sh/ruff/pull/10117))
+- \[`pycodestyle`\] Respect `isort` settings in blank line rules (`E3*`) ([#10096](https://github.com/astral-sh/ruff/pull/10096))
+- \[`pycodestyle`\] Make blank lines in typing stub files optional (`E3*`) ([#10098](https://github.com/astral-sh/ruff/pull/10098))
+- \[`pylint`\] Implement `singledispatch-method` (`E1519`) ([#10140](https://github.com/astral-sh/ruff/pull/10140))
+- \[`pylint`\] Implement `useless-exception-statement` (`W0133`) ([#10176](https://github.com/astral-sh/ruff/pull/10176))
+
+### Rule changes
+
+- \[`flake8-debugger`\] Check for use of `debugpy` and `ptvsd` debug modules (#10177) ([#10194](https://github.com/astral-sh/ruff/pull/10194))
+- \[`pyupgrade`\] Generate diagnostic for all valid f-string conversions regardless of line length (`UP032`) ([#10238](https://github.com/astral-sh/ruff/pull/10238))
+- \[`pep8_naming`\] Add fixes for `N804` and `N805` ([#10215](https://github.com/astral-sh/ruff/pull/10215))
+
+### CLI
+
+- Colorize the output of `ruff format --diff` ([#10110](https://github.com/astral-sh/ruff/pull/10110))
+- Make `--config` and `--isolated` global flags ([#10150](https://github.com/astral-sh/ruff/pull/10150))
+- Correctly expand tildes and environment variables in paths passed to `--config` ([#10219](https://github.com/astral-sh/ruff/pull/10219))
+
+### Configuration
+
+- Accept a PEP 440 version specifier for `required-version` ([#10216](https://github.com/astral-sh/ruff/pull/10216))
+- Implement isort's `default-section` setting ([#10149](https://github.com/astral-sh/ruff/pull/10149))
+
+### Bug fixes
+
+- Remove trailing space from `CapWords` message ([#10220](https://github.com/astral-sh/ruff/pull/10220))
+- Respect external codes in file-level exemptions ([#10203](https://github.com/astral-sh/ruff/pull/10203))
+- \[`flake8-raise`\] Avoid false-positives for parens-on-raise with `future.exception()` (`RSE102`) ([#10206](https://github.com/astral-sh/ruff/pull/10206))
+- \[`pylint`\] Add fix for unary expressions in `PLC2801` ([#9587](https://github.com/astral-sh/ruff/pull/9587))
+- \[`ruff`\] Fix RUF028 not allowing `# fmt: skip` on match cases ([#10178](https://github.com/astral-sh/ruff/pull/10178))
+
+## 0.3.0
+
+This release introduces the new Ruff formatter 2024.2 style and adds a new lint rule to
+detect invalid formatter suppression comments.
+
+### Preview features
+
+- \[`flake8-bandit`\] Remove suspicious-lxml-import (`S410`) ([#10154](https://github.com/astral-sh/ruff/pull/10154))
+- \[`pycodestyle`\] Allow `os.environ` modifications between imports (`E402`) ([#10066](https://github.com/astral-sh/ruff/pull/10066))
+- \[`pycodestyle`\] Don't warn about a single whitespace character before a comma in a tuple (`E203`) ([#10094](https://github.com/astral-sh/ruff/pull/10094))
+
+### Rule changes
+
+- \[`eradicate`\] Detect commented out `case` statements (`ERA001`) ([#10055](https://github.com/astral-sh/ruff/pull/10055))
+- \[`eradicate`\] Detect single-line code for `try:`, `except:`, etc. (`ERA001`) ([#10057](https://github.com/astral-sh/ruff/pull/10057))
+- \[`flake8-boolean-trap`\] Allow boolean positionals in `__post_init__` ([#10027](https://github.com/astral-sh/ruff/pull/10027))
+- \[`flake8-copyright`\] Allow © in copyright notices ([#10065](https://github.com/astral-sh/ruff/pull/10065))
+- \[`isort`\]: Use one blank line after imports in typing stub files ([#9971](https://github.com/astral-sh/ruff/pull/9971))
+- \[`pylint`\] New Rule `dict-iter-missing-items` (`PLE1141`) ([#9845](https://github.com/astral-sh/ruff/pull/9845))
+- \[`pylint`\] Ignore `sys.version` and `sys.platform` (`PLR1714`) ([#10054](https://github.com/astral-sh/ruff/pull/10054))
+- \[`pyupgrade`\] Detect literals with unary operators (`UP018`) ([#10060](https://github.com/astral-sh/ruff/pull/10060))
+- \[`ruff`\] Expand rule for `list(iterable).pop(0)` idiom (`RUF015`) ([#10148](https://github.com/astral-sh/ruff/pull/10148))
+
+### Formatter
+
+This release introduces the Ruff 2024.2 style, stabilizing the following changes:
+
+- Prefer splitting the assignment's value over the target or type annotation ([#8943](https://github.com/astral-sh/ruff/pull/8943))
+- Remove blank lines before class docstrings ([#9154](https://github.com/astral-sh/ruff/pull/9154))
+- Wrap multiple context managers in `with` parentheses when targeting Python 3.9 or newer ([#9222](https://github.com/astral-sh/ruff/pull/9222))
+- Add a blank line after nested classes with a dummy body (`...`) in typing stub files ([#9155](https://github.com/astral-sh/ruff/pull/9155))
+- Reduce vertical spacing for classes and functions with a dummy (`...`) body ([#7440](https://github.com/astral-sh/ruff/issues/7440), [#9240](https://github.com/astral-sh/ruff/pull/9240))
+- Add a blank line after the module docstring ([#8283](https://github.com/astral-sh/ruff/pull/8283))
+- Parenthesize long type hints in assignments ([#9210](https://github.com/astral-sh/ruff/pull/9210))
+- Preserve indent for single multiline-string call-expressions ([#9673](https://github.com/astral-sh/ruff/pull/9637))
+- Normalize hex escape and unicode escape sequences ([#9280](https://github.com/astral-sh/ruff/pull/9280))
+- Format module docstrings ([#9725](https://github.com/astral-sh/ruff/pull/9725))
+
+### CLI
+
+- Explicitly disallow `extend` as part of a `--config` flag ([#10135](https://github.com/astral-sh/ruff/pull/10135))
+- Remove `build` from the default exclusion list ([#10093](https://github.com/astral-sh/ruff/pull/10093))
+- Deprecate `ruff <path>`, `ruff --explain`, `ruff --clean`, and `ruff --generate-shell-completion` in favor of `ruff check <path>`, `ruff rule`, `ruff clean`, and `ruff generate-shell-completion` ([#10169](https://github.com/astral-sh/ruff/pull/10169))
+- Remove the deprecated CLI option `--format` from `ruff rule` and `ruff linter` ([#10170](https://github.com/astral-sh/ruff/pull/10170))
+
+### Bug fixes
+
+- \[`flake8-bugbear`\] Avoid adding default initializers to stubs (`B006`) ([#10152](https://github.com/astral-sh/ruff/pull/10152))
+- \[`flake8-type-checking`\] Respect runtime-required decorators for function signatures ([#10091](https://github.com/astral-sh/ruff/pull/10091))
+- \[`pycodestyle`\] Mark fixes overlapping with a multiline string as unsafe (`W293`) ([#10049](https://github.com/astral-sh/ruff/pull/10049))
+- \[`pydocstyle`\] Trim whitespace when removing blank lines after section (`D413`) ([#10162](https://github.com/astral-sh/ruff/pull/10162))
+- \[`pylint`\] Delete entire statement, including semicolons (`PLR0203`) ([#10074](https://github.com/astral-sh/ruff/pull/10074))
+- \[`ruff`\] Avoid f-string false positives in `gettext` calls (`RUF027`) ([#10118](https://github.com/astral-sh/ruff/pull/10118))
+- Fix `ruff` crashing on PowerPC systems because of too small page size ([#10080](https://github.com/astral-sh/ruff/pull/10080))
+
+### Performance
+
+- Add cold attribute to less likely printer queue branches in the formatter ([#10121](https://github.com/astral-sh/ruff/pull/10121))
+- Skip unnecessary string normalization in the formatter ([#10116](https://github.com/astral-sh/ruff/pull/10116))
+
+### Documentation
+
+- Remove "Beta" Label from formatter documentation ([#10144](https://github.com/astral-sh/ruff/pull/10144))
+- `line-length` option: fix link to `pycodestyle.max-line-length` ([#10136](https://github.com/astral-sh/ruff/pull/10136))
+
+## 0.2.2
+
+Highlights include:
+
+- Initial support formatting f-strings (in `--preview`).
+- Support for overriding arbitrary configuration options via the CLI through an expanded `--config`
+    argument (e.g., `--config "lint.isort.combine-as-imports=false"`).
+- Significant performance improvements in Ruff's lexer, parser, and lint rules.
+
+### Preview features
+
+- Implement minimal f-string formatting ([#9642](https://github.com/astral-sh/ruff/pull/9642))
+- \[`pycodestyle`\] Add blank line(s) rules (`E301`, `E302`, `E303`, `E304`, `E305`, `E306`) ([#9266](https://github.com/astral-sh/ruff/pull/9266))
+- \[`refurb`\] Implement `readlines_in_for` (`FURB129`) ([#9880](https://github.com/astral-sh/ruff/pull/9880))
+
+### Rule changes
+
+- \[`ruff`\] Ensure closing parentheses for multiline sequences are always on their own line (`RUF022`, `RUF023`) ([#9793](https://github.com/astral-sh/ruff/pull/9793))
+- \[`numpy`\] Add missing deprecation violations (`NPY002`) ([#9862](https://github.com/astral-sh/ruff/pull/9862))
+- \[`flake8-bandit`\] Detect `mark_safe` usages in decorators ([#9887](https://github.com/astral-sh/ruff/pull/9887))
+- \[`ruff`\] Expand `asyncio-dangling-task` (`RUF006`) to include `new_event_loop` ([#9976](https://github.com/astral-sh/ruff/pull/9976))
+- \[`flake8-pyi`\] Ignore 'unused' private type dicts in class scopes ([#9952](https://github.com/astral-sh/ruff/pull/9952))
+
+### Formatter
+
+- Docstring formatting: Preserve tab indentation when using `indent-style=tabs` ([#9915](https://github.com/astral-sh/ruff/pull/9915))
+- Disable top-level docstring formatting for notebooks ([#9957](https://github.com/astral-sh/ruff/pull/9957))
+- Stabilize quote-style's `preserve` mode ([#9922](https://github.com/astral-sh/ruff/pull/9922))
+
+### CLI
+
+- Allow arbitrary configuration options to be overridden via the CLI ([#9599](https://github.com/astral-sh/ruff/pull/9599))
+
+### Bug fixes
+
+- Make `show-settings` filters directory-agnostic ([#9866](https://github.com/astral-sh/ruff/pull/9866))
+- Respect duplicates when rewriting type aliases ([#9905](https://github.com/astral-sh/ruff/pull/9905))
+- Respect tuple assignments in typing analyzer ([#9969](https://github.com/astral-sh/ruff/pull/9969))
+- Use atomic write when persisting cache ([#9981](https://github.com/astral-sh/ruff/pull/9981))
+- Use non-parenthesized range for `DebugText` ([#9953](https://github.com/astral-sh/ruff/pull/9953))
+- \[`flake8-simplify`\] Avoid false positive with `async` for loops (`SIM113`) ([#9996](https://github.com/astral-sh/ruff/pull/9996))
+- \[`flake8-trio`\] Respect `async with` in `timeout-without-await` ([#9859](https://github.com/astral-sh/ruff/pull/9859))
+- \[`perflint`\] Catch a wider range of mutations in `PERF101` ([#9955](https://github.com/astral-sh/ruff/pull/9955))
+- \[`pycodestyle`\] Fix `E30X` panics on blank lines with trailing white spaces ([#9907](https://github.com/astral-sh/ruff/pull/9907))
+- \[`pydocstyle`\] Allow using `parameters` as a subsection header (`D405`) ([#9894](https://github.com/astral-sh/ruff/pull/9894))
+- \[`pydocstyle`\] Fix blank-line docstring rules for module-level docstrings ([#9878](https://github.com/astral-sh/ruff/pull/9878))
+- \[`pylint`\] Accept 0.0 and 1.0 as common magic values (`PLR2004`) ([#9964](https://github.com/astral-sh/ruff/pull/9964))
+- \[`pylint`\] Avoid suggesting set rewrites for non-hashable types ([#9956](https://github.com/astral-sh/ruff/pull/9956))
+- \[`ruff`\] Avoid false negatives with string literals inside of method calls (`RUF027`) ([#9865](https://github.com/astral-sh/ruff/pull/9865))
+- \[`ruff`\] Fix panic on with f-string detection (`RUF027`) ([#9990](https://github.com/astral-sh/ruff/pull/9990))
+- \[`ruff`\] Ignore builtins when detecting missing f-strings ([#9849](https://github.com/astral-sh/ruff/pull/9849))
+
+### Performance
+
+- Use `memchr` for string lexing ([#9888](https://github.com/astral-sh/ruff/pull/9888))
+- Use `memchr` for tab-indentation detection ([#9853](https://github.com/astral-sh/ruff/pull/9853))
+- Reduce `Result<Tok, LexicalError>` size by using `Box<str>` instead of `String` ([#9885](https://github.com/astral-sh/ruff/pull/9885))
+- Reduce size of `Expr` from 80 to 64 bytes ([#9900](https://github.com/astral-sh/ruff/pull/9900))
+- Improve trailing comma rule performance ([#9867](https://github.com/astral-sh/ruff/pull/9867))
+- Remove unnecessary string cloning from the parser ([#9884](https://github.com/astral-sh/ruff/pull/9884))
+
 ## 0.2.1
 
 This release includes support for range formatting (i.e., the ability to format specific lines

CONTRIBUTING.md

@@ -26,6 +26,10 @@ Welcome! We're happy to have you here. Thank you in advance for your contributio
 - [`cargo dev`](#cargo-dev)
 - [Subsystems](#subsystems)
     - [Compilation Pipeline](#compilation-pipeline)
+    - [Import Categorization](#import-categorization)
+        - [Project root](#project-root)
+        - [Package root](#package-root)
+        - [Import categorization](#import-categorization-1)
 
 ## The Basics
 
@@ -35,7 +39,7 @@ 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
+You can also join us on [**Discord**](https://discord.com/invite/astral-sh) to discuss your idea with the
 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)
@@ -63,7 +67,7 @@ You'll also need [Insta](https://insta.rs/docs/) to update snapshot tests:
 cargo install cargo-insta
 ```
 
-and pre-commit to run some validation checks:
+And you'll need pre-commit to run some validation checks:
 
 ```shell
 pipx install pre-commit  # or `pip install pre-commit` if you have a virtualenv
@@ -76,6 +80,16 @@ when making a commit:
 pre-commit install
 ```
 
+We recommend [nextest](https://nexte.st/) to run Ruff's test suite (via `cargo nextest run`),
+though it's not strictly necessary:
+
+```shell
+cargo install cargo-nextest --locked
+```
+
+Throughout this guide, any usages of `cargo test` can be replaced with `cargo nextest run`,
+if you choose to install `nextest`.
+
 ### Development
 
 After cloning the repository, run Ruff locally from the repository root with:
@@ -302,7 +316,7 @@ To preview any changes to the documentation locally:
     ```
 
 The documentation should then be available locally at
-[http://127.0.0.1:8000/docs/](http://127.0.0.1:8000/docs/).
+[http://127.0.0.1:8000/ruff/](http://127.0.0.1:8000/ruff/).
 
 ## Release Process
 
@@ -373,6 +387,11 @@ We have several ways of benchmarking and profiling Ruff:
 - Microbenchmarks which run the linter or the formatter on individual files. These run on pull requests.
 - Profiling the linter on either the microbenchmarks or entire projects
 
+> \[!NOTE\]
+> When running benchmarks, ensure that your CPU is otherwise idle (e.g., close any background
+> applications, like web browsers). You may also want to switch your CPU to a "performance"
+> mode, if it exists, especially when benchmarking short-lived processes.
+
 ### CPython Benchmark
 
 First, clone [CPython](https://github.com/python/cpython). It's a large and diverse Python codebase,

Cargo.toml

@@ -14,39 +14,39 @@ license = "MIT"
 [workspace.dependencies]
 aho-corasick = { version = "1.1.2" }
 annotate-snippets = { version = "0.9.2", features = ["color"] }
-anyhow = { version = "1.0.79" }
+anyhow = { version = "1.0.80" }
 argfile = { version = "0.1.6" }
 assert_cmd = { version = "2.0.13" }
 bincode = { version = "1.3.3" }
 bitflags = { version = "2.4.1" }
-bstr = { version = "1.9.0" }
+bstr = { version = "1.9.1" }
 cachedir = { version = "0.3.1" }
-chrono = { version = "0.4.33", default-features = false, features = ["clock"] }
-clap = { version = "4.4.18", features = ["derive"] }
+chrono = { version = "0.4.34", default-features = false, features = ["clock"] }
+clap = { version = "4.5.1", features = ["derive"] }
 clap_complete_command = { version = "0.5.1" }
 clearscreen = { version = "2.0.0" }
-codspeed-criterion-compat = { version = "2.3.3", default-features = false }
+codspeed-criterion-compat = { version = "2.4.0", default-features = false }
 colored = { version = "2.1.0" }
 configparser = { version = "3.0.3" }
 console_error_panic_hook = { version = "0.1.7" }
 console_log = { version = "1.0.0" }
-countme = { version ="3.0.1"}
+countme = { version = "3.0.1" }
 criterion = { version = "0.5.1", default-features = false }
 dirs = { version = "5.0.0" }
 drop_bomb = { version = "0.1.5" }
-env_logger = { version ="0.10.1"}
+env_logger = { version = "0.10.1" }
 fern = { version = "0.6.1" }
 filetime = { version = "0.2.23" }
-fs-err = { version ="2.11.0"}
+fs-err = { version = "2.11.0" }
 glob = { version = "0.3.1" }
 globset = { version = "0.4.14" }
-hexf-parse = { version ="0.2.1"}
+hexf-parse = { version = "0.2.1" }
 ignore = { version = "0.4.22" }
-imara-diff ={ version = "0.1.5"}
+imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
-indicatif ={ version = "0.17.7"}
-indoc ={ version = "2.0.4"}
-insta = { version = "1.34.0", feature = ["filters", "glob"] }
+indicatif = { version = "0.17.8" }
+indoc = { version = "2.0.4" }
+insta = { version = "1.35.1", feature = ["filters", "glob"] }
 insta-cmd = { version = "0.4.0" }
 is-macro = { version = "0.3.5" }
 is-wsl = { version = "0.4.0" }
@@ -57,7 +57,7 @@ lexical-parse-float = { version = "0.8.0", features = ["format"] }
 libcst = { version = "1.1.0", default-features = false }
 log = { version = "0.4.17" }
 memchr = { version = "2.7.1" }
-mimalloc = { version ="0.1.39"}
+mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
 notify = { version = "6.1.1" }
 once_cell = { version = "1.19.0" }
@@ -75,35 +75,34 @@ regex = { version = "1.10.2" }
 result-like = { version = "0.5.0" }
 rustc-hash = { version = "1.1.0" }
 schemars = { version = "0.8.16" }
-seahash = { version ="4.1.0"}
-semver = { version = "1.0.21" }
-serde = { version = "1.0.196", features = ["derive"] }
-serde-wasm-bindgen = { version = "0.6.3" }
+seahash = { version = "4.1.0" }
+serde = { version = "1.0.197", features = ["derive"] }
+serde-wasm-bindgen = { version = "0.6.4" }
 serde_json = { version = "1.0.113" }
 serde_test = { version = "1.0.152" }
 serde_with = { version = "3.6.0", default-features = false, features = ["macros"] }
 shellexpand = { version = "3.0.0" }
-shlex = { version ="1.3.0"}
+shlex = { version = "1.3.0" }
 similar = { version = "2.4.0", features = ["inline"] }
 smallvec = { version = "1.13.1" }
 static_assertions = "1.1.0"
 strum = { version = "0.25.0", features = ["strum_macros"] }
 strum_macros = { version = "0.25.3" }
-syn = { version = "2.0.40" }
-tempfile = { version ="3.9.0"}
+syn = { version = "2.0.51" }
+tempfile = { version = "3.9.0" }
 test-case = { version = "3.3.1" }
-thiserror = { version = "1.0.51" }
-tikv-jemallocator = { version ="0.5.0"}
+thiserror = { version = "1.0.57" }
+tikv-jemallocator = { version = "0.5.0" }
 toml = { version = "0.8.9" }
 tracing = { version = "0.1.40" }
 tracing-indicatif = { version = "0.3.6" }
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 typed-arena = { version = "2.0.2" }
-unic-ucd-category = { version ="0.9"}
+unic-ucd-category = { version = "0.9" }
 unicode-ident = { version = "1.0.12" }
 unicode-width = { version = "0.1.11" }
 unicode_names2 = { version = "1.2.1" }
-ureq = { version = "2.9.1" }
+ureq = { version = "2.9.6" }
 url = { version = "2.5.0" }
 uuid = { version = "1.6.1", features = ["v4", "fast-rng", "macro-diagnostics", "js"] }
 walkdir = { version = "2.3.2" }

README.md

@@ -7,8 +7,9 @@
 [![image](https://img.shields.io/pypi/l/ruff.svg)](https://pypi.python.org/pypi/ruff)
 [![image](https://img.shields.io/pypi/pyversions/ruff.svg)](https://pypi.python.org/pypi/ruff)
 [![Actions status](https://github.com/astral-sh/ruff/workflows/CI/badge.svg)](https://github.com/astral-sh/ruff/actions)
+[![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?logo=discord&logoColor=white)](https://discord.com/invite/astral-sh)
 
-[**Discord**](https://discord.gg/c9MhzV8aU5) | [**Docs**](https://docs.astral.sh/ruff/) | [**Playground**](https://play.ruff.rs/)
+[**Docs**](https://docs.astral.sh/ruff/) | [**Playground**](https://play.ruff.rs/)
 
 An extremely fast Python linter and code formatter, written in Rust.
 
@@ -150,7 +151,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.2.1
+  rev: v0.3.1
   hooks:
     # Run the linter.
     - id: ruff
@@ -172,7 +173,7 @@ jobs:
   ruff:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: chartboost/ruff-action@v1
 ```
 
@@ -341,14 +342,14 @@ For a complete enumeration of the supported rules, see [_Rules_](https://docs.as
 Contributions are welcome and highly appreciated. To get started, check out the
 [**contributing guidelines**](https://docs.astral.sh/ruff/contributing/).
 
-You can also join us on [**Discord**](https://discord.gg/c9MhzV8aU5).
+You can also join us on [**Discord**](https://discord.com/invite/astral-sh).
 
 ## Support
 
 Having trouble? Check out the existing issues on [**GitHub**](https://github.com/astral-sh/ruff/issues),
 or feel free to [**open a new one**](https://github.com/astral-sh/ruff/issues/new).
 
-You can also ask for help on [**Discord**](https://discord.gg/c9MhzV8aU5).
+You can also ask for help on [**Discord**](https://discord.com/invite/astral-sh).
 
 ## Acknowledgements
 
@@ -378,6 +379,7 @@ Ruff is released under the MIT license.
 
 Ruff is used by a number of major open-source projects and companies, including:
 
+- [Albumentations](https://github.com/albumentations-team/albumentations)
 - Amazon ([AWS SAM](https://github.com/aws/serverless-application-model))
 - Anthropic ([Python SDK](https://github.com/anthropics/anthropic-sdk-python))
 - [Apache Airflow](https://github.com/apache/airflow)
@@ -404,6 +406,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [Ibis](https://github.com/ibis-project/ibis)
 - [ivy](https://github.com/unifyai/ivy)
 - [Jupyter](https://github.com/jupyter-server/jupyter_server)
+- [Kraken Tech](https://kraken.tech/)
 - [LangChain](https://github.com/hwchase17/langchain)
 - [Litestar](https://litestar.dev/)
 - [LlamaIndex](https://github.com/jerryjliu/llama_index)

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.2.1"
+version = "0.3.1"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -48,7 +48,9 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 shellexpand = { workspace = true }
 strum = { workspace = true, features = [] }
+tempfile = { workspace = true }
 thiserror = { workspace = true }
+toml = { workspace = true }
 tracing = { workspace = true, features = ["log"] }
 walkdir = { workspace = true }
 wild = { workspace = true }

crates/ruff/src/args.rs

@@ -1,12 +1,18 @@
 use std::cmp::Ordering;
 use std::fmt::Formatter;
-use std::path::PathBuf;
+use std::ops::Deref;
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
+use std::sync::Arc;
 
+use anyhow::bail;
+use clap::builder::{TypedValueParser, ValueParserFactory};
 use clap::{command, Parser};
 use colored::Colorize;
+use path_absolutize::path_dedot;
 use regex::Regex;
 use rustc_hash::FxHashMap;
+use toml;
 
 use ruff_linter::line_width::LineLength;
 use ruff_linter::logging::LogLevel;
@@ -19,9 +25,55 @@ use ruff_linter::{warn_user, RuleParser, RuleSelector, RuleSelectorParser};
 use ruff_source_file::{LineIndex, OneIndexed};
 use ruff_text_size::TextRange;
 use ruff_workspace::configuration::{Configuration, RuleSelection};
-use ruff_workspace::options::PycodestyleOptions;
+use ruff_workspace::options::{Options, PycodestyleOptions};
 use ruff_workspace::resolver::ConfigurationTransformer;
 
+/// All configuration options that can be passed "globally",
+/// i.e., can be passed to all subcommands
+#[derive(Debug, Default, Clone, clap::Args)]
+pub struct GlobalConfigArgs {
+    #[clap(flatten)]
+    log_level_args: LogLevelArgs,
+    /// Either a path to a TOML configuration file (`pyproject.toml` or `ruff.toml`),
+    /// or a TOML `<KEY> = <VALUE>` pair
+    /// (such as you might find in a `ruff.toml` configuration file)
+    /// overriding a specific configuration option.
+    /// Overrides of individual settings using this option always take precedence
+    /// over all configuration files, including configuration files that were also
+    /// specified using `--config`.
+    #[arg(
+        long,
+        action = clap::ArgAction::Append,
+        value_name = "CONFIG_OPTION",
+        value_parser = ConfigArgumentParser,
+        global = true,
+        help_heading = "Global options",
+    )]
+    pub config: Vec<SingleConfigArgument>,
+    /// Ignore all configuration files.
+    //
+    // Note: We can't mark this as conflicting with `--config` here
+    // as `--config` can be used for specifying configuration overrides
+    // as well as configuration files.
+    // Specifying a configuration file conflicts with `--isolated`;
+    // specifying a configuration override does not.
+    // If a user specifies `ruff check --isolated --config=ruff.toml`,
+    // we emit an error later on, after the initial parsing by clap.
+    #[arg(long, help_heading = "Global options", global = true)]
+    pub isolated: bool,
+}
+
+impl GlobalConfigArgs {
+    pub fn log_level(&self) -> LogLevel {
+        LogLevel::from(&self.log_level_args)
+    }
+
+    #[must_use]
+    fn partition(self) -> (LogLevel, Vec<SingleConfigArgument>, bool) {
+        (self.log_level(), self.config, self.isolated)
+    }
+}
+
 #[derive(Debug, Parser)]
 #[command(
     author,
@@ -32,9 +84,9 @@ use ruff_workspace::resolver::ConfigurationTransformer;
 #[command(version)]
 pub struct Args {
     #[command(subcommand)]
-    pub command: Command,
+    pub(crate) command: Command,
     #[clap(flatten)]
-    pub log_level_args: LogLevelArgs,
+    pub(crate) global_options: GlobalConfigArgs,
 }
 
 #[allow(clippy::large_enum_variant)]
@@ -57,10 +109,6 @@ pub enum Command {
         /// Output format
         #[arg(long, value_enum, default_value = "text")]
         output_format: HelpFormat,
-
-        /// Output format (Deprecated: Use `--output-format` instead).
-        #[arg(long, value_enum, conflicts_with = "output_format", hide = true)]
-        format: Option<HelpFormat>,
     },
     /// List or describe the available configuration options.
     Config { option: Option<String> },
@@ -69,10 +117,6 @@ pub enum Command {
         /// Output format
         #[arg(long, value_enum, default_value = "text")]
         output_format: HelpFormat,
-
-        /// Output format (Deprecated: Use `--output-format` instead).
-        #[arg(long, value_enum, conflicts_with = "output_format", hide = true)]
-        format: Option<HelpFormat>,
     },
     /// Clear any caches in the current directory and any subdirectories.
     #[clap(alias = "--clean")]
@@ -155,10 +199,6 @@ pub struct CheckCommand {
     preview: bool,
     #[clap(long, overrides_with("preview"), hide = true)]
     no_preview: bool,
-    /// Path to the `pyproject.toml` or `ruff.toml` file to use for
-    /// configuration.
-    #[arg(long, conflicts_with = "isolated")]
-    pub config: Option<PathBuf>,
     /// Comma-separated list of rule codes to enable (or ALL, to enable all rules).
     #[arg(
         long,
@@ -290,9 +330,6 @@ pub struct CheckCommand {
     /// Disable cache reads.
     #[arg(short, long, env = "RUFF_NO_CACHE", help_heading = "Miscellaneous")]
     pub no_cache: bool,
-    /// Ignore all configuration files.
-    #[arg(long, conflicts_with = "config", help_heading = "Miscellaneous")]
-    pub isolated: bool,
     /// Path to the cache directory.
     #[arg(long, env = "RUFF_CACHE_DIR", help_heading = "Miscellaneous")]
     pub cache_dir: Option<PathBuf>,
@@ -384,9 +421,6 @@ pub struct FormatCommand {
     /// difference between the current file and how the formatted file would look like.
     #[arg(long)]
     pub diff: bool,
-    /// Path to the `pyproject.toml` or `ruff.toml` file to use for configuration.
-    #[arg(long, conflicts_with = "isolated")]
-    pub config: Option<PathBuf>,
 
     /// Disable cache reads.
     #[arg(short, long, env = "RUFF_NO_CACHE", help_heading = "Miscellaneous")]
@@ -427,9 +461,6 @@ pub struct FormatCommand {
     /// Set the line-length.
     #[arg(long, help_heading = "Format configuration")]
     pub line_length: Option<LineLength>,
-    /// Ignore all configuration files.
-    #[arg(long, conflicts_with = "config", help_heading = "Miscellaneous")]
-    pub isolated: bool,
     /// The name of the file when passing it through stdin.
     #[arg(long, help_heading = "Miscellaneous")]
     pub stdin_filename: Option<PathBuf>,
@@ -470,7 +501,7 @@ pub enum HelpFormat {
 }
 
 #[allow(clippy::module_name_repetitions)]
-#[derive(Debug, clap::Args)]
+#[derive(Debug, Default, Clone, clap::Args)]
 pub struct LogLevelArgs {
     /// Enable verbose logging.
     #[arg(
@@ -515,101 +546,191 @@ impl From<&LogLevelArgs> for LogLevel {
     }
 }
 
+/// Configuration-related arguments passed via the CLI.
+#[derive(Default)]
+pub struct ConfigArguments {
+    /// Whether the user specified --isolated on the command line
+    pub(crate) isolated: bool,
+    /// The logging level to be used, derived from command-line arguments passed
+    pub(crate) log_level: LogLevel,
+    /// Path to a pyproject.toml or ruff.toml configuration file (etc.).
+    /// Either 0 or 1 configuration file paths may be provided on the command line.
+    config_file: Option<PathBuf>,
+    /// Overrides provided via the `--config "KEY=VALUE"` option.
+    /// An arbitrary number of these overrides may be provided on the command line.
+    /// These overrides take precedence over all configuration files,
+    /// even configuration files that were also specified using `--config`.
+    overrides: Configuration,
+    /// Overrides provided via dedicated flags such as `--line-length` etc.
+    /// These overrides take precedence over all configuration files,
+    /// and also over all overrides specified using any `--config "KEY=VALUE"` flags.
+    per_flag_overrides: ExplicitConfigOverrides,
+}
+
+impl ConfigArguments {
+    pub fn config_file(&self) -> Option<&Path> {
+        self.config_file.as_deref()
+    }
+
+    fn from_cli_arguments(
+        global_options: GlobalConfigArgs,
+        per_flag_overrides: ExplicitConfigOverrides,
+    ) -> anyhow::Result<Self> {
+        let (log_level, config_options, isolated) = global_options.partition();
+        let mut config_file: Option<PathBuf> = None;
+        let mut overrides = Configuration::default();
+
+        for option in config_options {
+            match option {
+                SingleConfigArgument::SettingsOverride(overridden_option) => {
+                    let overridden_option = Arc::try_unwrap(overridden_option)
+                        .unwrap_or_else(|option| option.deref().clone());
+                    overrides = overrides.combine(Configuration::from_options(
+                        overridden_option,
+                        None,
+                        &path_dedot::CWD,
+                    )?);
+                }
+                SingleConfigArgument::FilePath(path) => {
+                    if isolated {
+                        bail!(
+                            "\
+The argument `--config={}` cannot be used with `--isolated`
+
+  tip: You cannot specify a configuration file and also specify `--isolated`,
+       as `--isolated` causes ruff to ignore all configuration files.
+       For more information, try `--help`.
+",
+                            path.display()
+                        );
+                    }
+                    if let Some(ref config_file) = config_file {
+                        let (first, second) = (config_file.display(), path.display());
+                        bail!(
+                            "\
+You cannot specify more than one configuration file on the command line.
+
+  tip: remove either `--config={first}` or `--config={second}`.
+       For more information, try `--help`.
+"
+                        );
+                    }
+                    config_file = Some(path);
+                }
+            }
+        }
+        Ok(Self {
+            isolated,
+            log_level,
+            config_file,
+            overrides,
+            per_flag_overrides,
+        })
+    }
+}
+
+impl ConfigurationTransformer for ConfigArguments {
+    fn transform(&self, config: Configuration) -> Configuration {
+        let with_config_overrides = self.overrides.clone().combine(config);
+        self.per_flag_overrides.transform(with_config_overrides)
+    }
+}
+
 impl CheckCommand {
     /// Partition the CLI into command-line arguments and configuration
     /// overrides.
-    pub fn partition(self) -> (CheckArguments, CliOverrides) {
-        (
-            CheckArguments {
-                add_noqa: self.add_noqa,
-                config: self.config,
-                diff: self.diff,
-                ecosystem_ci: self.ecosystem_ci,
-                exit_non_zero_on_fix: self.exit_non_zero_on_fix,
-                exit_zero: self.exit_zero,
-                files: self.files,
-                ignore_noqa: self.ignore_noqa,
-                isolated: self.isolated,
-                no_cache: self.no_cache,
-                output_file: self.output_file,
-                show_files: self.show_files,
-                show_settings: self.show_settings,
-                statistics: self.statistics,
-                stdin_filename: self.stdin_filename,
-                watch: self.watch,
-            },
-            CliOverrides {
-                dummy_variable_rgx: self.dummy_variable_rgx,
-                exclude: self.exclude,
-                extend_exclude: self.extend_exclude,
-                extend_fixable: self.extend_fixable,
-                extend_ignore: self.extend_ignore,
-                extend_per_file_ignores: self.extend_per_file_ignores,
-                extend_select: self.extend_select,
-                extend_unfixable: self.extend_unfixable,
-                fixable: self.fixable,
-                ignore: self.ignore,
-                line_length: self.line_length,
-                per_file_ignores: self.per_file_ignores,
-                preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
-                respect_gitignore: resolve_bool_arg(
-                    self.respect_gitignore,
-                    self.no_respect_gitignore,
-                ),
-                select: self.select,
-                target_version: self.target_version,
-                unfixable: self.unfixable,
-                // TODO(charlie): Included in `pyproject.toml`, but not inherited.
-                cache_dir: self.cache_dir,
-                fix: resolve_bool_arg(self.fix, self.no_fix),
-                fix_only: resolve_bool_arg(self.fix_only, self.no_fix_only),
-                unsafe_fixes: resolve_bool_arg(self.unsafe_fixes, self.no_unsafe_fixes)
-                    .map(UnsafeFixes::from),
-                force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
-                output_format: resolve_output_format(
-                    self.output_format,
-                    resolve_bool_arg(self.show_source, self.no_show_source),
-                    resolve_bool_arg(self.preview, self.no_preview).unwrap_or_default(),
-                ),
-                show_fixes: resolve_bool_arg(self.show_fixes, self.no_show_fixes),
-                extension: self.extension,
-            },
-        )
+    pub fn partition(
+        self,
+        global_options: GlobalConfigArgs,
+    ) -> anyhow::Result<(CheckArguments, ConfigArguments)> {
+        let check_arguments = CheckArguments {
+            add_noqa: self.add_noqa,
+            diff: self.diff,
+            ecosystem_ci: self.ecosystem_ci,
+            exit_non_zero_on_fix: self.exit_non_zero_on_fix,
+            exit_zero: self.exit_zero,
+            files: self.files,
+            ignore_noqa: self.ignore_noqa,
+            no_cache: self.no_cache,
+            output_file: self.output_file,
+            show_files: self.show_files,
+            show_settings: self.show_settings,
+            statistics: self.statistics,
+            stdin_filename: self.stdin_filename,
+            watch: self.watch,
+        };
+
+        let cli_overrides = ExplicitConfigOverrides {
+            dummy_variable_rgx: self.dummy_variable_rgx,
+            exclude: self.exclude,
+            extend_exclude: self.extend_exclude,
+            extend_fixable: self.extend_fixable,
+            extend_ignore: self.extend_ignore,
+            extend_per_file_ignores: self.extend_per_file_ignores,
+            extend_select: self.extend_select,
+            extend_unfixable: self.extend_unfixable,
+            fixable: self.fixable,
+            ignore: self.ignore,
+            line_length: self.line_length,
+            per_file_ignores: self.per_file_ignores,
+            preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
+            respect_gitignore: resolve_bool_arg(self.respect_gitignore, self.no_respect_gitignore),
+            select: self.select,
+            target_version: self.target_version,
+            unfixable: self.unfixable,
+            // TODO(charlie): Included in `pyproject.toml`, but not inherited.
+            cache_dir: self.cache_dir,
+            fix: resolve_bool_arg(self.fix, self.no_fix),
+            fix_only: resolve_bool_arg(self.fix_only, self.no_fix_only),
+            unsafe_fixes: resolve_bool_arg(self.unsafe_fixes, self.no_unsafe_fixes)
+                .map(UnsafeFixes::from),
+            force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
+            output_format: resolve_output_format(
+                self.output_format,
+                resolve_bool_arg(self.show_source, self.no_show_source),
+                resolve_bool_arg(self.preview, self.no_preview).unwrap_or_default(),
+            ),
+            show_fixes: resolve_bool_arg(self.show_fixes, self.no_show_fixes),
+            extension: self.extension,
+        };
+
+        let config_args = ConfigArguments::from_cli_arguments(global_options, cli_overrides)?;
+        Ok((check_arguments, config_args))
     }
 }
 
 impl FormatCommand {
     /// Partition the CLI into command-line arguments and configuration
     /// overrides.
-    pub fn partition(self) -> (FormatArguments, CliOverrides) {
-        (
-            FormatArguments {
-                check: self.check,
-                diff: self.diff,
-                config: self.config,
-                files: self.files,
-                isolated: self.isolated,
-                no_cache: self.no_cache,
-                stdin_filename: self.stdin_filename,
-                range: self.range,
-            },
-            CliOverrides {
-                line_length: self.line_length,
-                respect_gitignore: resolve_bool_arg(
-                    self.respect_gitignore,
-                    self.no_respect_gitignore,
-                ),
-                exclude: self.exclude,
-                preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
-                force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
-                target_version: self.target_version,
-                cache_dir: self.cache_dir,
-                extension: self.extension,
+    pub fn partition(
+        self,
+        global_options: GlobalConfigArgs,
+    ) -> anyhow::Result<(FormatArguments, ConfigArguments)> {
+        let format_arguments = FormatArguments {
+            check: self.check,
+            diff: self.diff,
+            files: self.files,
+            no_cache: self.no_cache,
+            stdin_filename: self.stdin_filename,
+            range: self.range,
+        };
 
-                // Unsupported on the formatter CLI, but required on `Overrides`.
-                ..CliOverrides::default()
-            },
-        )
+        let cli_overrides = ExplicitConfigOverrides {
+            line_length: self.line_length,
+            respect_gitignore: resolve_bool_arg(self.respect_gitignore, self.no_respect_gitignore),
+            exclude: self.exclude,
+            preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
+            force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
+            target_version: self.target_version,
+            cache_dir: self.cache_dir,
+            extension: self.extension,
+
+            // Unsupported on the formatter CLI, but required on `Overrides`.
+            ..ExplicitConfigOverrides::default()
+        };
+
+        let config_args = ConfigArguments::from_cli_arguments(global_options, cli_overrides)?;
+        Ok((format_arguments, config_args))
     }
 }
 
@@ -622,6 +743,180 @@ fn resolve_bool_arg(yes: bool, no: bool) -> Option<bool> {
     }
 }
 
+/// Enumeration of various ways in which a --config CLI flag
+/// could be invalid
+#[derive(Debug)]
+enum InvalidConfigFlagReason {
+    InvalidToml(toml::de::Error),
+    /// It was valid TOML, but not a valid ruff config file.
+    /// E.g. the user tried to select a rule that doesn't exist,
+    /// or tried to enable a setting that doesn't exist
+    ValidTomlButInvalidRuffSchema(toml::de::Error),
+    /// It was a valid ruff config file, but the user tried to pass a
+    /// value for `extend` as part of the config override.
+    // `extend` is special, because it affects which config files we look at
+    /// in the first place. We currently only parse --config overrides *after*
+    /// we've combined them with all the arguments from the various config files
+    /// that we found, so trying to override `extend` as part of a --config
+    /// override is forbidden.
+    ExtendPassedViaConfigFlag,
+}
+
+impl InvalidConfigFlagReason {
+    const fn description(&self) -> &'static str {
+        match self {
+            Self::InvalidToml(_) => "The supplied argument is not valid TOML",
+            Self::ValidTomlButInvalidRuffSchema(_) => {
+                "Could not parse the supplied argument as a `ruff.toml` configuration option"
+            }
+            Self::ExtendPassedViaConfigFlag => "Cannot include `extend` in a --config flag value",
+        }
+    }
+}
+
+/// Enumeration to represent a single `--config` argument
+/// passed via the CLI.
+///
+/// Using the `--config` flag, users may pass 0 or 1 paths
+/// to configuration files and an arbitrary number of
+/// "inline TOML" overrides for specific settings.
+///
+/// For example:
+///
+/// ```sh
+/// ruff check --config "path/to/ruff.toml" --config "extend-select=['E501', 'F841']" --config "lint.per-file-ignores = {'some_file.py' = ['F841']}"
+/// ```
+#[derive(Clone, Debug)]
+pub enum SingleConfigArgument {
+    FilePath(PathBuf),
+    SettingsOverride(Arc<Options>),
+}
+
+#[derive(Clone)]
+pub struct ConfigArgumentParser;
+
+impl ValueParserFactory for SingleConfigArgument {
+    type Parser = ConfigArgumentParser;
+
+    fn value_parser() -> Self::Parser {
+        ConfigArgumentParser
+    }
+}
+
+impl TypedValueParser for ConfigArgumentParser {
+    type Value = SingleConfigArgument;
+
+    fn parse_ref(
+        &self,
+        cmd: &clap::Command,
+        arg: Option<&clap::Arg>,
+        value: &std::ffi::OsStr,
+    ) -> Result<Self::Value, clap::Error> {
+        // Convert to UTF-8.
+        let Some(value) = value.to_str() else {
+            // But respect non-UTF-8 paths.
+            let path_to_config_file = PathBuf::from(value);
+            if path_to_config_file.is_file() {
+                return Ok(SingleConfigArgument::FilePath(path_to_config_file));
+            }
+            return Err(clap::Error::new(clap::error::ErrorKind::InvalidUtf8));
+        };
+
+        // Expand environment variables and tildes.
+        if let Ok(path_to_config_file) =
+            shellexpand::full(value).map(|config| PathBuf::from(&*config))
+        {
+            if path_to_config_file.is_file() {
+                return Ok(SingleConfigArgument::FilePath(path_to_config_file));
+            }
+        }
+
+        let config_parse_error = match toml::Table::from_str(value) {
+            Ok(table) => match table.try_into::<Options>() {
+                Ok(option) => {
+                    if option.extend.is_none() {
+                        return Ok(SingleConfigArgument::SettingsOverride(Arc::new(option)));
+                    }
+                    InvalidConfigFlagReason::ExtendPassedViaConfigFlag
+                }
+                Err(underlying_error) => {
+                    InvalidConfigFlagReason::ValidTomlButInvalidRuffSchema(underlying_error)
+                }
+            },
+            Err(underlying_error) => InvalidConfigFlagReason::InvalidToml(underlying_error),
+        };
+
+        let mut new_error = clap::Error::new(clap::error::ErrorKind::ValueValidation).with_cmd(cmd);
+        if let Some(arg) = arg {
+            new_error.insert(
+                clap::error::ContextKind::InvalidArg,
+                clap::error::ContextValue::String(arg.to_string()),
+            );
+        }
+        new_error.insert(
+            clap::error::ContextKind::InvalidValue,
+            clap::error::ContextValue::String(value.to_string()),
+        );
+
+        let underlying_error = match &config_parse_error {
+            InvalidConfigFlagReason::ExtendPassedViaConfigFlag => {
+                let tip = config_parse_error.description().into();
+                new_error.insert(
+                    clap::error::ContextKind::Suggested,
+                    clap::error::ContextValue::StyledStrs(vec![tip]),
+                );
+                return Err(new_error);
+            }
+            InvalidConfigFlagReason::InvalidToml(underlying_error)
+            | InvalidConfigFlagReason::ValidTomlButInvalidRuffSchema(underlying_error) => {
+                underlying_error
+            }
+        };
+
+        // small hack so that multiline tips
+        // have the same indent on the left-hand side:
+        let tip_indent = " ".repeat("  tip: ".len());
+
+        let mut tip = format!(
+            "\
+A `--config` flag must either be a path to a `.toml` configuration file
+{tip_indent}or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+{tip_indent}option"
+        );
+
+        // Here we do some heuristics to try to figure out whether
+        // the user was trying to pass in a path to a configuration file
+        // or some inline TOML.
+        // We want to display the most helpful error to the user as possible.
+        if std::path::Path::new(value)
+            .extension()
+            .map_or(false, |ext| ext.eq_ignore_ascii_case("toml"))
+        {
+            if !value.contains('=') {
+                tip.push_str(&format!(
+                    "
+
+It looks like you were trying to pass a path to a configuration file.
+The path `{value}` does not point to a configuration file"
+                ));
+            }
+        } else if value.contains('=') {
+            tip.push_str(&format!(
+                "\n\n{}:\n\n{underlying_error}",
+                config_parse_error.description()
+            ));
+        }
+        let tip = tip.trim_end().to_owned().into();
+
+        new_error.insert(
+            clap::error::ContextKind::Suggested,
+            clap::error::ContextValue::StyledStrs(vec![tip]),
+        );
+
+        Err(new_error)
+    }
+}
+
 fn resolve_output_format(
     output_format: Option<SerializationFormat>,
     show_sources: Option<bool>,
@@ -664,14 +959,12 @@ fn resolve_output_format(
 #[allow(clippy::struct_excessive_bools)]
 pub struct CheckArguments {
     pub add_noqa: bool,
-    pub config: Option<PathBuf>,
     pub diff: bool,
     pub ecosystem_ci: bool,
     pub exit_non_zero_on_fix: bool,
     pub exit_zero: bool,
     pub files: Vec<PathBuf>,
     pub ignore_noqa: bool,
-    pub isolated: bool,
     pub no_cache: bool,
     pub output_file: Option<PathBuf>,
     pub show_files: bool,
@@ -688,9 +981,7 @@ pub struct FormatArguments {
     pub check: bool,
     pub no_cache: bool,
     pub diff: bool,
-    pub config: Option<PathBuf>,
     pub files: Vec<PathBuf>,
-    pub isolated: bool,
     pub stdin_filename: Option<PathBuf>,
     pub range: Option<FormatRange>,
 }
@@ -884,39 +1175,40 @@ impl LineColumnParseError {
     }
 }
 
-/// CLI settings that function as configuration overrides.
+/// Configuration overrides provided via dedicated CLI flags:
+/// `--line-length`, `--respect-gitignore`, etc.
 #[derive(Clone, Default)]
 #[allow(clippy::struct_excessive_bools)]
-pub struct CliOverrides {
-    pub dummy_variable_rgx: Option<Regex>,
-    pub exclude: Option<Vec<FilePattern>>,
-    pub extend_exclude: Option<Vec<FilePattern>>,
-    pub extend_fixable: Option<Vec<RuleSelector>>,
-    pub extend_ignore: Option<Vec<RuleSelector>>,
-    pub extend_select: Option<Vec<RuleSelector>>,
-    pub extend_unfixable: Option<Vec<RuleSelector>>,
-    pub fixable: Option<Vec<RuleSelector>>,
-    pub ignore: Option<Vec<RuleSelector>>,
-    pub line_length: Option<LineLength>,
-    pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
-    pub extend_per_file_ignores: Option<Vec<PatternPrefixPair>>,
-    pub preview: Option<PreviewMode>,
-    pub respect_gitignore: Option<bool>,
-    pub select: Option<Vec<RuleSelector>>,
-    pub target_version: Option<PythonVersion>,
-    pub unfixable: Option<Vec<RuleSelector>>,
+struct ExplicitConfigOverrides {
+    dummy_variable_rgx: Option<Regex>,
+    exclude: Option<Vec<FilePattern>>,
+    extend_exclude: Option<Vec<FilePattern>>,
+    extend_fixable: Option<Vec<RuleSelector>>,
+    extend_ignore: Option<Vec<RuleSelector>>,
+    extend_select: Option<Vec<RuleSelector>>,
+    extend_unfixable: Option<Vec<RuleSelector>>,
+    fixable: Option<Vec<RuleSelector>>,
+    ignore: Option<Vec<RuleSelector>>,
+    line_length: Option<LineLength>,
+    per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    extend_per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    preview: Option<PreviewMode>,
+    respect_gitignore: Option<bool>,
+    select: Option<Vec<RuleSelector>>,
+    target_version: Option<PythonVersion>,
+    unfixable: Option<Vec<RuleSelector>>,
     // TODO(charlie): Captured in pyproject.toml as a default, but not part of `Settings`.
-    pub cache_dir: Option<PathBuf>,
-    pub fix: Option<bool>,
-    pub fix_only: Option<bool>,
-    pub unsafe_fixes: Option<UnsafeFixes>,
-    pub force_exclude: Option<bool>,
-    pub output_format: Option<SerializationFormat>,
-    pub show_fixes: Option<bool>,
-    pub extension: Option<Vec<ExtensionPair>>,
+    cache_dir: Option<PathBuf>,
+    fix: Option<bool>,
+    fix_only: Option<bool>,
+    unsafe_fixes: Option<UnsafeFixes>,
+    force_exclude: Option<bool>,
+    output_format: Option<SerializationFormat>,
+    show_fixes: Option<bool>,
+    extension: Option<Vec<ExtensionPair>>,
 }
 
-impl ConfigurationTransformer for CliOverrides {
+impl ConfigurationTransformer for ExplicitConfigOverrides {
     fn transform(&self, mut config: Configuration) -> Configuration {
         if let Some(cache_dir) = &self.cache_dir {
             config.cache_dir = Some(cache_dir.clone());

crates/ruff/src/cache.rs

@@ -1,7 +1,7 @@
 use std::fmt::Debug;
 use std::fs::{self, File};
 use std::hash::Hasher;
-use std::io::{self, BufReader, BufWriter, Write};
+use std::io::{self, BufReader, Write};
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Mutex;
@@ -15,6 +15,7 @@ use rayon::iter::ParallelIterator;
 use rayon::iter::{IntoParallelIterator, ParallelBridge};
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
+use tempfile::NamedTempFile;
 
 use ruff_cache::{CacheKey, CacheKeyHasher};
 use ruff_diagnostics::{DiagnosticKind, Fix};
@@ -165,15 +166,29 @@ impl Cache {
             return Ok(());
         }
 
-        let file = File::create(&self.path)
-            .with_context(|| format!("Failed to create cache file '{}'", self.path.display()))?;
-        let writer = BufWriter::new(file);
-        bincode::serialize_into(writer, &self.package).with_context(|| {
+        // Write the cache to a temporary file first and then rename it for an "atomic" write.
+        // Protects against data loss if the process is killed during the write and races between different ruff
+        // processes, resulting in a corrupted cache file. https://github.com/astral-sh/ruff/issues/8147#issuecomment-1943345964
+        let mut temp_file =
+            NamedTempFile::new_in(self.path.parent().expect("Write path must have a parent"))
+                .context("Failed to create temporary file")?;
+
+        // Serialize to in-memory buffer because hyperfine benchmark showed that it's faster than
+        // using a `BufWriter` and our cache files are small enough that streaming isn't necessary.
+        let serialized =
+            bincode::serialize(&self.package).context("Failed to serialize cache data")?;
+        temp_file
+            .write_all(&serialized)
+            .context("Failed to write serialized cache to temporary file.")?;
+
+        temp_file.persist(&self.path).with_context(|| {
             format!(
-                "Failed to serialise cache to file '{}'",
+                "Failed to rename temporary cache file to {}",
                 self.path.display()
             )
-        })
+        })?;
+
+        Ok(())
     }
 
     /// Applies the pending changes without storing the cache to disk.
@@ -368,7 +383,7 @@ pub(crate) fn init(path: &Path) -> Result<()> {
     let gitignore_path = path.join(".gitignore");
     if !gitignore_path.exists() {
         let mut file = fs::File::create(gitignore_path)?;
-        file.write_all(b"*")?;
+        file.write_all(b"# Automatically created by ruff.\n*\n")?;
     }
 
     Ok(())

crates/ruff/src/commands/add_noqa.rs

@@ -12,17 +12,17 @@ use ruff_linter::warn_user_once;
 use ruff_python_ast::{PySourceType, SourceType};
 use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, ResolvedFile};
 
-use crate::args::CliOverrides;
+use crate::args::ConfigArguments;
 
 /// Add `noqa` directives to a collection of files.
 pub(crate) fn add_noqa(
     files: &[PathBuf],
     pyproject_config: &PyprojectConfig,
-    overrides: &CliOverrides,
+    config_arguments: &ConfigArguments,
 ) -> Result<usize> {
     // Collect all the files to check.
     let start = Instant::now();
-    let (paths, resolver) = python_files_in_path(files, pyproject_config, overrides)?;
+    let (paths, resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
     let duration = start.elapsed();
     debug!("Identified files to lint in: {:?}", duration);
 

crates/ruff/src/commands/check.rs

@@ -24,7 +24,7 @@ use ruff_workspace::resolver::{
     match_exclusion, python_files_in_path, PyprojectConfig, ResolvedFile,
 };
 
-use crate::args::CliOverrides;
+use crate::args::ConfigArguments;
 use crate::cache::{Cache, PackageCacheMap, PackageCaches};
 use crate::diagnostics::Diagnostics;
 use crate::panic::catch_unwind;
@@ -34,7 +34,7 @@ use crate::panic::catch_unwind;
 pub(crate) fn check(
     files: &[PathBuf],
     pyproject_config: &PyprojectConfig,
-    overrides: &CliOverrides,
+    config_arguments: &ConfigArguments,
     cache: flags::Cache,
     noqa: flags::Noqa,
     fix_mode: flags::FixMode,
@@ -42,7 +42,7 @@ pub(crate) fn check(
 ) -> Result<Diagnostics> {
     // Collect all the Python files to check.
     let start = Instant::now();
-    let (paths, resolver) = python_files_in_path(files, pyproject_config, overrides)?;
+    let (paths, resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
     debug!("Identified files to lint in: {:?}", start.elapsed());
 
     if paths.is_empty() {
@@ -233,7 +233,7 @@ mod test {
     use ruff_workspace::resolver::{PyprojectConfig, PyprojectDiscoveryStrategy};
     use ruff_workspace::Settings;
 
-    use crate::args::CliOverrides;
+    use crate::args::ConfigArguments;
 
     use super::check;
 
@@ -272,7 +272,7 @@ mod test {
             // Notebooks are not included by default
             &[tempdir.path().to_path_buf(), notebook],
             &pyproject_config,
-            &CliOverrides::default(),
+            &ConfigArguments::default(),
             flags::Cache::Disabled,
             flags::Noqa::Disabled,
             flags::FixMode::Generate,

crates/ruff/src/commands/check_stdin.rs

@@ -6,7 +6,7 @@ use ruff_linter::packaging;
 use ruff_linter::settings::flags;
 use ruff_workspace::resolver::{match_exclusion, python_file_at_path, PyprojectConfig, Resolver};
 
-use crate::args::CliOverrides;
+use crate::args::ConfigArguments;
 use crate::diagnostics::{lint_stdin, Diagnostics};
 use crate::stdin::{parrot_stdin, read_from_stdin};
 
@@ -14,7 +14,7 @@ use crate::stdin::{parrot_stdin, read_from_stdin};
 pub(crate) fn check_stdin(
     filename: Option<&Path>,
     pyproject_config: &PyprojectConfig,
-    overrides: &CliOverrides,
+    overrides: &ConfigArguments,
     noqa: flags::Noqa,
     fix_mode: flags::FixMode,
 ) -> Result<Diagnostics> {

crates/ruff/src/commands/format.rs

@@ -29,7 +29,7 @@ use ruff_text_size::{TextLen, TextRange, TextSize};
 use ruff_workspace::resolver::{match_exclusion, python_files_in_path, ResolvedFile, Resolver};
 use ruff_workspace::FormatterSettings;
 
-use crate::args::{CliOverrides, FormatArguments, FormatRange};
+use crate::args::{ConfigArguments, FormatArguments, FormatRange};
 use crate::cache::{Cache, FileCacheKey, PackageCacheMap, PackageCaches};
 use crate::panic::{catch_unwind, PanicError};
 use crate::resolve::resolve;
@@ -60,18 +60,12 @@ impl FormatMode {
 /// Format a set of files, and return the exit status.
 pub(crate) fn format(
     cli: FormatArguments,
-    overrides: &CliOverrides,
-    log_level: LogLevel,
+    config_arguments: &ConfigArguments,
 ) -> Result<ExitStatus> {
-    let pyproject_config = resolve(
-        cli.isolated,
-        cli.config.as_deref(),
-        overrides,
-        cli.stdin_filename.as_deref(),
-    )?;
+    let pyproject_config = resolve(config_arguments, cli.stdin_filename.as_deref())?;
     let mode = FormatMode::from_cli(&cli);
     let files = resolve_default_files(cli.files, false);
-    let (paths, resolver) = python_files_in_path(&files, &pyproject_config, overrides)?;
+    let (paths, resolver) = python_files_in_path(&files, &pyproject_config, config_arguments)?;
 
     if paths.is_empty() {
         warn_user_once!("No Python files found under the given path(s)");
@@ -203,7 +197,7 @@ pub(crate) fn format(
     }
 
     // Report on the formatting changes.
-    if log_level >= LogLevel::Default {
+    if config_arguments.log_level >= LogLevel::Default {
         if mode.is_diff() {
             // Allow piping the diff to e.g. a file by writing the summary to stderr
             results.write_summary(&mut stderr().lock())?;
@@ -533,7 +527,7 @@ impl<'a> FormatResults<'a> {
             })
             .sorted_unstable_by_key(|(path, _, _)| *path)
         {
-            unformatted.diff(formatted, Some(path), f)?;
+            write!(f, "{}", unformatted.diff(formatted, Some(path)).unwrap())?;
         }
 
         Ok(())

crates/ruff/src/commands/format_stdin.rs

@@ -9,7 +9,7 @@ use ruff_python_ast::{PySourceType, SourceType};
 use ruff_workspace::resolver::{match_exclusion, python_file_at_path, Resolver};
 use ruff_workspace::FormatterSettings;
 
-use crate::args::{CliOverrides, FormatArguments, FormatRange};
+use crate::args::{ConfigArguments, FormatArguments, FormatRange};
 use crate::commands::format::{
     format_source, warn_incompatible_formatter_settings, FormatCommandError, FormatMode,
     FormatResult, FormattedSource,
@@ -19,13 +19,11 @@ use crate::stdin::{parrot_stdin, read_from_stdin};
 use crate::ExitStatus;
 
 /// Run the formatter over a single file, read from `stdin`.
-pub(crate) fn format_stdin(cli: &FormatArguments, overrides: &CliOverrides) -> Result<ExitStatus> {
-    let pyproject_config = resolve(
-        cli.isolated,
-        cli.config.as_deref(),
-        overrides,
-        cli.stdin_filename.as_deref(),
-    )?;
+pub(crate) fn format_stdin(
+    cli: &FormatArguments,
+    config_arguments: &ConfigArguments,
+) -> Result<ExitStatus> {
+    let pyproject_config = resolve(config_arguments, cli.stdin_filename.as_deref())?;
 
     let mut resolver = Resolver::new(&pyproject_config);
     warn_incompatible_formatter_settings(&resolver);
@@ -34,7 +32,7 @@ pub(crate) fn format_stdin(cli: &FormatArguments, overrides: &CliOverrides) -> R
 
     if resolver.force_exclude() {
         if let Some(filename) = cli.stdin_filename.as_deref() {
-            if !python_file_at_path(filename, &mut resolver, overrides)? {
+            if !python_file_at_path(filename, &mut resolver, config_arguments)? {
                 if mode.is_write() {
                     parrot_stdin()?;
                 }
@@ -120,9 +118,13 @@ fn format_source_code(
             }
             FormatMode::Check => {}
             FormatMode::Diff => {
-                source_kind
-                    .diff(formatted, path, &mut stdout().lock())
-                    .map_err(|err| FormatCommandError::Diff(path.map(Path::to_path_buf), err))?;
+                use std::io::Write;
+                write!(
+                    &mut stdout().lock(),
+                    "{}",
+                    source_kind.diff(formatted, path).unwrap()
+                )
+                .map_err(|err| FormatCommandError::Diff(path.map(Path::to_path_buf), err))?;
             }
         },
         FormattedSource::Unchanged => {

crates/ruff/src/commands/show_files.rs

@@ -7,17 +7,17 @@ use itertools::Itertools;
 use ruff_linter::warn_user_once;
 use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, ResolvedFile};
 
-use crate::args::CliOverrides;
+use crate::args::ConfigArguments;
 
 /// Show the list of files to be checked based on current settings.
 pub(crate) fn show_files(
     files: &[PathBuf],
     pyproject_config: &PyprojectConfig,
-    overrides: &CliOverrides,
+    config_arguments: &ConfigArguments,
     writer: &mut impl Write,
 ) -> Result<()> {
     // Collect all files in the hierarchy.
-    let (paths, _resolver) = python_files_in_path(files, pyproject_config, overrides)?;
+    let (paths, _resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
 
     if paths.is_empty() {
         warn_user_once!("No Python files found under the given path(s)");

crates/ruff/src/commands/show_settings.rs

@@ -6,17 +6,17 @@ use itertools::Itertools;
 
 use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, ResolvedFile};
 
-use crate::args::CliOverrides;
+use crate::args::ConfigArguments;
 
 /// Print the user-facing configuration settings.
 pub(crate) fn show_settings(
     files: &[PathBuf],
     pyproject_config: &PyprojectConfig,
-    overrides: &CliOverrides,
+    config_arguments: &ConfigArguments,
     writer: &mut impl Write,
 ) -> Result<()> {
     // Collect all files in the hierarchy.
-    let (paths, resolver) = python_files_in_path(files, pyproject_config, overrides)?;
+    let (paths, resolver) = python_files_in_path(files, pyproject_config, config_arguments)?;
 
     // Print the list of files.
     let Some(path) = paths

crates/ruff/src/diagnostics.rs

@@ -3,6 +3,7 @@
 use std::borrow::Cow;
 use std::fs::File;
 use std::io;
+use std::io::Write;
 use std::ops::{Add, AddAssign};
 use std::path::Path;
 
@@ -289,10 +290,10 @@ pub(crate) fn lint_path(
                 match fix_mode {
                     flags::FixMode::Apply => transformed.write(&mut File::create(path)?)?,
                     flags::FixMode::Diff => {
-                        source_kind.diff(
-                            transformed.as_ref(),
-                            Some(path),
+                        write!(
                             &mut io::stdout().lock(),
+                            "{}",
+                            source_kind.diff(&transformed, Some(path)).unwrap()
                         )?;
                     }
                     flags::FixMode::Generate => {}
@@ -442,7 +443,11 @@ pub(crate) fn lint_stdin(
                 flags::FixMode::Diff => {
                     // But only write a diff if it's non-empty.
                     if !fixed.is_empty() {
-                        source_kind.diff(transformed.as_ref(), path, &mut io::stdout().lock())?;
+                        write!(
+                            &mut io::stdout().lock(),
+                            "{}",
+                            source_kind.diff(&transformed, path).unwrap()
+                        )?;
                     }
                 }
                 flags::FixMode::Generate => {}

crates/ruff/src/lib.rs

@@ -7,6 +7,7 @@ use std::process::ExitCode;
 use std::sync::mpsc::channel;
 
 use anyhow::Result;
+use args::GlobalConfigArgs;
 use clap::CommandFactory;
 use colored::Colorize;
 use log::warn;
@@ -18,7 +19,7 @@ use ruff_linter::settings::types::SerializationFormat;
 use ruff_linter::{fs, warn_user, warn_user_once};
 use ruff_workspace::Settings;
 
-use crate::args::{Args, CheckCommand, Command, FormatCommand, HelpFormat};
+use crate::args::{Args, CheckCommand, Command, FormatCommand};
 use crate::printer::{Flags as PrinterFlags, Printer};
 
 pub mod args;
@@ -114,20 +115,12 @@ fn resolve_default_files(files: Vec<PathBuf>, is_stdin: bool) -> Vec<PathBuf> {
     }
 }
 
-/// Get the actual value of the `format` desired from either `output_format`
-/// or `format`, and warn the user if they're using the deprecated form.
-fn resolve_help_output_format(output_format: HelpFormat, format: Option<HelpFormat>) -> HelpFormat {
-    if format.is_some() {
-        warn_user!("The `--format` argument is deprecated. Use `--output-format` instead.");
-    }
-    format.unwrap_or(output_format)
-}
-
 pub fn run(
     Args {
         command,
-        log_level_args,
+        global_options,
     }: Args,
+    deprecated_alias_warning: Option<&'static str>,
 ) -> Result<ExitStatus> {
     {
         let default_panic_hook = std::panic::take_hook();
@@ -155,8 +148,11 @@ pub fn run(
     #[cfg(windows)]
     assert!(colored::control::set_virtual_terminal(true).is_ok());
 
-    let log_level = LogLevel::from(&log_level_args);
-    set_up_logging(&log_level)?;
+    set_up_logging(global_options.log_level())?;
+
+    if let Some(deprecated_alias_warning) = deprecated_alias_warning {
+        warn_user!("{}", deprecated_alias_warning);
+    }
 
     match command {
         Command::Version { output_format } => {
@@ -166,10 +162,8 @@ pub fn run(
         Command::Rule {
             rule,
             all,
-            format,
-            mut output_format,
+            output_format,
         } => {
-            output_format = resolve_help_output_format(output_format, format);
             if all {
                 commands::rule::rules(output_format)?;
             }
@@ -182,48 +176,39 @@ pub fn run(
             commands::config::config(option.as_deref())?;
             Ok(ExitStatus::Success)
         }
-        Command::Linter {
-            format,
-            mut output_format,
-        } => {
-            output_format = resolve_help_output_format(output_format, format);
+        Command::Linter { output_format } => {
             commands::linter::linter(output_format)?;
             Ok(ExitStatus::Success)
         }
         Command::Clean => {
-            commands::clean::clean(log_level)?;
+            commands::clean::clean(global_options.log_level())?;
             Ok(ExitStatus::Success)
         }
         Command::GenerateShellCompletion { shell } => {
             shell.generate(&mut Args::command(), &mut stdout());
             Ok(ExitStatus::Success)
         }
-        Command::Check(args) => check(args, log_level),
-        Command::Format(args) => format(args, log_level),
+        Command::Check(args) => check(args, global_options),
+        Command::Format(args) => format(args, global_options),
     }
 }
 
-fn format(args: FormatCommand, log_level: LogLevel) -> Result<ExitStatus> {
-    let (cli, overrides) = args.partition();
+fn format(args: FormatCommand, global_options: GlobalConfigArgs) -> Result<ExitStatus> {
+    let (cli, config_arguments) = args.partition(global_options)?;
 
     if is_stdin(&cli.files, cli.stdin_filename.as_deref()) {
-        commands::format_stdin::format_stdin(&cli, &overrides)
+        commands::format_stdin::format_stdin(&cli, &config_arguments)
     } else {
-        commands::format::format(cli, &overrides, log_level)
+        commands::format::format(cli, &config_arguments)
     }
 }
 
-pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
-    let (cli, overrides) = args.partition();
+pub fn check(args: CheckCommand, global_options: GlobalConfigArgs) -> Result<ExitStatus> {
+    let (cli, config_arguments) = args.partition(global_options)?;
 
     // Construct the "default" settings. These are used when no `pyproject.toml`
     // files are present, or files are injected from outside of the hierarchy.
-    let pyproject_config = resolve::resolve(
-        cli.isolated,
-        cli.config.as_deref(),
-        &overrides,
-        cli.stdin_filename.as_deref(),
-    )?;
+    let pyproject_config = resolve::resolve(&config_arguments, cli.stdin_filename.as_deref())?;
 
     let mut writer: Box<dyn Write> = match cli.output_file {
         Some(path) if !cli.watch => {
@@ -239,11 +224,21 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
     let files = resolve_default_files(cli.files, is_stdin);
 
     if cli.show_settings {
-        commands::show_settings::show_settings(&files, &pyproject_config, &overrides, &mut writer)?;
+        commands::show_settings::show_settings(
+            &files,
+            &pyproject_config,
+            &config_arguments,
+            &mut writer,
+        )?;
         return Ok(ExitStatus::Success);
     }
     if cli.show_files {
-        commands::show_files::show_files(&files, &pyproject_config, &overrides, &mut writer)?;
+        commands::show_files::show_files(
+            &files,
+            &pyproject_config,
+            &config_arguments,
+            &mut writer,
+        )?;
         return Ok(ExitStatus::Success);
     }
 
@@ -302,8 +297,9 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
         if !fix_mode.is_generate() {
             warn_user!("--fix is incompatible with --add-noqa.");
         }
-        let modifications = commands::add_noqa::add_noqa(&files, &pyproject_config, &overrides)?;
-        if modifications > 0 && log_level >= LogLevel::Default {
+        let modifications =
+            commands::add_noqa::add_noqa(&files, &pyproject_config, &config_arguments)?;
+        if modifications > 0 && config_arguments.log_level >= LogLevel::Default {
             let s = if modifications == 1 { "" } else { "s" };
             #[allow(clippy::print_stderr)]
             {
@@ -315,7 +311,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
 
     let printer = Printer::new(
         output_format,
-        log_level,
+        config_arguments.log_level,
         fix_mode,
         unsafe_fixes,
         printer_flags,
@@ -352,7 +348,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
         let messages = commands::check::check(
             &files,
             &pyproject_config,
-            &overrides,
+            &config_arguments,
             cache.into(),
             noqa.into(),
             fix_mode,
@@ -372,12 +368,8 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
                     };
 
                     if matches!(change_kind, ChangeKind::Configuration) {
-                        pyproject_config = resolve::resolve(
-                            cli.isolated,
-                            cli.config.as_deref(),
-                            &overrides,
-                            cli.stdin_filename.as_deref(),
-                        )?;
+                        pyproject_config =
+                            resolve::resolve(&config_arguments, cli.stdin_filename.as_deref())?;
                     }
                     Printer::clear_screen()?;
                     printer.write_to_user("File change detected...\n");
@@ -385,7 +377,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
                     let messages = commands::check::check(
                         &files,
                         &pyproject_config,
-                        &overrides,
+                        &config_arguments,
                         cache.into(),
                         noqa.into(),
                         fix_mode,
@@ -402,7 +394,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
             commands::check_stdin::check_stdin(
                 cli.stdin_filename.map(fs::normalize_path).as_deref(),
                 &pyproject_config,
-                &overrides,
+                &config_arguments,
                 noqa.into(),
                 fix_mode,
             )?
@@ -410,7 +402,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
             commands::check::check(
                 &files,
                 &pyproject_config,
-                &overrides,
+                &config_arguments,
                 cache.into(),
                 noqa.into(),
                 fix_mode,

crates/ruff/src/main.rs

@@ -27,26 +27,42 @@ pub fn main() -> ExitCode {
     let mut args =
         argfile::expand_args_from(args, argfile::parse_fromfile, argfile::PREFIX).unwrap();
 
-    // Clap doesn't support default subcommands but we want to run `check` by
-    // default for convenience and backwards-compatibility, so we just
-    // preprocess the arguments accordingly before passing them to Clap.
-    if let Some(arg) = args.get(1) {
-        if arg
-            .to_str()
-            .is_some_and(|arg| !Command::has_subcommand(rewrite_legacy_subcommand(arg)))
+    // We can't use `warn_user` here because logging isn't set up at this point
+    // and we also don't know if the user runs ruff with quiet.
+    // Keep the message and pass it to `run` that is responsible for emitting the warning.
+    let deprecated_alias_warning = match args.get(1).and_then(|arg| arg.to_str()) {
+        // Deprecated aliases that are handled by clap
+        Some("--explain") => {
+            Some("`ruff --explain <RULE>` is deprecated. Use `ruff rule <RULE>` instead.")
+        }
+        Some("--clean") => {
+            Some("`ruff --clean` is deprecated. Use `ruff clean` instead.")
+        }
+        Some("--generate-shell-completion") => {
+            Some("`ruff --generate-shell-completion <SHELL>` is deprecated. Use `ruff generate-shell-completion <SHELL>` instead.")
+        }
+        // Deprecated `ruff` alias to `ruff check`
+        // Clap doesn't support default subcommands but we want to run `check` by
+        // default for convenience and backwards-compatibility, so we just
+        // preprocess the arguments accordingly before passing them to Clap.
+        Some(arg) if !Command::has_subcommand(arg)
             && arg != "-h"
             && arg != "--help"
             && arg != "-V"
             && arg != "--version"
-            && arg != "help"
-        {
-            args.insert(1, "check".into());
-        }
-    }
+            && arg != "help" => {
+
+            {
+                args.insert(1, "check".into());
+                Some("`ruff <path>` is deprecated. Use `ruff check <path>` instead.")
+            }
+        },
+        _ => None
+    };
 
     let args = Args::parse_from(args);
 
-    match run(args) {
+    match run(args, deprecated_alias_warning) {
         Ok(code) => code.into(),
         Err(err) => {
             #[allow(clippy::print_stderr)]
@@ -65,12 +81,3 @@ pub fn main() -> ExitCode {
         }
     }
 }
-
-fn rewrite_legacy_subcommand(cmd: &str) -> &str {
-    match cmd {
-        "--explain" => "rule",
-        "--clean" => "clean",
-        "--generate-shell-completion" => "generate-shell-completion",
-        cmd => cmd,
-    }
-}

crates/ruff/src/resolve.rs

@@ -1,4 +1,4 @@
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
 use anyhow::Result;
 use log::debug;
@@ -11,19 +11,17 @@ use ruff_workspace::resolver::{
     Relativity,
 };
 
-use crate::args::CliOverrides;
+use crate::args::ConfigArguments;
 
 /// Resolve the relevant settings strategy and defaults for the current
 /// invocation.
 pub fn resolve(
-    isolated: bool,
-    config: Option<&Path>,
-    overrides: &CliOverrides,
+    config_arguments: &ConfigArguments,
     stdin_filename: Option<&Path>,
 ) -> Result<PyprojectConfig> {
     // First priority: if we're running in isolated mode, use the default settings.
-    if isolated {
-        let config = overrides.transform(Configuration::default());
+    if config_arguments.isolated {
+        let config = config_arguments.transform(Configuration::default());
         let settings = config.into_settings(&path_dedot::CWD)?;
         debug!("Isolated mode, not reading any pyproject.toml");
         return Ok(PyprojectConfig::new(
@@ -36,12 +34,8 @@ pub fn resolve(
     // Second priority: the user specified a `pyproject.toml` file. Use that
     // `pyproject.toml` for _all_ configuration, and resolve paths relative to the
     // current working directory. (This matches ESLint's behavior.)
-    if let Some(pyproject) = config
-        .map(|config| config.display().to_string())
-        .map(|config| shellexpand::full(&config).map(|config| PathBuf::from(config.as_ref())))
-        .transpose()?
-    {
-        let settings = resolve_root_settings(&pyproject, Relativity::Cwd, overrides)?;
+    if let Some(pyproject) = config_arguments.config_file() {
+        let settings = resolve_root_settings(pyproject, Relativity::Cwd, config_arguments)?;
         debug!(
             "Using user-specified configuration file at: {}",
             pyproject.display()
@@ -49,7 +43,7 @@ pub fn resolve(
         return Ok(PyprojectConfig::new(
             PyprojectDiscoveryStrategy::Fixed,
             settings,
-            Some(pyproject),
+            Some(pyproject.to_path_buf()),
         ));
     }
 
@@ -67,7 +61,7 @@ pub fn resolve(
             "Using configuration file (via parent) at: {}",
             pyproject.display()
         );
-        let settings = resolve_root_settings(&pyproject, Relativity::Parent, overrides)?;
+        let settings = resolve_root_settings(&pyproject, Relativity::Parent, config_arguments)?;
         return Ok(PyprojectConfig::new(
             PyprojectDiscoveryStrategy::Hierarchical,
             settings,
@@ -84,7 +78,7 @@ pub fn resolve(
             "Using configuration file (via cwd) at: {}",
             pyproject.display()
         );
-        let settings = resolve_root_settings(&pyproject, Relativity::Cwd, overrides)?;
+        let settings = resolve_root_settings(&pyproject, Relativity::Cwd, config_arguments)?;
         return Ok(PyprojectConfig::new(
             PyprojectDiscoveryStrategy::Hierarchical,
             settings,
@@ -97,7 +91,7 @@ pub fn resolve(
     // "closest" `pyproject.toml` file for every Python file later on, so these act
     // as the "default" settings.)
     debug!("Using Ruff default settings");
-    let config = overrides.transform(Configuration::default());
+    let config = config_arguments.transform(Configuration::default());
     let settings = config.into_settings(&path_dedot::CWD)?;
     Ok(PyprojectConfig::new(
         PyprojectDiscoveryStrategy::Hierarchical,

crates/ruff/tests/deprecation.rs

@@ -12,9 +12,10 @@ const STDIN: &str = "l = 1";
 fn ruff_check(show_source: Option<bool>, output_format: Option<String>) -> Command {
     let mut cmd = Command::new(get_cargo_bin(BIN_NAME));
     let output_format = output_format.unwrap_or(format!("{}", SerializationFormat::default(false)));
-    cmd.arg("--output-format");
-    cmd.arg(output_format);
-    cmd.arg("--no-cache");
+    cmd.arg("check")
+        .arg("--output-format")
+        .arg(output_format)
+        .arg("--no-cache");
     match show_source {
         Some(true) => {
             cmd.arg("--show-source");

crates/ruff/tests/format.rs

@@ -7,10 +7,15 @@ use std::str;
 
 use anyhow::Result;
 use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
+use regex::escape;
 use tempfile::TempDir;
 
 const BIN_NAME: &str = "ruff";
 
+fn tempdir_filter(tempdir: &TempDir) -> String {
+    format!(r"{}\\?/?", escape(tempdir.path().to_str().unwrap()))
+}
+
 #[test]
 fn default_options() {
     assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
@@ -90,6 +95,182 @@ fn format_warn_stdin_filename_with_files() {
     "###);
 }
 
+#[test]
+fn nonexistent_config_file() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--config", "foo.toml", "."]), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'foo.toml' for '--config <CONFIG_OPTION>'
+
+      tip: A `--config` flag must either be a path to a `.toml` configuration file
+           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+           option
+
+    It looks like you were trying to pass a path to a configuration file.
+    The path `foo.toml` does not point to a configuration file
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn config_override_rejected_if_invalid_toml() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--config", "foo = bar", "."]), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'foo = bar' for '--config <CONFIG_OPTION>'
+
+      tip: A `--config` flag must either be a path to a `.toml` configuration file
+           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+           option
+
+    The supplied argument is not valid TOML:
+
+    TOML parse error at line 1, column 7
+      |
+    1 | foo = bar
+      |       ^
+    invalid string
+    expected `"`, `'`
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn too_many_config_files() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_dot_toml = tempdir.path().join("ruff.toml");
+    let ruff2_dot_toml = tempdir.path().join("ruff2.toml");
+    fs::File::create(&ruff_dot_toml)?;
+    fs::File::create(&ruff2_dot_toml)?;
+    insta::with_settings!({
+        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/")]
+    }, {
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .arg("format")
+        .arg("--config")
+        .arg(&ruff_dot_toml)
+        .arg("--config")
+        .arg(&ruff2_dot_toml)
+        .arg("."), @r###"
+            success: false
+            exit_code: 2
+            ----- stdout -----
+
+            ----- stderr -----
+            ruff failed
+              Cause: You cannot specify more than one configuration file on the command line.
+
+              tip: remove either `--config=[TMP]/ruff.toml` or `--config=[TMP]/ruff2.toml`.
+                   For more information, try `--help`.
+
+            "###);
+    });
+    Ok(())
+}
+
+#[test]
+fn config_file_and_isolated() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_dot_toml = tempdir.path().join("ruff.toml");
+    fs::File::create(&ruff_dot_toml)?;
+    insta::with_settings!({
+        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/")]
+    }, {
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .arg("format")
+        .arg("--config")
+        .arg(&ruff_dot_toml)
+        .arg("--isolated")
+        .arg("."), @r###"
+        success: false
+        exit_code: 2
+        ----- stdout -----
+
+        ----- stderr -----
+        ruff failed
+          Cause: The argument `--config=[TMP]/ruff.toml` cannot be used with `--isolated`
+
+          tip: You cannot specify a configuration file and also specify `--isolated`,
+               as `--isolated` causes ruff to ignore all configuration files.
+               For more information, try `--help`.
+
+        "###);
+    });
+    Ok(())
+}
+
+#[test]
+fn config_override_via_cli() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(&ruff_toml, "line-length = 100")?;
+    let fixture = r#"
+def foo():
+    print("looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string")
+
+    "#;
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .arg("format")
+        .arg("--config")
+        .arg(&ruff_toml)
+        // This overrides the long line length set in the config file
+        .args(["--config", "line-length=80"])
+        .arg("-")
+        .pass_stdin(fixture), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    def foo():
+        print(
+            "looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string"
+        )
+
+    ----- stderr -----
+    "###);
+    Ok(())
+}
+
+#[test]
+fn config_doubly_overridden_via_cli() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(&ruff_toml, "line-length = 70")?;
+    let fixture = r#"
+def foo():
+    print("looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string")
+
+    "#;
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .arg("format")
+        .arg("--config")
+        .arg(&ruff_toml)
+        // This overrides the long line length set in the config file...
+        .args(["--config", "line-length=80"])
+        // ...but this overrides them both:
+        .args(["--line-length", "100"])
+        .arg("-")
+        .pass_stdin(fixture), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    def foo():
+        print("looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string")
+
+    ----- stderr -----
+    "###);
+    Ok(())
+}
+
 #[test]
 fn format_options() -> Result<()> {
     let tempdir = TempDir::new()?;
@@ -177,58 +358,52 @@ def f(x):
     '''
     pass
 "#), @r###"
-success: true
-exit_code: 0
------ stdout -----
-def f(x):
-    """
-    Something about `f`. And an example:
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    def f(x):
+        """
+        Something about `f`. And an example:
 
-    .. code-block:: python
+        .. code-block:: python
 
-        (
-            foo,
-            bar,
-            quux,
-        ) = this_is_a_long_line(
-            lion,
-            hippo,
-            lemur,
-            bear,
+            foo, bar, quux = (
+                this_is_a_long_line(
+                    lion,
+                    hippo,
+                    lemur,
+                    bear,
+                )
+            )
+
+        Another example:
+
+        ```py
+        foo, bar, quux = (
+            this_is_a_long_line(
+                lion,
+                hippo,
+                lemur,
+                bear,
+            )
         )
+        ```
 
-    Another example:
+        And another:
 
-    ```py
-    (
-        foo,
-        bar,
-        quux,
-    ) = this_is_a_long_line(
-        lion,
-        hippo,
-        lemur,
-        bear,
-    )
-    ```
+        >>> foo, bar, quux = (
+        ...     this_is_a_long_line(
+        ...         lion,
+        ...         hippo,
+        ...         lemur,
+        ...         bear,
+        ...     )
+        ... )
+        """
+        pass
 
-    And another:
-
-    >>> (
-    ...     foo,
-    ...     bar,
-    ...     quux,
-    ... ) = this_is_a_long_line(
-    ...     lion,
-    ...     hippo,
-    ...     lemur,
-    ...     bear,
-    ... )
-    """
-    pass
-
------ stderr -----
-"###);
+    ----- stderr -----
+    "###);
     Ok(())
 }
 

crates/ruff/tests/integration_test.rs

@@ -71,6 +71,7 @@ impl<'a> RuffCheck<'a> {
     /// Generate a [`Command`] for the `ruff check` command.
     fn build(self) -> Command {
         let mut cmd = ruff_cmd();
+        cmd.arg("check");
         if let Some(output_format) = self.output_format {
             cmd.args(["--output-format", output_format]);
         }
@@ -805,13 +806,13 @@ fn full_output_format() {
 }
 
 #[test]
-fn explain_status_codes_f401() {
-    assert_cmd_snapshot!(ruff_cmd().args(["--explain", "F401"]));
+fn rule_f401() {
+    assert_cmd_snapshot!(ruff_cmd().args(["rule", "F401"]));
 }
 
 #[test]
-fn explain_status_codes_ruf404() {
-    assert_cmd_snapshot!(ruff_cmd().args(["--explain", "RUF404"]), @r###"
+fn rule_invalid_rule_name() {
+    assert_cmd_snapshot!(ruff_cmd().args(["rule", "RUF404"]), @r###"
     success: false
     exit_code: 2
     ----- stdout -----
@@ -1348,7 +1349,7 @@ fn unreadable_pyproject_toml() -> Result<()> {
 
     // Don't `--isolated` since the configuration discovery is where the error happens
     let args = Args::parse_from(["", "check", "--no-cache", tempdir.path().to_str().unwrap()]);
-    let err = run(args).err().context("Unexpected success")?;
+    let err = run(args, None).err().context("Unexpected success")?;
     assert_eq!(
         err.chain()
             .map(std::string::ToString::to_string)

crates/ruff/tests/lint.rs

@@ -12,7 +12,7 @@ use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
 use tempfile::TempDir;
 
 const BIN_NAME: &str = "ruff";
-const STDIN_BASE_OPTIONS: &[&str] = &["--no-cache", "--output-format", "concise"];
+const STDIN_BASE_OPTIONS: &[&str] = &["check", "--no-cache", "--output-format", "concise"];
 
 fn tempdir_filter(tempdir: &TempDir) -> String {
     format!(r"{}\\?/?", escape(tempdir.path().to_str().unwrap()))
@@ -246,7 +246,6 @@ OTHER = "OTHER"
     }, {
     assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
         .current_dir(tempdir.path())
-        .arg("check")
         .args(STDIN_BASE_OPTIONS)
         .args(["--config", &ruff_toml.file_name().unwrap().to_string_lossy()])
         // Explicitly pass test.py, should be linted regardless of it being excluded by lint.exclude
@@ -293,7 +292,6 @@ inline-quotes = "single"
     }, {
     assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
         .current_dir(tempdir.path())
-        .arg("check")
         .args(STDIN_BASE_OPTIONS)
         .args(["--config", &ruff_toml.file_name().unwrap().to_string_lossy()])
         .args(["--stdin-filename", "generated.py"])
@@ -386,7 +384,6 @@ inline-quotes = "single"
     }, {
     assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
         .current_dir(tempdir.path())
-        .arg("check")
         .args(STDIN_BASE_OPTIONS)
         .args(["--config", &ruff_toml.file_name().unwrap().to_string_lossy()])
         .args(["--stdin-filename", "generated.py"])
@@ -435,7 +432,6 @@ inline-quotes = "single"
     }, {
     assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
         .current_dir(tempdir.path())
-        .arg("check")
         .args(STDIN_BASE_OPTIONS)
         .args(["--config", &ruff_toml.file_name().unwrap().to_string_lossy()])
         .args(["--stdin-filename", "generated.py"])
@@ -495,7 +491,6 @@ ignore = ["D203", "D212"]
     }, {
     assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
         .current_dir(sub_dir)
-        .arg("check")
         .args(STDIN_BASE_OPTIONS)
         , @r###"
     success: true
@@ -510,6 +505,359 @@ ignore = ["D203", "D212"]
     Ok(())
 }
 
+#[test]
+fn nonexistent_config_file() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--config", "foo.toml", "."]), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'foo.toml' for '--config <CONFIG_OPTION>'
+
+      tip: A `--config` flag must either be a path to a `.toml` configuration file
+           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+           option
+
+    It looks like you were trying to pass a path to a configuration file.
+    The path `foo.toml` does not point to a configuration file
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn config_override_rejected_if_invalid_toml() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--config", "foo = bar", "."]), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'foo = bar' for '--config <CONFIG_OPTION>'
+
+      tip: A `--config` flag must either be a path to a `.toml` configuration file
+           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+           option
+
+    The supplied argument is not valid TOML:
+
+    TOML parse error at line 1, column 7
+      |
+    1 | foo = bar
+      |       ^
+    invalid string
+    expected `"`, `'`
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn too_many_config_files() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_dot_toml = tempdir.path().join("ruff.toml");
+    let ruff2_dot_toml = tempdir.path().join("ruff2.toml");
+    fs::File::create(&ruff_dot_toml)?;
+    fs::File::create(&ruff2_dot_toml)?;
+    insta::with_settings!({
+        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/")]
+    }, {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--config")
+        .arg(&ruff_dot_toml)
+        .arg("--config")
+        .arg(&ruff2_dot_toml)
+        .arg("."), @r###"
+        success: false
+        exit_code: 2
+        ----- stdout -----
+
+        ----- stderr -----
+        ruff failed
+          Cause: You cannot specify more than one configuration file on the command line.
+
+          tip: remove either `--config=[TMP]/ruff.toml` or `--config=[TMP]/ruff2.toml`.
+               For more information, try `--help`.
+
+        "###);
+    });
+    Ok(())
+}
+
+#[test]
+fn extend_passed_via_config_argument() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--config", "extend = 'foo.toml'", "."]), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'extend = 'foo.toml'' for '--config <CONFIG_OPTION>'
+
+      tip: Cannot include `extend` in a --config flag value
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn config_file_and_isolated() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_dot_toml = tempdir.path().join("ruff.toml");
+    fs::File::create(&ruff_dot_toml)?;
+    insta::with_settings!({
+        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/")]
+    }, {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--config")
+        .arg(&ruff_dot_toml)
+        .arg("--isolated")
+        .arg("."), @r###"
+        success: false
+        exit_code: 2
+        ----- stdout -----
+
+        ----- stderr -----
+        ruff failed
+          Cause: The argument `--config=[TMP]/ruff.toml` cannot be used with `--isolated`
+
+          tip: You cannot specify a configuration file and also specify `--isolated`,
+               as `--isolated` causes ruff to ignore all configuration files.
+               For more information, try `--help`.
+
+        "###);
+    });
+    Ok(())
+}
+
+#[test]
+fn config_override_via_cli() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        r#"
+line-length = 100
+
+[lint]
+select = ["I"]
+
+[lint.isort]
+combine-as-imports = true
+        "#,
+    )?;
+    let fixture = r#"
+from foo import (
+    aaaaaaaaaaaaaaaaaaa,
+    bbbbbbbbbbb as bbbbbbbbbbbbbbbb,
+    cccccccccccccccc,
+    ddddddddddd as ddddddddddddd,
+    eeeeeeeeeeeeeee,
+    ffffffffffff as ffffffffffffff,
+    ggggggggggggg,
+    hhhhhhh as hhhhhhhhhhh,
+    iiiiiiiiiiiiii,
+    jjjjjjjjjjjjj as jjjjjj,
+)
+
+x = "longer_than_90_charactersssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss"
+"#;
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--config")
+        .arg(&ruff_toml)
+        .args(["--config", "line-length=90"])
+        .args(["--config", "lint.extend-select=['E501', 'F841']"])
+        .args(["--config", "lint.isort.combine-as-imports = false"])
+        .arg("-")
+        .pass_stdin(fixture), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:2:1: I001 [*] Import block is un-sorted or un-formatted
+    -:15:91: E501 Line too long (97 > 90)
+    Found 2 errors.
+    [*] 1 fixable with the `--fix` option.
+
+    ----- stderr -----
+    "###);
+    Ok(())
+}
+
+#[test]
+fn valid_toml_but_nonexistent_option_provided_via_config_argument() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args([".", "--config", "extend-select=['F481']"]),  // No such code as F481!
+        @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'extend-select=['F481']' for '--config <CONFIG_OPTION>'
+
+      tip: A `--config` flag must either be a path to a `.toml` configuration file
+           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+           option
+
+    Could not parse the supplied argument as a `ruff.toml` configuration option:
+
+    Unknown rule selector: `F481`
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn each_toml_option_requires_a_new_flag_1() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        // commas can't be used to delimit different config overrides;
+        // you need a new --config flag for each override
+        .args([".", "--config", "extend-select=['F841'], line-length=90"]),
+        @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'extend-select=['F841'], line-length=90' for '--config <CONFIG_OPTION>'
+
+      tip: A `--config` flag must either be a path to a `.toml` configuration file
+           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+           option
+
+    The supplied argument is not valid TOML:
+
+    TOML parse error at line 1, column 23
+      |
+    1 | extend-select=['F841'], line-length=90
+      |                       ^
+    expected newline, `#`
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn each_toml_option_requires_a_new_flag_2() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        // spaces *also* can't be used to delimit different config overrides;
+        // you need a new --config flag for each override
+        .args([".", "--config", "extend-select=['F841'] line-length=90"]),
+        @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'extend-select=['F841'] line-length=90' for '--config <CONFIG_OPTION>'
+
+      tip: A `--config` flag must either be a path to a `.toml` configuration file
+           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+           option
+
+    The supplied argument is not valid TOML:
+
+    TOML parse error at line 1, column 24
+      |
+    1 | extend-select=['F841'] line-length=90
+      |                        ^
+    expected newline, `#`
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn config_doubly_overridden_via_cli() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        r#"
+line-length = 100
+
+[lint]
+select=["E501"]
+"#,
+    )?;
+    let fixture = "x = 'longer_than_90_charactersssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss'";
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        // The --line-length flag takes priority over both the config file
+        // and the `--config="line-length=110"` flag,
+        // despite them both being specified after this flag on the command line:
+        .args(["--line-length", "90"])
+        .arg("--config")
+        .arg(&ruff_toml)
+        .args(["--config", "line-length=110"])
+        .arg("-")
+        .pass_stdin(fixture), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:91: E501 Line too long (97 > 90)
+    Found 1 error.
+
+    ----- stderr -----
+    "###);
+    Ok(())
+}
+
+#[test]
+fn complex_config_setting_overridden_via_cli() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(&ruff_toml, "lint.select = ['N801']")?;
+    let fixture = "class violates_n801: pass";
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--config")
+        .arg(&ruff_toml)
+        .args(["--config", "lint.per-file-ignores = {'generated.py' = ['N801']}"])
+        .args(["--stdin-filename", "generated.py"])
+        .arg("-")
+        .pass_stdin(fixture), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    "###);
+    Ok(())
+}
+
+#[test]
+fn deprecated_config_option_overridden_via_cli() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--config", "select=['N801']", "-"])
+        .pass_stdin("class lowercase: ..."),
+        @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:7: N801 Class name `lowercase` should use CapWords convention
+    Found 1 error.
+
+    ----- stderr -----
+    warning: The top-level linter settings are deprecated in favour of their counterparts in the `lint` section. Please update the following options in your `--config` CLI arguments:
+      - 'select' -> 'lint.select'
+    "###);
+}
+
 #[test]
 fn extension() -> Result<()> {
     let tempdir = TempDir::new()?;
@@ -568,7 +916,6 @@ include = ["*.ipy"]
     }, {
     assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
         .current_dir(tempdir.path())
-        .arg("check")
         .args(STDIN_BASE_OPTIONS)
         .args(["--config", &ruff_toml.file_name().unwrap().to_string_lossy()])
         .args(["--extension", "ipy:ipynb"])
@@ -586,3 +933,236 @@ include = ["*.ipy"]
 
     Ok(())
 }
+
+#[test]
+fn file_noqa_external() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        r#"
+[lint]
+external = ["AAA"]
+"#,
+    )?;
+
+    insta::with_settings!({
+        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/")]
+    }, {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--config")
+        .arg(&ruff_toml)
+        .arg("-")
+        .pass_stdin(r#"
+# flake8: noqa: AAA101, BBB102
+import os
+"#), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:3:8: F401 [*] `os` imported but unused
+    Found 1 error.
+    [*] 1 fixable with the `--fix` option.
+
+    ----- stderr -----
+    warning: Invalid rule code provided to `# ruff: noqa` at -:2: BBB102
+    "###);
+    });
+
+    Ok(())
+}
+
+#[test]
+fn required_version_exact_mismatch() -> Result<()> {
+    let version = env!("CARGO_PKG_VERSION");
+
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        r#"
+required-version = "0.1.0"
+"#,
+    )?;
+
+    insta::with_settings!({
+        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/"), (version, "[VERSION]")]
+    }, {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--config")
+        .arg(&ruff_toml)
+        .arg("-")
+        .pass_stdin(r#"
+import os
+"#), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    ruff failed
+      Cause: Required version `==0.1.0` does not match the running version `[VERSION]`
+    "###);
+    });
+
+    Ok(())
+}
+
+#[test]
+fn required_version_exact_match() -> Result<()> {
+    let version = env!("CARGO_PKG_VERSION");
+
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        format!(
+            r#"
+required-version = "{version}"
+"#
+        ),
+    )?;
+
+    insta::with_settings!({
+        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/"), (version, "[VERSION]")]
+    }, {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--config")
+        .arg(&ruff_toml)
+        .arg("-")
+        .pass_stdin(r#"
+import os
+"#), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:2:8: F401 [*] `os` imported but unused
+    Found 1 error.
+    [*] 1 fixable with the `--fix` option.
+
+    ----- stderr -----
+    "###);
+    });
+
+    Ok(())
+}
+
+#[test]
+fn required_version_bound_mismatch() -> Result<()> {
+    let version = env!("CARGO_PKG_VERSION");
+
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        format!(
+            r#"
+required-version = ">{version}"
+"#
+        ),
+    )?;
+
+    insta::with_settings!({
+        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/"), (version, "[VERSION]")]
+    }, {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--config")
+        .arg(&ruff_toml)
+        .arg("-")
+        .pass_stdin(r#"
+import os
+"#), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    ruff failed
+      Cause: Required version `>[VERSION]` does not match the running version `[VERSION]`
+    "###);
+    });
+
+    Ok(())
+}
+
+#[test]
+fn required_version_bound_match() -> Result<()> {
+    let version = env!("CARGO_PKG_VERSION");
+
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        &ruff_toml,
+        r#"
+required-version = ">=0.1.0"
+"#,
+    )?;
+
+    insta::with_settings!({
+        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/"), (version, "[VERSION]")]
+    }, {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--config")
+        .arg(&ruff_toml)
+        .arg("-")
+        .pass_stdin(r#"
+import os
+"#), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:2:8: F401 [*] `os` imported but unused
+    Found 1 error.
+    [*] 1 fixable with the `--fix` option.
+
+    ----- stderr -----
+    "###);
+    });
+
+    Ok(())
+}
+
+/// Expand environment variables in `--config` paths provided via the CLI.
+#[test]
+fn config_expand() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(
+        ruff_toml,
+        r#"
+[lint]
+select = ["F"]
+ignore = ["F841"]
+"#,
+    )?;
+
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .arg("--config")
+        .arg("${NAME}.toml")
+        .env("NAME", "ruff")
+        .arg("-")
+        .current_dir(tempdir.path())
+        .pass_stdin(r#"
+import os
+
+def func():
+    x = 1
+"#), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:2:8: F401 [*] `os` imported but unused
+    Found 1 error.
+    [*] 1 fixable with the `--fix` option.
+
+    ----- stderr -----
+    "###);
+
+    Ok(())
+}

crates/ruff/tests/snapshots/integration_test__rule_f401.snap

@@ -3,7 +3,7 @@ source: crates/ruff/tests/integration_test.rs
 info:
   program: ruff
   args:
-    - "--explain"
+    - rule
     - F401
 ---
 success: true
@@ -25,6 +25,15 @@ import cycles. They also increase the cognitive load of reading the code.
 If an import statement is used to check for the availability or existence
 of a module, consider using `importlib.util.find_spec` instead.
 
+If an import statement is used to re-export a symbol as part of a module's
+public interface, consider using a "redundant" import alias, which
+instructs Ruff (and other tools) to respect the re-export, and avoid
+marking it as unused, as in:
+
+```python
+from module import member as member
+```
+
 ## Example
 ```python
 import numpy as np  # unused import
@@ -51,11 +60,11 @@ else:
 ```
 
 ## Options
-- `lint.pyflakes.extend-generics`
+- `lint.ignore-init-module-imports`
 
 ## References
 - [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)
 - [Python documentation: `importlib.util.find_spec`](https://docs.python.org/3/library/importlib.html#importlib.util.find_spec)
+- [Typing documentation: interface conventions](https://typing.readthedocs.io/en/latest/source/libraries.html#library-interface-public-and-private-symbols)
 
 ----- stderr -----
-

crates/ruff/tests/snapshots/show_settings__display_default_settings.snap

@@ -44,7 +44,6 @@ file_resolver.exclude = [
 	"__pypackages__",
 	"_build",
 	"buck-out",
-	"build",
 	"dist",
 	"node_modules",
 	"site-packages",
@@ -232,7 +231,7 @@ linter.flake8_bandit.check_typed_exception = false
 linter.flake8_bugbear.extend_immutable_calls = []
 linter.flake8_builtins.builtins_ignorelist = []
 linter.flake8_comprehensions.allow_dict_calls_with_keyword_arguments = false
-linter.flake8_copyright.notice_rgx = (?i)Copyright\s+(\(C\)\s+)?\d{4}(-\d{4})*
+linter.flake8_copyright.notice_rgx = (?i)Copyright\s+((?:\(C\)|©)\s+)?\d{4}(-\d{4})*
 linter.flake8_copyright.author = none
 linter.flake8_copyright.min_file_size = 0
 linter.flake8_errmsg.max_string_length = 0
@@ -312,6 +311,7 @@ linter.isort.section_order = [
 	known { type = first_party },
 	known { type = local_folder },
 ]
+linter.isort.default_section = known { type = third_party }
 linter.isort.no_sections = false
 linter.isort.from_first = false
 linter.isort.length_sort = false
@@ -366,4 +366,3 @@ formatter.docstring_code_format = disabled
 formatter.docstring_code_line_width = dynamic
 
 ----- stderr -----
-

crates/ruff/tests/version.rs

@@ -0,0 +1,105 @@
+//! Tests for the --version command
+use std::fs;
+use std::process::Command;
+
+use anyhow::Result;
+use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
+use tempfile::TempDir;
+
+const BIN_NAME: &str = "ruff";
+const VERSION_FILTER: [(&str, &str); 1] = [(
+    r"\d+\.\d+\.\d+(\+\d+)?( \(\w{9} \d\d\d\d-\d\d-\d\d\))?",
+    "[VERSION]",
+)];
+
+#[test]
+fn version_basics() {
+    insta::with_settings!({filters => VERSION_FILTER.to_vec()}, {
+        assert_cmd_snapshot!(
+            Command::new(get_cargo_bin(BIN_NAME)).arg("version"), @r###"
+        success: true
+        exit_code: 0
+        ----- stdout -----
+        ruff [VERSION]
+
+        ----- stderr -----
+        "###
+        );
+    });
+}
+
+/// `--config` is a global option,
+/// so it's allowed to pass --config to subcommands such as `version`
+/// -- the flag is simply ignored
+#[test]
+fn config_option_allowed_but_ignored() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_dot_toml = tempdir.path().join("ruff.toml");
+    fs::File::create(&ruff_dot_toml)?;
+    insta::with_settings!({filters => VERSION_FILTER.to_vec()}, {
+        assert_cmd_snapshot!(
+            Command::new(get_cargo_bin(BIN_NAME))
+                .arg("version")
+                .arg("--config")
+                .arg(&ruff_dot_toml)
+                .args(["--config", "lint.isort.extra-standard-library = ['foo', 'bar']"]), @r###"
+        success: true
+        exit_code: 0
+        ----- stdout -----
+        ruff [VERSION]
+
+        ----- stderr -----
+        "###
+        );
+    });
+    Ok(())
+}
+#[test]
+fn config_option_ignored_but_validated() {
+    insta::with_settings!({filters => VERSION_FILTER.to_vec()}, {
+        assert_cmd_snapshot!(
+            Command::new(get_cargo_bin(BIN_NAME))
+                .arg("version")
+                .args(["--config", "foo = bar"]), @r###"
+        success: false
+        exit_code: 2
+        ----- stdout -----
+
+        ----- stderr -----
+        error: invalid value 'foo = bar' for '--config <CONFIG_OPTION>'
+
+          tip: A `--config` flag must either be a path to a `.toml` configuration file
+               or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+               option
+
+        The supplied argument is not valid TOML:
+
+        TOML parse error at line 1, column 7
+          |
+        1 | foo = bar
+          |       ^
+        invalid string
+        expected `"`, `'`
+
+        For more information, try '--help'.
+        "###
+        );
+    });
+}
+
+/// `--isolated` is also a global option,
+#[test]
+fn isolated_option_allowed() {
+    insta::with_settings!({filters => VERSION_FILTER.to_vec()}, {
+        assert_cmd_snapshot!(
+            Command::new(get_cargo_bin(BIN_NAME)).arg("version").arg("--isolated"), @r###"
+        success: true
+        exit_code: 0
+        ----- stdout -----
+        ruff [VERSION]
+
+        ----- stderr -----
+        "###
+        );
+    });
+}

crates/ruff_benchmark/Cargo.toml

@@ -13,6 +13,7 @@ license = { workspace = true }
 
 [lib]
 bench = false
+doctest = false
 
 [[bench]]
 name = "linter"

crates/ruff_dev/src/format_dev.rs

@@ -27,7 +27,7 @@ use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 use tracing_subscriber::EnvFilter;
 
-use ruff::args::{CliOverrides, FormatArguments, FormatCommand, LogLevelArgs};
+use ruff::args::{ConfigArguments, FormatArguments, FormatCommand, GlobalConfigArgs, LogLevelArgs};
 use ruff::resolve::resolve;
 use ruff_formatter::{FormatError, LineWidth, PrintError};
 use ruff_linter::logging::LogLevel;
@@ -38,26 +38,21 @@ use ruff_python_formatter::{
 use ruff_python_parser::ParseError;
 use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, ResolvedFile, Resolver};
 
-fn parse_cli(dirs: &[PathBuf]) -> anyhow::Result<(FormatArguments, CliOverrides)> {
+fn parse_cli(dirs: &[PathBuf]) -> anyhow::Result<(FormatArguments, ConfigArguments)> {
     let args_matches = FormatCommand::command()
         .no_binary_name(true)
         .get_matches_from(dirs);
     let arguments: FormatCommand = FormatCommand::from_arg_matches(&args_matches)?;
-    let (cli, overrides) = arguments.partition();
-    Ok((cli, overrides))
+    let (cli, config_arguments) = arguments.partition(GlobalConfigArgs::default())?;
+    Ok((cli, config_arguments))
 }
 
 /// Find the [`PyprojectConfig`] to use for formatting.
 fn find_pyproject_config(
     cli: &FormatArguments,
-    overrides: &CliOverrides,
+    config_arguments: &ConfigArguments,
 ) -> anyhow::Result<PyprojectConfig> {
-    let mut pyproject_config = resolve(
-        cli.isolated,
-        cli.config.as_deref(),
-        overrides,
-        cli.stdin_filename.as_deref(),
-    )?;
+    let mut pyproject_config = resolve(config_arguments, cli.stdin_filename.as_deref())?;
     // We don't want to format pyproject.toml
     pyproject_config.settings.file_resolver.include = FilePatternSet::try_from_iter([
         FilePattern::Builtin("*.py"),
@@ -72,9 +67,9 @@ fn find_pyproject_config(
 fn ruff_check_paths<'a>(
     pyproject_config: &'a PyprojectConfig,
     cli: &FormatArguments,
-    overrides: &CliOverrides,
+    config_arguments: &ConfigArguments,
 ) -> anyhow::Result<(Vec<Result<ResolvedFile, ignore::Error>>, Resolver<'a>)> {
-    let (paths, resolver) = python_files_in_path(&cli.files, pyproject_config, overrides)?;
+    let (paths, resolver) = python_files_in_path(&cli.files, pyproject_config, config_arguments)?;
     Ok((paths, resolver))
 }
 

crates/ruff_dev/src/main.rs

@@ -4,8 +4,8 @@
 
 use anyhow::Result;
 use clap::{Parser, Subcommand};
-use ruff::check;
-use ruff_linter::logging::{set_up_logging, LogLevel};
+use ruff::{args::GlobalConfigArgs, check};
+use ruff_linter::logging::set_up_logging;
 use std::process::ExitCode;
 
 mod format_dev;
@@ -28,6 +28,8 @@ const ROOT_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../");
 struct Args {
     #[command(subcommand)]
     command: Command,
+    #[clap(flatten)]
+    global_options: GlobalConfigArgs,
 }
 
 #[derive(Subcommand)]
@@ -57,8 +59,6 @@ enum Command {
     Repeat {
         #[clap(flatten)]
         args: ruff::args::CheckCommand,
-        #[clap(flatten)]
-        log_level_args: ruff::args::LogLevelArgs,
         /// Run this many times
         #[clap(long)]
         repeat: usize,
@@ -75,9 +75,12 @@ enum Command {
 }
 
 fn main() -> Result<ExitCode> {
-    let args = Args::parse();
+    let Args {
+        command,
+        global_options,
+    } = Args::parse();
     #[allow(clippy::print_stdout)]
-    match args.command {
+    match command {
         Command::GenerateAll(args) => generate_all::main(&args)?,
         Command::GenerateJSONSchema(args) => generate_json_schema::main(&args)?,
         Command::GenerateRulesTable => println!("{}", generate_rules_table::generate()),
@@ -89,14 +92,12 @@ fn main() -> Result<ExitCode> {
         Command::PrintTokens(args) => print_tokens::main(&args)?,
         Command::RoundTrip(args) => round_trip::main(&args)?,
         Command::Repeat {
-            args,
+            args: subcommand_args,
             repeat,
-            log_level_args,
         } => {
-            let log_level = LogLevel::from(&log_level_args);
-            set_up_logging(&log_level)?;
+            set_up_logging(global_options.log_level())?;
             for _ in 0..repeat {
-                check(args.clone(), log_level)?;
+                check(subcommand_args.clone(), global_options.clone())?;
             }
         }
         Command::FormatDev(args) => {

crates/ruff_diagnostics/Cargo.toml

@@ -11,6 +11,7 @@ repository = { workspace = true }
 license = { workspace = true }
 
 [lib]
+doctest = false
 
 [dependencies]
 ruff_text_size = { path = "../ruff_text_size" }

crates/ruff_formatter/src/printer/queue.rs

@@ -78,27 +78,28 @@ impl<'a> PrintQueue<'a> {
 impl<'a> Queue<'a> for PrintQueue<'a> {
     fn pop(&mut self) -> Option<&'a FormatElement> {
         let elements = self.element_slices.last_mut()?;
-        elements.next().or_else(|| {
-            self.element_slices.pop();
-            let elements = self.element_slices.last_mut()?;
-            elements.next()
-        })
+        elements.next().or_else(
+            #[cold]
+            || {
+                self.element_slices.pop();
+                let elements = self.element_slices.last_mut()?;
+                elements.next()
+            },
+        )
     }
 
     fn top_with_interned(&self) -> Option<&'a FormatElement> {
         let mut slices = self.element_slices.iter().rev();
         let slice = slices.next()?;
 
-        match slice.as_slice().first() {
-            Some(element) => Some(element),
-            None => {
-                if let Some(next_elements) = slices.next() {
-                    next_elements.as_slice().first()
-                } else {
-                    None
-                }
-            }
-        }
+        slice.as_slice().first().or_else(
+            #[cold]
+            || {
+                slices
+                    .next()
+                    .and_then(|next_elements| next_elements.as_slice().first())
+            },
+        )
     }
 
     fn extend_back(&mut self, elements: &'a [FormatElement]) {
@@ -146,24 +147,30 @@ impl<'a, 'print> FitsQueue<'a, 'print> {
 
 impl<'a, 'print> Queue<'a> for FitsQueue<'a, 'print> {
     fn pop(&mut self) -> Option<&'a FormatElement> {
-        self.queue.pop().or_else(|| {
-            if let Some(next_slice) = self.rest_elements.next_back() {
-                self.queue.extend_back(next_slice.as_slice());
-                self.queue.pop()
-            } else {
-                None
-            }
-        })
+        self.queue.pop().or_else(
+            #[cold]
+            || {
+                if let Some(next_slice) = self.rest_elements.next_back() {
+                    self.queue.extend_back(next_slice.as_slice());
+                    self.queue.pop()
+                } else {
+                    None
+                }
+            },
+        )
     }
 
     fn top_with_interned(&self) -> Option<&'a FormatElement> {
-        self.queue.top_with_interned().or_else(|| {
-            if let Some(next_elements) = self.rest_elements.as_slice().last() {
-                next_elements.as_slice().first()
-            } else {
-                None
-            }
-        })
+        self.queue.top_with_interned().or_else(
+            #[cold]
+            || {
+                if let Some(next_elements) = self.rest_elements.as_slice().last() {
+                    next_elements.as_slice().first()
+                } else {
+                    None
+                }
+            },
+        )
     }
 
     fn extend_back(&mut self, elements: &'a [FormatElement]) {

crates/ruff_index/Cargo.toml

@@ -11,6 +11,7 @@ repository = { workspace = true }
 license = { workspace = true }
 
 [lib]
+doctest = false
 
 [dependencies]
 ruff_macros = { path = "../ruff_macros" }

crates/ruff_linter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.2.1"
+version = "0.3.1"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -60,7 +60,6 @@ regex = { workspace = true }
 result-like = { workspace = true }
 rustc-hash = { workspace = true }
 schemars = { workspace = true, optional = true }
-semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 similar = { workspace = true }

crates/ruff_linter/resources/test/fixtures/eradicate/ERA001.py

@@ -28,3 +28,11 @@ dictionary = {
 }
 
 #import os  # noqa
+
+# case 1:
+# try:
+# try:  # with comment
+# try: print()
+# except:
+# except Foo:
+# except Exception as e: print(e)

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

@@ -119,3 +119,16 @@ def func(x: bool):
 
 
 settings(True)
+
+
+from dataclasses import dataclass, InitVar
+
+
+@dataclass
+class Fit:
+    force: InitVar[bool] = False
+
+    def __post_init__(self, force: bool) -> None:
+        print(force)
+
+Fit(force=True)

crates/ruff_linter/resources/test/fixtures/flake8_debugger/T100.py

@@ -7,7 +7,19 @@ from pdb import set_trace as st
 from celery.contrib.rdb import set_trace
 from celery.contrib import rdb
 import celery.contrib.rdb
+from debugpy import wait_for_client
+import debugpy
+from ptvsd import break_into_debugger
+from ptvsd import enable_attach
+from ptvsd import wait_for_attach
+import ptvsd
 
 breakpoint()
 st()
 set_trace()
+debugpy.breakpoint()
+wait_for_client()
+debugpy.listen(1234)
+enable_attach()
+break_into_debugger()
+wait_for_attach()

crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI049.py

@@ -11,13 +11,25 @@ class _UnusedTypedDict2(typing.TypedDict):
 
 
 class _UsedTypedDict(TypedDict):
-   foo: bytes
+    foo: bytes
 
 
 class _CustomClass(_UsedTypedDict):
     bar: list[int]
 
+
 _UnusedTypedDict3 = TypedDict("_UnusedTypedDict3", {"foo": int})
 _UsedTypedDict3 = TypedDict("_UsedTypedDict3", {"bar": bytes})
 
+
 def uses_UsedTypedDict3(arg: _UsedTypedDict3) -> None: ...
+
+
+# In `.py` files, we don't flag unused definitions in class scopes (unlike in `.pyi`
+# files).
+class _CustomClass3:
+    class _UnusedTypeDict4(TypedDict):
+        pass
+
+    def method(self) -> None:
+        _CustomClass3._UnusedTypeDict4()

crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI049.pyi

@@ -35,3 +35,13 @@ _UnusedTypedDict3 = TypedDict("_UnusedTypedDict3", {"foo": int})
 _UsedTypedDict3 = TypedDict("_UsedTypedDict3", {"bar": bytes})
 
 def uses_UsedTypedDict3(arg: _UsedTypedDict3) -> None: ...
+
+
+# In `.pyi` files, we flag unused definitions in class scopes as well as in the global
+# scope (unlike in `.py` files).
+class _CustomClass3:
+    class _UnusedTypeDict4(TypedDict):
+        pass
+
+    def method(self) -> None:
+        _CustomClass3._UnusedTypeDict4()

crates/ruff_linter/resources/test/fixtures/flake8_raise/RSE102.py

@@ -93,3 +93,15 @@ def func():
 
 # OK
 raise func()
+
+
+# OK
+future = executor.submit(float, "a")
+if future.exception():
+    raise future.exception()
+
+
+# RSE102
+future = executor.submit(float, "a")
+if future.exception():
+    raise future.Exception()

crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM113.py

@@ -193,3 +193,11 @@ def func():
         for y in range(5):
             g(x, idx)
             idx += 1
+
+async def func():
+    # OK (for loop is async)
+    idx = 0
+
+    async for x in async_gen():
+        g(x, idx)
+        idx += 1

crates/ruff_linter/resources/test/fixtures/isort/default_section_user_defined.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import django.settings
+from library import foo
+import os
+import pytz
+import sys
+
+from . import local

crates/ruff_linter/resources/test/fixtures/isort/lines_after_imports.pyi

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Any
+
+from requests import Session
+
+from my_first_party import my_first_party_object
+
+from . import my_local_folder_object
+
+
+
+class Thing(object):
+  name: str
+  def __init__(self, name: str):
+    self.name = name

crates/ruff_linter/resources/test/fixtures/isort/no_standard_library.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import os
+import django.settings
+from library import foo
+import pytz
+
+from . import local
+import sys

crates/ruff_linter/resources/test/fixtures/pep8_naming/N804.py

@@ -50,6 +50,29 @@ class MetaClass(ABCMeta):
     def static_method(not_cls) -> bool:
         return False
 
+class ClsInArgsClass(ABCMeta):
+    def cls_as_argument(this, cls):
+        pass
+
+    def cls_as_pos_only_argument(this, cls, /):
+        pass
+
+    def cls_as_kw_only_argument(this, *, cls):
+        pass
+
+    def cls_as_varags(this, *cls):
+        pass
+
+    def cls_as_kwargs(this, **cls):
+        pass
+
+class RenamingInMethodBodyClass(ABCMeta):
+    def bad_method(this):
+        this = this
+        this
+
+    def bad_method(this):
+        self = this
 
 def func(x):
     return x

crates/ruff_linter/resources/test/fixtures/pep8_naming/N805.py

@@ -61,7 +61,7 @@ class PosOnlyClass:
     def good_method_pos_only(self, blah, /, something: str):
         pass
 
-    def bad_method_pos_only(this, blah, /, self, something: str):
+    def bad_method_pos_only(this, blah, /, something: str):
         pass
 
 
@@ -93,3 +93,27 @@ class ModelClass:
     @foobar.thisisstatic
     def badstatic(foo):
         pass
+
+class SelfInArgsClass:
+    def self_as_argument(this, self):
+        pass
+
+    def self_as_pos_only_argument(this, self, /):
+        pass
+
+    def self_as_kw_only_argument(this, *, self):
+        pass
+
+    def self_as_varags(this, *self):
+        pass
+
+    def self_as_kwargs(this, **self):
+        pass
+
+class RenamingInMethodBodyClass:
+    def bad_method(this):
+        this = this
+        this
+
+    def bad_method(this):
+        self = this

crates/ruff_linter/resources/test/fixtures/perflint/PERF101.py

@@ -36,35 +36,47 @@ for i in list( # Comment
 ):  # PERF101
     pass
 
-for i in list(foo_dict):  # Ok
+for i in list(foo_dict):  # OK
     pass
 
-for i in list(1):  # Ok
+for i in list(1):  # OK
     pass
 
-for i in list(foo_int):  # Ok
+for i in list(foo_int):  # OK
     pass
 
 
 import itertools
 
-for i in itertools.product(foo_int):  # Ok
+for i in itertools.product(foo_int):  # OK
     pass
 
-for i in list(foo_list):  # Ok
+for i in list(foo_list):  # OK
     foo_list.append(i + 1)
 
 for i in list(foo_list):  # PERF101
     # Make sure we match the correct list
     other_list.append(i + 1)
 
-for i in list(foo_tuple):  # Ok
+for i in list(foo_tuple):  # OK
     foo_tuple.append(i + 1)
 
-for i in list(foo_set):  # Ok
+for i in list(foo_set):  # OK
     foo_set.append(i + 1)
 
 x, y, nested_tuple = (1, 2, (3, 4, 5))
 
 for i in list(nested_tuple):  # PERF101
     pass
+
+for i in list(foo_list):  # OK
+    if True:
+        foo_list.append(i + 1)
+
+for i in list(foo_list):  # OK
+    if True:
+        foo_list[i] = i + 1
+
+for i in list(foo_list):  # OK
+    if True:
+        del foo_list[i + 1]

crates/ruff_linter/resources/test/fixtures/pycodestyle/.editorconfig

@@ -0,0 +1,8 @@
+# These rules test for intentional "odd" formatting. Using a formatter fixes that
+[E{1,2,3}*.py]
+generated_code = true
+ij_formatter_enabled = false
+
+[W*.py]
+generated_code = true
+ij_formatter_enabled = false

crates/ruff_linter/resources/test/fixtures/pycodestyle/E20.py

@@ -147,3 +147,9 @@ ham[upper : ]
 
 #: E203:1:10
 ham[upper  :]
+
+#: Okay
+ham[lower +1 :, "columnname"]
+
+#: E203:1:13
+ham[lower + 1  :, "columnname"]

crates/ruff_linter/resources/test/fixtures/pycodestyle/E30.py

@@ -466,6 +466,29 @@ class Class:
 # end
 
 
+# E301
+class Class:
+    """Class for minimal repo."""
+
+    columns = []
+    @classmethod
+    def cls_method(cls) -> None:
+        pass
+# end
+
+
+# E301
+class Class:
+    """Class for minimal repo."""
+
+    def method(cls) -> None:
+        pass
+    @classmethod
+    def cls_method(cls) -> None:
+        pass
+# end
+
+
 # E302
 """Main module."""
 def fn():

crates/ruff_linter/resources/test/fixtures/pycodestyle/E30.pyi

@@ -0,0 +1,50 @@
+import json
+
+from typing import Any, Sequence
+
+class MissingCommand(TypeError): ...
+class AnoherClass: ...
+
+def a(): ...
+
+@overload
+def a(arg: int): ...
+ 
+@overload
+def a(arg: int, name: str): ...
+
+
+def grouped1(): ...
+def grouped2(): ...
+def grouped3( ): ...
+
+
+class BackendProxy:
+    backend_module: str
+    backend_object: str | None
+    backend: Any
+    
+    def grouped1(): ...
+    def grouped2(): ...
+    def grouped3( ): ...
+    @decorated
+    
+    def with_blank_line(): ...
+    
+    
+    def ungrouped(): ...
+a = "test"
+
+def function_def():
+    pass
+b = "test"
+
+
+def outer():
+     def inner():
+         pass
+     def inner2():
+         pass
+         
+class Foo: ...
+class Bar: ... 

crates/ruff_linter/resources/test/fixtures/pycodestyle/E30_isort.py

@@ -0,0 +1,62 @@
+import json
+
+
+
+from typing import Any, Sequence
+
+
+class MissingCommand(TypeError): ...  # noqa: N818
+
+
+class BackendProxy:
+    backend_module: str
+    backend_object: str | None
+    backend: Any
+
+
+if __name__ == "__main__":
+    import abcd
+
+
+    abcd.foo()
+
+def __init__(self, backend_module: str, backend_obj: str | None) -> None: ...
+
+if TYPE_CHECKING:
+    import os
+
+
+
+    from typing_extensions import TypeAlias
+
+
+    abcd.foo()
+
+def __call__(self, name: str, *args: Any, **kwargs: Any) -> Any:
+    ...
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+def __call__2(self, name: str, *args: Any, **kwargs: Any) -> Any:
+    ...
+
+
+def _exit(self) -> None: ...
+
+
+def _optional_commands(self) -> dict[str, bool]: ...
+
+
+def run(argv: Sequence[str]) -> int: ...
+
+
+def read_line(fd: int = 0) -> bytearray: ...
+
+
+def flush() -> None: ...
+
+
+from typing import Any, Sequence
+
+class MissingCommand(TypeError): ...  # noqa: N818

crates/ruff_linter/resources/test/fixtures/pycodestyle/E30_isort.pyi

@@ -0,0 +1,62 @@
+import json
+
+
+
+from typing import Any, Sequence
+
+
+class MissingCommand(TypeError): ...  # noqa: N818
+
+
+class BackendProxy:
+    backend_module: str
+    backend_object: str | None
+    backend: Any
+
+
+if __name__ == "__main__":
+    import abcd
+
+
+    abcd.foo()
+
+def __init__(self, backend_module: str, backend_obj: str | None) -> None: ...
+
+if TYPE_CHECKING:
+    import os
+
+
+
+    from typing_extensions import TypeAlias
+
+
+    abcd.foo()
+
+def __call__(self, name: str, *args: Any, **kwargs: Any) -> Any:
+    ...
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+def __call__2(self, name: str, *args: Any, **kwargs: Any) -> Any:
+    ...
+
+
+def _exit(self) -> None: ...
+
+
+def _optional_commands(self) -> dict[str, bool]: ...
+
+
+def run(argv: Sequence[str]) -> int: ...
+
+
+def read_line(fd: int = 0) -> bytearray: ...
+
+
+def flush() -> None: ...
+
+
+from typing import Any, Sequence
+
+class MissingCommand(TypeError): ...  # noqa: N818

crates/ruff_linter/resources/test/fixtures/pycodestyle/E402_2.py

@@ -0,0 +1,7 @@
+import os
+
+os.environ["WORLD_SIZE"] = "1"
+os.putenv("CUDA_VISIBLE_DEVICES", "4")
+del os.environ["WORLD_SIZE"]
+
+import torch

crates/ruff_linter/resources/test/fixtures/pycodestyle/W293.py

@@ -14,3 +14,6 @@ class Chassis(RobotModuleTemplate):
  " \
     \
     
+'''blank line with whitespace
+ 
+inside a multiline string'''

crates/ruff_linter/resources/test/fixtures/pydocstyle/D413.py

@@ -57,3 +57,15 @@ def func():
 
     Returns:
         the value"""
+
+
+def func():
+    """Do something.
+
+    Args:
+        x: the value
+            with a hanging indent
+
+    Returns:
+        the value
+        """

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

@@ -0,0 +1,32 @@
+from typing import Any
+
+
+d = {1: 1, 2: 2}
+d_tuple = {(1, 2): 3, (4, 5): 6}
+d_tuple_annotated: Any = {(1, 2): 3, (4, 5): 6}
+d_tuple_incorrect_tuple = {(1,): 3, (4, 5): 6}
+l = [1, 2]
+s1 = {1, 2}
+s2 = {1, 2, 3}
+
+# Errors
+for k, v in d:
+    pass
+
+for k, v in d_tuple_incorrect_tuple:
+    pass
+
+
+# Non errors
+for k, v in d.items():
+    pass
+for k in d.keys():
+    pass
+for i, v in enumerate(l):
+    pass
+for i, v in s1.intersection(s2):
+    pass
+for a, b in d_tuple: 
+    pass
+for a, b in d_tuple_annotated: 
+    pass

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

@@ -4,7 +4,12 @@
 1 in (
     1, 2, 3
 )
-
-# OK
 fruits = ["cherry", "grapes"]
 "cherry" in fruits
+_ = {key: value for key, value in {"a": 1, "b": 2}.items() if key in ("a", "b")}
+
+# OK
+fruits in [[1, 2, 3], [4, 5, 6]]
+fruits in [1, 2, 3]
+1 in [[1, 2, 3], [4, 5, 6]]
+_ = {key: value for key, value in {"a": 1, "b": 2}.items() if key in (["a", "b"], ["c", "d"])}

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

@@ -35,6 +35,15 @@ if argc != 0:  # correct
 if argc != 1:  # correct
     pass
 
+if argc != -1.0:  # correct
+    pass
+
+if argc != 0.0:  # correct
+    pass
+
+if argc != 1.0:  # correct
+    pass
+
 if argc != 2:  # [magic-value-comparison]
     pass
 
@@ -44,6 +53,12 @@ if argc != -2:  # [magic-value-comparison]
 if argc != +2:  # [magic-value-comparison]
     pass
 
+if argc != -2.0:  # [magic-value-comparison]
+    pass
+
+if argc != +2.0:  # [magic-value-comparison]
+    pass
+
 if __name__ == "__main__":  # correct
     pass
 

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

@@ -17,3 +17,14 @@ class Fruit:
         return choice(Fruit.COLORS)
 
     pick_one_color = staticmethod(pick_one_color)
+
+class Class:
+    def class_method(cls):
+        pass
+
+    class_method = classmethod(class_method);another_statement
+
+    def static_method():
+        pass
+
+    static_method = staticmethod(static_method);

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

@@ -51,3 +51,7 @@ foo == foo or foo == bar  # Self-comparison.
 foo[0] == "a" or foo[0] == "b"  # Subscripts.
 
 foo() == "a" or foo() == "b"  # Calls.
+
+import sys
+
+sys.platform == "win32" or sys.platform == "emscripten"  # sys attributes

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

@@ -0,0 +1,39 @@
+from functools import singledispatch, singledispatchmethod
+
+
+@singledispatch
+def convert_position(position):
+    pass
+
+
+class Board:
+    @singledispatch  # [singledispatch-method]
+    @classmethod
+    def convert_position(cls, position):
+        pass
+
+    @singledispatch  # [singledispatch-method]
+    def move(self, position):
+        pass
+
+    @singledispatchmethod
+    def place(self, position):
+        pass
+
+    @singledispatch
+    @staticmethod
+    def do(position):
+        pass
+
+    # False negative (flagged by Pylint).
+    @convert_position.register
+    @classmethod
+    def _(cls, position: str) -> tuple:
+        position_a, position_b = position.split(",")
+        return (int(position_a), int(position_b))
+
+    # False negative (flagged by Pylint).
+    @convert_position.register
+    @classmethod
+    def _(cls, position: tuple) -> str:
+        return f"{position[0]},{position[1]}"

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

@@ -1,6 +1,6 @@
 from typing import Any
 
-
+a = 2
 print((3.0).__add__(4.0))  # PLC2801
 print((3.0).__sub__(4.0))  # PLC2801
 print((3.0).__mul__(4.0))  # PLC2801
@@ -17,6 +17,67 @@ print((3.0).__str__())  # PLC2801
 print((3.0).__repr__())  # PLC2801
 print([1, 2, 3].__len__())  # PLC2801
 print((1).__neg__())  # PLC2801
+print(-a.__sub__(1))  # PLC2801
+print(-(a).__sub__(1))  # PLC2801
+print(-(-a.__sub__(1)))  # PLC2801
+print((5 - a).__sub__(1))  # PLC2801
+print(-(5 - a).__sub__(1))  # PLC2801
+print(-(-5 - a).__sub__(1))  # PLC2801
+print(+-+-+-a.__sub__(1))  # PLC2801
+print(a.__rsub__(2 - 1))  # PLC2801
+print(a.__sub__(((((1))))))  # PLC2801
+print(a.__sub__(((((2 - 1))))))  # PLC2801
+print(a.__sub__(
+    3
+    +
+    4
+))
+print(a.__rsub__(
+    3
+    +
+    4
+))
+print(2 * a.__add__(3))  # PLC2801
+x = 2 * a.__add__(3)  # PLC2801
+x = 2 * -a.__add__(3)  # PLC2801
+x = a.__add__(3)  # PLC2801
+x = -a.__add__(3)  # PLC2801
+x = (-a).__add__(3)  # PLC2801
+x = -(-a).__add__(3)  # PLC2801
+
+# Calls
+print(a.__call__())  # PLC2801 (no fix, intentional)
+
+# Lambda expressions
+blah = lambda: a.__add__(1)  # PLC2801
+
+# If expressions
+print(a.__add__(1) if a > 0 else a.__sub__(1))  # PLC2801
+
+# Dict/Set/List/Tuple
+print({"a": a.__add__(1)})  # PLC2801
+print({a.__add__(1)})  # PLC2801
+print([a.__add__(1)])  # PLC2801
+print((a.__add__(1),))  # PLC2801
+
+# Comprehension variants
+print({i: i.__add__(1) for i in range(5)})  # PLC2801
+print({i.__add__(1) for i in range(5)})  # PLC2801
+print([i.__add__(1) for i in range(5)])  # PLC2801
+print((i.__add__(1) for i in range(5)))  # PLC2801
+
+# Generators
+gen = (i.__add__(1) for i in range(5))  # PLC2801
+print(next(gen))
+
+# Subscripts
+print({"a": a.__add__(1)}["a"])  # PLC2801
+
+# Starred
+print(*[a.__add__(1)])  # PLC2801
+
+# Slices
+print([a.__add__(1), a.__sub__(1)][0:1])  # PLC2801
 
 
 class Thing:

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

@@ -0,0 +1,116 @@
+# Test case 1: Useless exception statement
+from abc import ABC, abstractmethod
+from contextlib import suppress
+
+
+def func():
+    AssertionError("This is an assertion error")  # PLW0133
+
+
+# Test case 2: Useless exception statement in try-except block
+def func():
+    try:
+        Exception("This is an exception")  # PLW0133
+    except Exception as err:
+        pass
+
+
+# Test case 3: Useless exception statement in if statement
+def func():
+    if True:
+        RuntimeError("This is an exception")  # PLW0133
+
+
+# Test case 4: Useless exception statement in class
+def func():
+    class Class:
+        def __init__(self):
+            TypeError("This is an exception")  # PLW0133
+
+
+# Test case 5: Useless exception statement in function
+def func():
+    def inner():
+        IndexError("This is an exception")  # PLW0133
+
+    inner()
+
+
+# Test case 6: Useless exception statement in while loop
+def func():
+    while True:
+        KeyError("This is an exception")  # PLW0133
+
+
+# Test case 7: Useless exception statement in abstract class
+def func():
+    class Class(ABC):
+        @abstractmethod
+        def method(self):
+            NotImplementedError("This is an exception")  # PLW0133
+
+
+# Test case 8: Useless exception statement inside context manager
+def func():
+    with suppress(AttributeError):
+        AttributeError("This is an exception")  # PLW0133
+
+
+# Test case 9: Useless exception statement in parentheses
+def func():
+    (RuntimeError("This is an exception"))  # PLW0133
+
+
+# Test case 10: Useless exception statement in continuation
+def func():
+    x = 1; (RuntimeError("This is an exception")); y = 2  # PLW0133
+
+
+# Non-violation test cases: PLW0133
+
+
+# Test case 1: Used exception statement in try-except block
+def func():
+    raise Exception("This is an exception")  # OK
+
+
+# Test case 2: Used exception statement in if statement
+def func():
+    if True:
+        raise ValueError("This is an exception")  # OK
+
+
+# Test case 3: Used exception statement in class
+def func():
+    class Class:
+        def __init__(self):
+            raise TypeError("This is an exception")  # OK
+
+
+# Test case 4: Exception statement used in list comprehension
+def func():
+    [ValueError("This is an exception") for i in range(10)]  # OK
+
+
+# Test case 5: Exception statement used when initializing a dictionary
+def func():
+    {i: TypeError("This is an exception") for i in range(10)}  # OK
+
+
+# Test case 6: Exception statement used in function
+def func():
+    def inner():
+        raise IndexError("This is an exception")  # OK
+
+    inner()
+
+
+# Test case 7: Exception statement used in variable assignment
+def func():
+    err = KeyError("This is an exception")  # OK
+
+
+# Test case 8: Exception statement inside context manager
+def func():
+    with suppress(AttributeError):
+        raise AttributeError("This is an exception")  # OK

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP018.py

@@ -33,7 +33,7 @@ bool(b"")
 bool(1.0)
 int().denominator
 
-# These become string or byte literals
+# These become literals
 str()
 str("foo")
 str("""
@@ -53,3 +53,9 @@ bool(False)
 
 # These become a literal but retain parentheses
 int(1).denominator
+
+# These too are literals in spirit
+int(+1)
+int(-1)
+float(+1.0)
+float(-1.0)

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

@@ -0,0 +1,75 @@
+import codecs
+import io
+from pathlib import Path
+
+# Errors
+with open("FURB129.py") as f:
+    for _line in f.readlines():
+        pass
+    a = [line.lower() for line in f.readlines()]
+    b = {line.upper() for line in f.readlines()}
+    c = {line.lower(): line.upper() for line in f.readlines()}
+
+with Path("FURB129.py").open() as f:
+    for _line in f.readlines():
+        pass
+
+for _line in open("FURB129.py").readlines():
+    pass
+
+for _line in Path("FURB129.py").open().readlines():
+    pass
+
+
+def func():
+    f = Path("FURB129.py").open()
+    for _line in f.readlines():
+        pass
+    f.close()
+
+
+def func(f: io.BytesIO):
+    for _line in f.readlines():
+        pass
+
+
+def func():
+    with (open("FURB129.py") as f, foo as bar):
+        for _line in f.readlines():
+            pass
+        for _line in bar.readlines():
+            pass
+
+
+# False positives
+def func(f):
+    for _line in f.readlines():
+        pass
+
+
+def func(f: codecs.StreamReader):
+    for _line in f.readlines():
+        pass
+
+
+def func():
+    class A:
+        def readlines(self) -> list[str]:
+            return ["a", "b", "c"]
+
+    return A()
+
+
+for _line in func().readlines():
+    pass
+
+# OK
+for _line in ["a", "b", "c"]:
+    pass
+with open("FURB129.py") as f:
+    for _line in f:
+        pass
+    for _line in f.readlines(10):
+        pass
+    for _not_line in f.readline():
+        pass

crates/ruff_linter/resources/test/fixtures/ruff/RUF006.py

@@ -162,3 +162,26 @@ async def f(x: bool):
         T = asyncio.create_task(asyncio.sleep(1))
     else:
         T = None
+
+
+# Error
+def f():
+    loop = asyncio.new_event_loop()
+    loop.create_task(main()) # Error
+
+# Error
+def f():
+    loop = asyncio.get_event_loop()
+    loop.create_task(main()) # Error
+
+# OK
+def f():
+    global task
+    loop = asyncio.new_event_loop()
+    task = loop.create_task(main()) # Error
+
+# OK
+def f():
+    global task
+    loop = asyncio.get_event_loop()
+    task = loop.create_task(main()) # Error

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

@@ -57,6 +57,16 @@ revision_heads_map_ast = [
 list(zip(x, y))[0]
 [*zip(x, y)][0]
 
+# RUF015 (pop)
+list(x).pop(0)
+[i for i in x].pop(0)
+list(i for i in x).pop(0)
+
+# OK
+list(x).pop(1)
+list(x).remove(0)
+list(x).remove(1)
+
 
 def test():
     zip = list  # Overwrite the builtin zip

crates/ruff_linter/resources/test/fixtures/ruff/RUF022.py

@@ -250,6 +250,23 @@ __all__ = (
     ,
 )
 
+__all__ = (  # comment about the opening paren
+    # multiline strange comment 0a
+    # multiline strange comment 0b
+    "foo"  # inline comment about foo
+    # multiline strange comment 1a
+    # multiline strange comment 1b
+    ,  # comment about the comma??
+    # comment about bar part a
+    # comment about bar part b
+    "bar"  # inline comment about bar
+    # strange multiline comment comment 2a
+    # strange multiline comment 2b
+    ,
+    # strange multiline comment 3a
+    # strange multiline comment 3b
+)  # comment about the closing paren
+
 ###################################
 # These should all not get flagged:
 ###################################

crates/ruff_linter/resources/test/fixtures/ruff/RUF023.py

@@ -188,6 +188,10 @@ class BezierBuilder4:
         ,
     )
 
+    __slots__ = {"foo", "bar",
+                 "baz", "bingo"
+                 }
+
 ###################################
 # These should all not get flagged:
 ###################################

crates/ruff_linter/resources/test/fixtures/ruff/RUF027_0.py

@@ -68,3 +68,7 @@ def method_calls():
     first = "Wendy"
     last = "Appleseed"
     value.method("{first} {last}")  # RUF027
+
+def format_specifiers():
+    a = 4
+    b = "{a:b} {a:^5}"

crates/ruff_linter/resources/test/fixtures/ruff/RUF027_1.py

@@ -25,6 +25,10 @@ def negative_cases():
     json3 = "{ 'positive': 'false' }"
     alternative_formatter("{a}", a=5)
     formatted = "{a}".fmt(a=7)
+    partial = "partial sentence"
+    a = _("formatting of {partial} in a translation string is bad practice")
+    _("formatting of {partial} in a translation string is bad practice")
+    print(_("formatting of {partial} in a translation string is bad practice"))
     print(do_nothing("{a}".format(a=3)))
     print(do_nothing(alternative_formatter("{a}", a=5)))
     print(format(do_nothing("{a}"), a=5))

crates/ruff_linter/resources/test/fixtures/ruff/RUF027_2.py

@@ -0,0 +1,2 @@
+# 测试eval函数,eval()函数用来执行一个字符串表达式，并返t表达式的值。另外，可以讲字符串转换成列表或元组或字典
+a = "{1: 'a', 2: 'b'}"

crates/ruff_linter/resources/test/fixtures/ruff/RUF028.py

@@ -0,0 +1,89 @@
+def fmt_off_between_lists():
+    test_list = [
+        # fmt: off
+        1,
+        2,
+        3,
+    ]
+
+
+# note: the second `fmt: skip`` should be OK
+def fmt_skip_on_own_line():
+    # fmt: skip
+    pass  # fmt: skip
+
+
+@fmt_skip_on_own_line
+# fmt: off
+@fmt_off_between_lists
+def fmt_off_between_decorators():
+    pass
+
+
+@fmt_off_between_decorators
+# fmt: off
+class FmtOffBetweenClassDecorators:
+    ...
+
+
+def fmt_off_in_else():
+    x = [1, 2, 3]
+    for val in x:
+        print(x)
+    # fmt: off
+    else:
+        print("done")
+    while False:
+        print("while")
+        # fmt: off
+    # fmt: off
+    else:
+        print("done")
+    if len(x) > 3:
+        print("huh?")
+    # fmt: on
+    # fmt: off
+    else:
+        print("expected")
+
+
+class Test:
+    @classmethod
+    # fmt: off
+    def cls_method_a(
+        # fmt: off
+        cls,
+    ) -> None: # noqa: test # fmt: skip
+        pass
+
+
+def fmt_on_trailing():
+    # fmt: off
+    val = 5 # fmt: on
+    pass # fmt: on
+
+
+# all of these should be fine
+def match_case_and_elif():
+    string = "hello"
+    match string:
+        case ("C"
+            | "CX"
+            | "R"
+            | "RX"
+            | "S"
+            | "SP"
+            | "WAP"
+            | "XX"
+            | "Y"
+            | "YY"
+            | "YZ"
+            | "Z"
+            | "ZZ"
+        ):  # fmt: skip
+            pass
+        case _: # fmt: skip
+            if string != "Hello":
+                pass
+            elif string == "Hello": # fmt: skip
+                pass

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

@@ -2,11 +2,14 @@ use ruff_python_ast::Comprehension;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
-use crate::rules::flake8_simplify;
+use crate::rules::{flake8_simplify, refurb};
 
 /// Run lint rules over a [`Comprehension`] syntax nodes.
 pub(crate) fn comprehension(comprehension: &Comprehension, checker: &mut Checker) {
     if checker.enabled(Rule::InDictKeys) {
         flake8_simplify::rules::key_in_dict_comprehension(checker, comprehension);
     }
+    if checker.enabled(Rule::ReadlinesInFor) {
+        refurb::rules::readlines_in_comprehension(checker, comprehension);
+    }
 }

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

@@ -7,8 +7,8 @@ use crate::checkers::ast::Checker;
 use crate::codes::Rule;
 use crate::fix;
 use crate::rules::{
-    flake8_builtins, flake8_pyi, flake8_type_checking, flake8_unused_arguments, pyflakes, pylint,
-    ruff,
+    flake8_builtins, flake8_pyi, flake8_type_checking, flake8_unused_arguments, pep8_naming,
+    pyflakes, pylint, ruff,
 };
 
 /// Run lint rules over all deferred scopes in the [`SemanticModel`].
@@ -18,6 +18,8 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
         Rule::GlobalVariableNotAssigned,
         Rule::ImportPrivateName,
         Rule::ImportShadowedByLoopVar,
+        Rule::InvalidFirstArgumentNameForMethod,
+        Rule::InvalidFirstArgumentNameForClassMethod,
         Rule::NoSelfUse,
         Rule::RedefinedArgumentFromLocal,
         Rule::RedefinedWhileUnused,
@@ -40,6 +42,7 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
         Rule::UnusedPrivateTypedDict,
         Rule::UnusedStaticMethodArgument,
         Rule::UnusedVariable,
+        Rule::SingledispatchMethod,
     ]) {
         return;
     }
@@ -281,17 +284,21 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
             }
         }
 
-        if checker.enabled(Rule::UnusedPrivateTypeVar) {
-            flake8_pyi::rules::unused_private_type_var(checker, scope, &mut diagnostics);
-        }
-        if checker.enabled(Rule::UnusedPrivateProtocol) {
-            flake8_pyi::rules::unused_private_protocol(checker, scope, &mut diagnostics);
-        }
-        if checker.enabled(Rule::UnusedPrivateTypeAlias) {
-            flake8_pyi::rules::unused_private_type_alias(checker, scope, &mut diagnostics);
-        }
-        if checker.enabled(Rule::UnusedPrivateTypedDict) {
-            flake8_pyi::rules::unused_private_typed_dict(checker, scope, &mut diagnostics);
+        if checker.source_type.is_stub()
+            || matches!(scope.kind, ScopeKind::Module | ScopeKind::Function(_))
+        {
+            if checker.enabled(Rule::UnusedPrivateTypeVar) {
+                flake8_pyi::rules::unused_private_type_var(checker, scope, &mut diagnostics);
+            }
+            if checker.enabled(Rule::UnusedPrivateProtocol) {
+                flake8_pyi::rules::unused_private_protocol(checker, scope, &mut diagnostics);
+            }
+            if checker.enabled(Rule::UnusedPrivateTypeAlias) {
+                flake8_pyi::rules::unused_private_type_alias(checker, scope, &mut diagnostics);
+            }
+            if checker.enabled(Rule::UnusedPrivateTypedDict) {
+                flake8_pyi::rules::unused_private_typed_dict(checker, scope, &mut diagnostics);
+            }
         }
 
         if checker.enabled(Rule::AsyncioDanglingTask) {
@@ -385,6 +392,17 @@ pub(crate) fn deferred_scopes(checker: &mut Checker) {
             if checker.enabled(Rule::TooManyLocals) {
                 pylint::rules::too_many_locals(checker, scope, &mut diagnostics);
             }
+
+            if checker.enabled(Rule::SingledispatchMethod) {
+                pylint::rules::singledispatch_method(checker, scope, &mut diagnostics);
+            }
+
+            if checker.any_enabled(&[
+                Rule::InvalidFirstArgumentNameForClassMethod,
+                Rule::InvalidFirstArgumentNameForMethod,
+            ]) {
+                pep8_naming::rules::invalid_first_argument_name(checker, scope, &mut diagnostics);
+            }
         }
     }
     checker.diagnostics.extend(diagnostics);

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

@@ -116,7 +116,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_simplify::rules::use_capital_environment_variables(checker, expr);
             }
             if checker.enabled(Rule::UnnecessaryIterableAllocationForFirstElement) {
-                ruff::rules::unnecessary_iterable_allocation_for_first_element(checker, subscript);
+                ruff::rules::unnecessary_iterable_allocation_for_first_element(checker, expr);
             }
             if checker.enabled(Rule::InvalidIndexType) {
                 ruff::rules::invalid_index_type(checker, subscript);
@@ -134,6 +134,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             elts,
             ctx,
             range: _,
+            parenthesized: _,
         })
         | Expr::List(ast::ExprList {
             elts,
@@ -964,6 +965,9 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
             if checker.enabled(Rule::DefaultFactoryKwarg) {
                 ruff::rules::default_factory_kwarg(checker, call);
             }
+            if checker.enabled(Rule::UnnecessaryIterableAllocationForFirstElement) {
+                ruff::rules::unnecessary_iterable_allocation_for_first_element(checker, expr);
+            }
         }
         Expr::Dict(dict) => {
             if checker.any_enabled(&[
@@ -1323,8 +1327,8 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 }
             }
         }
-        Expr::IfExp(
-            if_exp @ ast::ExprIfExp {
+        Expr::If(
+            if_exp @ ast::ExprIf {
                 test,
                 body,
                 orelse,
@@ -1446,11 +1450,12 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_bugbear::rules::static_key_dict_comprehension(checker, dict_comp);
             }
         }
-        Expr::GeneratorExp(
-            generator @ ast::ExprGeneratorExp {
+        Expr::Generator(
+            generator @ ast::ExprGenerator {
                 generators,
                 elt: _,
                 range: _,
+                parenthesized: _,
             },
         ) => {
             if checker.enabled(Rule::UnnecessaryListIndexLookup) {
@@ -1512,7 +1517,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 ruff::rules::parenthesize_chained_logical_operators(checker, bool_op);
             }
         }
-        Expr::NamedExpr(..) => {
+        Expr::Named(..) => {
             if checker.enabled(Rule::AssignmentInAssert) {
                 ruff::rules::assignment_in_assert(checker, expr);
             }

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

@@ -2,11 +2,14 @@ use ruff_python_ast::Suite;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
-use crate::rules::flake8_bugbear;
+use crate::rules::{flake8_bugbear, ruff};
 
 /// Run lint rules over a module.
 pub(crate) fn module(suite: &Suite, checker: &mut Checker) {
     if checker.enabled(Rule::FStringDocstring) {
         flake8_bugbear::rules::f_string_docstring(checker, suite);
     }
+    if checker.enabled(Rule::InvalidFormatterSuppressionComment) {
+        ruff::rules::ignored_formatter_suppression_comment(checker, suite);
+    }
 }

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

@@ -105,30 +105,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     checker.diagnostics.push(diagnostic);
                 }
             }
-            if checker.enabled(Rule::InvalidFirstArgumentNameForClassMethod) {
-                if let Some(diagnostic) =
-                    pep8_naming::rules::invalid_first_argument_name_for_class_method(
-                        checker,
-                        checker.semantic.current_scope(),
-                        name,
-                        decorator_list,
-                        parameters,
-                    )
-                {
-                    checker.diagnostics.push(diagnostic);
-                }
-            }
-            if checker.enabled(Rule::InvalidFirstArgumentNameForMethod) {
-                if let Some(diagnostic) = pep8_naming::rules::invalid_first_argument_name_for_method(
-                    checker,
-                    checker.semantic.current_scope(),
-                    name,
-                    decorator_list,
-                    parameters,
-                ) {
-                    checker.diagnostics.push(diagnostic);
-                }
-            }
             if checker.source_type.is_stub() {
                 if checker.enabled(Rule::PassStatementStubBody) {
                     flake8_pyi::rules::pass_statement_stub_body(checker, body);
@@ -386,10 +362,10 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             },
         ) => {
             if checker.enabled(Rule::NoClassmethodDecorator) {
-                pylint::rules::no_classmethod_decorator(checker, class_def);
+                pylint::rules::no_classmethod_decorator(checker, stmt);
             }
             if checker.enabled(Rule::NoStaticmethodDecorator) {
-                pylint::rules::no_staticmethod_decorator(checker, class_def);
+                pylint::rules::no_staticmethod_decorator(checker, stmt);
             }
             if checker.enabled(Rule::DjangoNullableModelStringField) {
                 flake8_django::rules::nullable_model_string_field(checker, body);
@@ -1299,6 +1275,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::IterationOverSet) {
                 pylint::rules::iteration_over_set(checker, iter);
             }
+            if checker.enabled(Rule::DictIterMissingItems) {
+                pylint::rules::dict_iter_missing_items(checker, target, iter);
+            }
             if checker.enabled(Rule::ManualListComprehension) {
                 perflint::rules::manual_list_comprehension(checker, target, body);
             }
@@ -1317,6 +1296,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::UnnecessaryDictIndexLookup) {
                 pylint::rules::unnecessary_dict_index_lookup(checker, for_stmt);
             }
+            if checker.enabled(Rule::ReadlinesInFor) {
+                refurb::rules::readlines_in_for(checker, for_stmt);
+            }
             if !is_async {
                 if checker.enabled(Rule::ReimplementedBuiltin) {
                     flake8_simplify::rules::convert_for_loop_to_any_all(checker, stmt);
@@ -1603,7 +1585,7 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 refurb::rules::delete_full_slice(checker, delete);
             }
         }
-        Stmt::Expr(ast::StmtExpr { value, range: _ }) => {
+        Stmt::Expr(expr @ ast::StmtExpr { value, range: _ }) => {
             if checker.enabled(Rule::UselessComparison) {
                 flake8_bugbear::rules::useless_comparison(checker, value);
             }
@@ -1626,6 +1608,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::RepeatedAppend) {
                 refurb::rules::repeated_append(checker, stmt);
             }
+            if checker.enabled(Rule::UselessExceptionStatement) {
+                pylint::rules::useless_exception_statement(checker, expr);
+            }
         }
         _ => {}
     }

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

@@ -2,10 +2,16 @@ use ruff_python_ast::StringLike;
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;
-use crate::rules::{flake8_bandit, flake8_pyi};
+use crate::rules::{flake8_bandit, flake8_pyi, ruff};
 
 /// Run lint rules over a [`StringLike`] syntax nodes.
 pub(crate) fn string_like(string_like: StringLike, checker: &mut Checker) {
+    if checker.any_enabled(&[
+        Rule::AmbiguousUnicodeCharacterString,
+        Rule::AmbiguousUnicodeCharacterDocstring,
+    ]) {
+        ruff::rules::ambiguous_unicode_character_string(checker, string_like);
+    }
     if checker.enabled(Rule::HardcodedBindAllInterfaces) {
         flake8_bandit::rules::hardcoded_bind_all_interfaces(checker, string_like);
     }

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

@@ -1,3 +1,4 @@
+use ruff_python_ast::StmtFunctionDef;
 use ruff_python_semantic::{ScopeKind, SemanticModel};
 
 use crate::rules::flake8_type_checking;
@@ -26,6 +27,8 @@ pub(super) enum AnnotationContext {
 }
 
 impl AnnotationContext {
+    /// Determine the [`AnnotationContext`] for an annotation based on the current scope of the
+    /// semantic model.
     pub(super) fn from_model(semantic: &SemanticModel, settings: &LinterSettings) -> Self {
         // If the annotation is in a class scope (e.g., an annotated assignment for a
         // class field) or a function scope, and that class or function is marked as
@@ -71,4 +74,23 @@ impl AnnotationContext {
 
         Self::TypingOnly
     }
+
+    /// Determine the [`AnnotationContext`] to use for annotations in a function signature.
+    pub(super) fn from_function(
+        function_def: &StmtFunctionDef,
+        semantic: &SemanticModel,
+        settings: &LinterSettings,
+    ) -> Self {
+        if flake8_type_checking::helpers::runtime_required_function(
+            function_def,
+            &settings.flake8_type_checking.runtime_required_decorators,
+            semantic,
+        ) {
+            Self::RuntimeRequired
+        } else if semantic.future_annotations() {
+            Self::TypingOnly
+        } else {
+            Self::RuntimeEvaluated
+        }
+    }
 }

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

@@ -40,9 +40,10 @@ use ruff_diagnostics::{Diagnostic, IsolationLevel};
 use ruff_notebook::{CellOffsets, NotebookIndex};
 use ruff_python_ast::all::{extract_all_names, DunderAllFlags};
 use ruff_python_ast::helpers::{
-    collect_import_from_member, extract_handled_exceptions, to_module_path,
+    collect_import_from_member, extract_handled_exceptions, is_docstring_stmt, to_module_path,
 };
 use ruff_python_ast::identifier::Identifier;
+use ruff_python_ast::name::QualifiedName;
 use ruff_python_ast::str::trailing_quote;
 use ruff_python_ast::visitor::{walk_except_handler, walk_f_string_element, walk_pattern, Visitor};
 use ruff_python_ast::{helpers, str, visitor, PySourceType};
@@ -71,6 +72,38 @@ mod analyze;
 mod annotation;
 mod deferred;
 
+/// State representing whether a docstring is expected or not for the next statement.
+#[derive(Default, Debug, Copy, Clone, PartialEq)]
+enum DocstringState {
+    /// The next statement is expected to be a docstring, but not necessarily so.
+    ///
+    /// For example, in the following code:
+    ///
+    /// ```python
+    /// class Foo:
+    ///     pass
+    ///
+    ///
+    /// def bar(x, y):
+    ///     """Docstring."""
+    ///     return x +  y
+    /// ```
+    ///
+    /// For `Foo`, the state is expected when the checker is visiting the class
+    /// body but isn't going to be present. While, for `bar` function, the docstring
+    /// is expected and present.
+    #[default]
+    Expected,
+    Other,
+}
+
+impl DocstringState {
+    /// Returns `true` if the next statement is expected to be a docstring.
+    const fn is_expected(self) -> bool {
+        matches!(self, DocstringState::Expected)
+    }
+}
+
 pub(crate) struct Checker<'a> {
     /// The [`Path`] to the file under analysis.
     path: &'a Path,
@@ -114,6 +147,8 @@ pub(crate) struct Checker<'a> {
     pub(crate) flake8_bugbear_seen: Vec<TextRange>,
     /// The end offset of the last visited statement.
     last_stmt_end: TextSize,
+    /// A state describing if a docstring is expected or not.
+    docstring_state: DocstringState,
 }
 
 impl<'a> Checker<'a> {
@@ -153,6 +188,7 @@ impl<'a> Checker<'a> {
             cell_offsets,
             notebook_index,
             last_stmt_end: TextSize::default(),
+            docstring_state: DocstringState::default(),
         }
     }
 }
@@ -285,11 +321,8 @@ impl<'a> Checker<'a> {
     }
 }
 
-impl<'a, 'b> Visitor<'b> for Checker<'a>
-where
-    'b: 'a,
-{
-    fn visit_stmt(&mut self, stmt: &'b Stmt) {
+impl<'a> Visitor<'a> for Checker<'a> {
+    fn visit_stmt(&mut self, stmt: &'a Stmt) {
         // Step 0: Pre-processing
         self.semantic.push_node(stmt);
 
@@ -305,19 +338,16 @@ where
             self.semantic.flags -= SemanticModelFlags::IMPORT_BOUNDARY;
         }
 
-        // Track whether we've seen docstrings, non-imports, etc.
+        // Track whether we've seen module docstrings, non-imports, etc.
         match stmt {
             Stmt::Expr(ast::StmtExpr { value, .. })
-                if !self
-                    .semantic
-                    .flags
-                    .intersects(SemanticModelFlags::MODULE_DOCSTRING)
+                if !self.semantic.seen_module_docstring_boundary()
                     && value.is_string_literal_expr() =>
             {
-                self.semantic.flags |= SemanticModelFlags::MODULE_DOCSTRING;
+                self.semantic.flags |= SemanticModelFlags::MODULE_DOCSTRING_BOUNDARY;
             }
             Stmt::ImportFrom(ast::StmtImportFrom { module, names, .. }) => {
-                self.semantic.flags |= SemanticModelFlags::MODULE_DOCSTRING;
+                self.semantic.flags |= SemanticModelFlags::MODULE_DOCSTRING_BOUNDARY;
 
                 // Allow __future__ imports until we see a non-__future__ import.
                 if let Some("__future__") = module.as_deref() {
@@ -332,17 +362,19 @@ where
                 }
             }
             Stmt::Import(_) => {
-                self.semantic.flags |= SemanticModelFlags::MODULE_DOCSTRING;
+                self.semantic.flags |= SemanticModelFlags::MODULE_DOCSTRING_BOUNDARY;
                 self.semantic.flags |= SemanticModelFlags::FUTURES_BOUNDARY;
             }
             _ => {
-                self.semantic.flags |= SemanticModelFlags::MODULE_DOCSTRING;
+                self.semantic.flags |= SemanticModelFlags::MODULE_DOCSTRING_BOUNDARY;
                 self.semantic.flags |= SemanticModelFlags::FUTURES_BOUNDARY;
                 if !(self.semantic.seen_import_boundary()
                     || helpers::is_assignment_to_a_dunder(stmt)
                     || helpers::in_nested_block(self.semantic.current_statements())
                     || imports::is_matplotlib_activation(stmt, self.semantic())
-                    || imports::is_sys_path_modification(stmt, self.semantic()))
+                    || imports::is_sys_path_modification(stmt, self.semantic())
+                    || (self.settings.preview.is_enabled()
+                        && imports::is_os_environ_modification(stmt, self.semantic())))
                 {
                     self.semantic.flags |= SemanticModelFlags::IMPORT_BOUNDARY;
                 }
@@ -353,6 +385,16 @@ where
         // the node.
         let flags_snapshot = self.semantic.flags;
 
+        // Update the semantic model if it is in a docstring. This should be done after the
+        // flags snapshot to ensure that it gets reset once the statement is analyzed.
+        if self.docstring_state.is_expected() {
+            if is_docstring_stmt(stmt) {
+                self.semantic.flags |= SemanticModelFlags::DOCSTRING;
+            }
+            // Reset the state irrespective of whether the statement is a docstring or not.
+            self.docstring_state = DocstringState::Other;
+        }
+
         // Step 1: Binding
         match stmt {
             Stmt::AugAssign(ast::StmtAugAssign {
@@ -377,11 +419,13 @@ where
                     self.semantic.add_module(module);
 
                     if alias.asname.is_none() && alias.name.contains('.') {
-                        let call_path: Box<[&str]> = alias.name.split('.').collect();
+                        let qualified_name = QualifiedName::user_defined(&alias.name);
                         self.add_binding(
                             module,
                             alias.identifier(),
-                            BindingKind::SubmoduleImport(SubmoduleImport { call_path }),
+                            BindingKind::SubmoduleImport(SubmoduleImport {
+                                qualified_name: Box::new(qualified_name),
+                            }),
                             BindingFlags::EXTERNAL,
                         );
                     } else {
@@ -398,11 +442,13 @@ where
                         }
 
                         let name = alias.asname.as_ref().unwrap_or(&alias.name);
-                        let call_path: Box<[&str]> = alias.name.split('.').collect();
+                        let qualified_name = QualifiedName::user_defined(&alias.name);
                         self.add_binding(
                             name,
                             alias.identifier(),
-                            BindingKind::Import(Import { call_path }),
+                            BindingKind::Import(Import {
+                                qualified_name: Box::new(qualified_name),
+                            }),
                             flags,
                         );
                     }
@@ -462,12 +508,13 @@ where
                         // Attempt to resolve any relative imports; but if we don't know the current
                         // module path, or the relative import extends beyond the package root,
                         // fallback to a literal representation (e.g., `[".", "foo"]`).
-                        let call_path = collect_import_from_member(level, module, &alias.name)
-                            .into_boxed_slice();
+                        let qualified_name = collect_import_from_member(level, module, &alias.name);
                         self.add_binding(
                             name,
                             alias.identifier(),
-                            BindingKind::FromImport(FromImport { call_path }),
+                            BindingKind::FromImport(FromImport {
+                                qualified_name: Box::new(qualified_name),
+                            }),
                             flags,
                         );
                     }
@@ -540,7 +587,8 @@ where
 
                 // Function annotations are always evaluated at runtime, unless future annotations
                 // are enabled.
-                let runtime_annotation = !self.semantic.future_annotations();
+                let annotation =
+                    AnnotationContext::from_function(function_def, &self.semantic, self.settings);
 
                 // The first parameter may be a single dispatch.
                 let mut singledispatch =
@@ -564,10 +612,18 @@ where
                     if let Some(expr) = &parameter_with_default.parameter.annotation {
                         if singledispatch {
                             self.visit_runtime_required_annotation(expr);
-                        } else if runtime_annotation {
-                            self.visit_runtime_evaluated_annotation(expr);
                         } else {
-                            self.visit_annotation(expr);
+                            match annotation {
+                                AnnotationContext::RuntimeRequired => {
+                                    self.visit_runtime_required_annotation(expr);
+                                }
+                                AnnotationContext::RuntimeEvaluated => {
+                                    self.visit_runtime_evaluated_annotation(expr);
+                                }
+                                AnnotationContext::TypingOnly => {
+                                    self.visit_annotation(expr);
+                                }
+                            }
                         };
                     }
                     if let Some(expr) = &parameter_with_default.default {
@@ -577,28 +633,46 @@ where
                 }
                 if let Some(arg) = &parameters.vararg {
                     if let Some(expr) = &arg.annotation {
-                        if runtime_annotation {
-                            self.visit_runtime_evaluated_annotation(expr);
-                        } else {
-                            self.visit_annotation(expr);
-                        };
+                        match annotation {
+                            AnnotationContext::RuntimeRequired => {
+                                self.visit_runtime_required_annotation(expr);
+                            }
+                            AnnotationContext::RuntimeEvaluated => {
+                                self.visit_runtime_evaluated_annotation(expr);
+                            }
+                            AnnotationContext::TypingOnly => {
+                                self.visit_annotation(expr);
+                            }
+                        }
                     }
                 }
                 if let Some(arg) = &parameters.kwarg {
                     if let Some(expr) = &arg.annotation {
-                        if runtime_annotation {
-                            self.visit_runtime_evaluated_annotation(expr);
-                        } else {
-                            self.visit_annotation(expr);
-                        };
+                        match annotation {
+                            AnnotationContext::RuntimeRequired => {
+                                self.visit_runtime_required_annotation(expr);
+                            }
+                            AnnotationContext::RuntimeEvaluated => {
+                                self.visit_runtime_evaluated_annotation(expr);
+                            }
+                            AnnotationContext::TypingOnly => {
+                                self.visit_annotation(expr);
+                            }
+                        }
                     }
                 }
                 for expr in returns {
-                    if runtime_annotation {
-                        self.visit_runtime_evaluated_annotation(expr);
-                    } else {
-                        self.visit_annotation(expr);
-                    };
+                    match annotation {
+                        AnnotationContext::RuntimeRequired => {
+                            self.visit_runtime_required_annotation(expr);
+                        }
+                        AnnotationContext::RuntimeEvaluated => {
+                            self.visit_runtime_evaluated_annotation(expr);
+                        }
+                        AnnotationContext::TypingOnly => {
+                            self.visit_annotation(expr);
+                        }
+                    }
                 }
 
                 let definition = docstrings::extraction::extract_definition(
@@ -654,6 +728,8 @@ where
                     self.semantic.set_globals(globals);
                 }
 
+                // Set the docstring state before visiting the class body.
+                self.docstring_state = DocstringState::Expected;
                 self.visit_body(body);
             }
             Stmt::TypeAlias(ast::StmtTypeAlias {
@@ -681,8 +757,8 @@ where
             }) => {
                 let mut handled_exceptions = Exceptions::empty();
                 for type_ in extract_handled_exceptions(handlers) {
-                    if let Some(call_path) = self.semantic.resolve_call_path(type_) {
-                        match call_path.as_slice() {
+                    if let Some(qualified_name) = self.semantic.resolve_qualified_name(type_) {
+                        match qualified_name.segments() {
                             ["", "NameError"] => {
                                 handled_exceptions |= Exceptions::NAME_ERROR;
                             }
@@ -849,14 +925,14 @@ where
         self.last_stmt_end = stmt.end();
     }
 
-    fn visit_annotation(&mut self, expr: &'b Expr) {
+    fn visit_annotation(&mut self, expr: &'a Expr) {
         let flags_snapshot = self.semantic.flags;
         self.semantic.flags |= SemanticModelFlags::TYPING_ONLY_ANNOTATION;
         self.visit_type_definition(expr);
         self.semantic.flags = flags_snapshot;
     }
 
-    fn visit_expr(&mut self, expr: &'b Expr) {
+    fn visit_expr(&mut self, expr: &'a Expr) {
         // Step 0: Pre-processing
         if !self.semantic.in_typing_literal()
             && !self.semantic.in_deferred_type_definition()
@@ -930,10 +1006,11 @@ where
                 generators,
                 range: _,
             })
-            | Expr::GeneratorExp(ast::ExprGeneratorExp {
+            | Expr::Generator(ast::ExprGenerator {
                 elt,
                 generators,
                 range: _,
+                parenthesized: _,
             }) => {
                 self.visit_generators(generators);
                 self.visit_expr(elt);
@@ -977,7 +1054,7 @@ where
                 self.visit.lambdas.push(self.semantic.snapshot());
                 self.analyze.lambdas.push(self.semantic.snapshot());
             }
-            Expr::IfExp(ast::ExprIfExp {
+            Expr::If(ast::ExprIf {
                 test,
                 body,
                 orelse,
@@ -994,42 +1071,54 @@ where
             }) => {
                 self.visit_expr(func);
 
-                let callable = self.semantic.resolve_call_path(func).and_then(|call_path| {
-                    if self.semantic.match_typing_call_path(&call_path, "cast") {
-                        Some(typing::Callable::Cast)
-                    } else if self.semantic.match_typing_call_path(&call_path, "NewType") {
-                        Some(typing::Callable::NewType)
-                    } else if self.semantic.match_typing_call_path(&call_path, "TypeVar") {
-                        Some(typing::Callable::TypeVar)
-                    } else if self
-                        .semantic
-                        .match_typing_call_path(&call_path, "NamedTuple")
-                    {
-                        Some(typing::Callable::NamedTuple)
-                    } else if self
-                        .semantic
-                        .match_typing_call_path(&call_path, "TypedDict")
-                    {
-                        Some(typing::Callable::TypedDict)
-                    } else if matches!(
-                        call_path.as_slice(),
-                        [
-                            "mypy_extensions",
-                            "Arg"
-                                | "DefaultArg"
-                                | "NamedArg"
-                                | "DefaultNamedArg"
-                                | "VarArg"
-                                | "KwArg"
-                        ]
-                    ) {
-                        Some(typing::Callable::MypyExtension)
-                    } else if matches!(call_path.as_slice(), ["", "bool"]) {
-                        Some(typing::Callable::Bool)
-                    } else {
-                        None
-                    }
-                });
+                let callable =
+                    self.semantic
+                        .resolve_qualified_name(func)
+                        .and_then(|qualified_name| {
+                            if self
+                                .semantic
+                                .match_typing_qualified_name(&qualified_name, "cast")
+                            {
+                                Some(typing::Callable::Cast)
+                            } else if self
+                                .semantic
+                                .match_typing_qualified_name(&qualified_name, "NewType")
+                            {
+                                Some(typing::Callable::NewType)
+                            } else if self
+                                .semantic
+                                .match_typing_qualified_name(&qualified_name, "TypeVar")
+                            {
+                                Some(typing::Callable::TypeVar)
+                            } else if self
+                                .semantic
+                                .match_typing_qualified_name(&qualified_name, "NamedTuple")
+                            {
+                                Some(typing::Callable::NamedTuple)
+                            } else if self
+                                .semantic
+                                .match_typing_qualified_name(&qualified_name, "TypedDict")
+                            {
+                                Some(typing::Callable::TypedDict)
+                            } else if matches!(
+                                qualified_name.segments(),
+                                [
+                                    "mypy_extensions",
+                                    "Arg"
+                                        | "DefaultArg"
+                                        | "NamedArg"
+                                        | "DefaultNamedArg"
+                                        | "VarArg"
+                                        | "KwArg"
+                                ]
+                            ) {
+                                Some(typing::Callable::MypyExtension)
+                            } else if matches!(qualified_name.segments(), ["", "bool"]) {
+                                Some(typing::Callable::Bool)
+                            } else {
+                                None
+                            }
+                        });
                 match callable {
                     Some(typing::Callable::Bool) => {
                         let mut args = arguments.args.iter();
@@ -1254,6 +1343,7 @@ where
                                 elts,
                                 ctx,
                                 range: _,
+                                parenthesized: _,
                             }) = slice.as_ref()
                             {
                                 let mut iter = elts.iter();
@@ -1288,13 +1378,23 @@ where
                 self.semantic.flags |= SemanticModelFlags::F_STRING;
                 visitor::walk_expr(self, expr);
             }
+            Expr::Named(ast::ExprNamed {
+                target,
+                value,
+                range: _,
+            }) => {
+                self.visit_expr(value);
+
+                self.semantic.flags |= SemanticModelFlags::NAMED_EXPRESSION_ASSIGNMENT;
+                self.visit_expr(target);
+            }
             _ => visitor::walk_expr(self, expr),
         }
 
         // Step 3: Clean-up
         match expr {
             Expr::Lambda(_)
-            | Expr::GeneratorExp(_)
+            | Expr::Generator(_)
             | Expr::ListComp(_)
             | Expr::DictComp(_)
             | Expr::SetComp(_) => {
@@ -1318,7 +1418,7 @@ where
         self.semantic.pop_node();
     }
 
-    fn visit_except_handler(&mut self, except_handler: &'b ExceptHandler) {
+    fn visit_except_handler(&mut self, except_handler: &'a ExceptHandler) {
         let flags_snapshot = self.semantic.flags;
         self.semantic.flags |= SemanticModelFlags::EXCEPTION_HANDLER;
 
@@ -1368,7 +1468,7 @@ where
         self.semantic.flags = flags_snapshot;
     }
 
-    fn visit_parameters(&mut self, parameters: &'b Parameters) {
+    fn visit_parameters(&mut self, parameters: &'a Parameters) {
         // Step 1: Binding.
         // Bind, but intentionally avoid walking default expressions, as we handle them
         // upstream.
@@ -1392,7 +1492,7 @@ where
         analyze::parameters(parameters, self);
     }
 
-    fn visit_parameter(&mut self, parameter: &'b Parameter) {
+    fn visit_parameter(&mut self, parameter: &'a Parameter) {
         // Step 1: Binding.
         // Bind, but intentionally avoid walking the annotation, as we handle it
         // upstream.
@@ -1407,7 +1507,7 @@ where
         analyze::parameter(parameter, self);
     }
 
-    fn visit_pattern(&mut self, pattern: &'b Pattern) {
+    fn visit_pattern(&mut self, pattern: &'a Pattern) {
         // Step 1: Binding
         if let Pattern::MatchAs(ast::PatternMatchAs {
             name: Some(name), ..
@@ -1432,7 +1532,7 @@ where
         walk_pattern(self, pattern);
     }
 
-    fn visit_body(&mut self, body: &'b [Stmt]) {
+    fn visit_body(&mut self, body: &'a [Stmt]) {
         // Step 4: Analysis
         analyze::suite(body, self);
 
@@ -1442,7 +1542,7 @@ where
         }
     }
 
-    fn visit_match_case(&mut self, match_case: &'b MatchCase) {
+    fn visit_match_case(&mut self, match_case: &'a MatchCase) {
         self.visit_pattern(&match_case.pattern);
         if let Some(expr) = &match_case.guard {
             self.visit_boolean_test(expr);
@@ -1453,7 +1553,7 @@ where
         self.semantic.pop_branch();
     }
 
-    fn visit_type_param(&mut self, type_param: &'b ast::TypeParam) {
+    fn visit_type_param(&mut self, type_param: &'a ast::TypeParam) {
         // Step 1: Binding
         match type_param {
             ast::TypeParam::TypeVar(ast::TypeParamTypeVar { name, range, .. })
@@ -1478,7 +1578,7 @@ where
         }
     }
 
-    fn visit_f_string_element(&mut self, f_string_element: &'b ast::FStringElement) {
+    fn visit_f_string_element(&mut self, f_string_element: &'a ast::FStringElement) {
         // Step 2: Traversal
         walk_f_string_element(self, f_string_element);
 
@@ -1504,6 +1604,8 @@ impl<'a> Checker<'a> {
             unreachable!("Generator expression must contain at least one generator");
         };
 
+        let flags = self.semantic.flags;
+
         // Generators are compiled as nested functions. (This may change with PEP 709.)
         // As such, the `iter` of the first generator is evaluated in the outer scope, while all
         // subsequent nodes are evaluated in the inner scope.
@@ -1533,14 +1635,22 @@ impl<'a> Checker<'a> {
         // `x` is local to `foo`, and the `T` in `y=T` skips the class scope when resolving.
         self.visit_expr(&generator.iter);
         self.semantic.push_scope(ScopeKind::Generator);
+
+        self.semantic.flags = flags | SemanticModelFlags::COMPREHENSION_ASSIGNMENT;
         self.visit_expr(&generator.target);
+        self.semantic.flags = flags;
+
         for expr in &generator.ifs {
             self.visit_boolean_test(expr);
         }
 
         for generator in iterator {
             self.visit_expr(&generator.iter);
+
+            self.semantic.flags = flags | SemanticModelFlags::COMPREHENSION_ASSIGNMENT;
             self.visit_expr(&generator.target);
+            self.semantic.flags = flags;
+
             for expr in &generator.ifs {
                 self.visit_boolean_test(expr);
             }
@@ -1739,11 +1849,21 @@ impl<'a> Checker<'a> {
             return;
         }
 
+        // A binding within a `for` must be a loop variable, as in:
+        // ```python
+        // for x in range(10):
+        //     ...
+        // ```
         if parent.is_for_stmt() {
             self.add_binding(id, expr.range(), BindingKind::LoopVar, flags);
             return;
         }
 
+        // A binding within a `with` must be an item, as in:
+        // ```python
+        // with open("file.txt") as fp:
+        //     ...
+        // ```
         if parent.is_with_stmt() {
             self.add_binding(id, expr.range(), BindingKind::WithItemVar, flags);
             return;
@@ -1799,17 +1919,26 @@ impl<'a> Checker<'a> {
         }
 
         // If the expression is the left-hand side of a walrus operator, then it's a named
-        // expression assignment.
-        if self
-            .semantic
-            .current_expressions()
-            .filter_map(Expr::as_named_expr_expr)
-            .any(|parent| parent.target.as_ref() == expr)
-        {
+        // expression assignment, as in:
+        // ```python
+        // if (x := 10) > 5:
+        //     ...
+        // ```
+        if self.semantic.in_named_expression_assignment() {
             self.add_binding(id, expr.range(), BindingKind::NamedExprAssignment, flags);
             return;
         }
 
+        // If the expression is part of a comprehension target, then it's a comprehension variable
+        // assignment, as in:
+        // ```python
+        // [x for x in range(10)]
+        // ```
+        if self.semantic.in_comprehension_assignment() {
+            self.add_binding(id, expr.range(), BindingKind::ComprehensionVar, flags);
+            return;
+        }
+
         self.add_binding(id, expr.range(), BindingKind::Assignment, flags);
     }
 
@@ -1925,6 +2054,8 @@ impl<'a> Checker<'a> {
                 };
 
                 self.visit_parameters(parameters);
+                // Set the docstring state before visiting the function body.
+                self.docstring_state = DocstringState::Expected;
                 self.visit_body(body);
             }
         }

crates/ruff_linter/src/checkers/noqa.rs

@@ -3,12 +3,13 @@
 use std::path::Path;
 
 use itertools::Itertools;
-use ruff_text_size::{Ranged, TextLen, TextRange};
+use ruff_text_size::Ranged;
 
 use ruff_diagnostics::{Diagnostic, Edit, Fix};
-use ruff_python_trivia::{CommentRanges, PythonWhitespace};
+use ruff_python_trivia::CommentRanges;
 use ruff_source_file::Locator;
 
+use crate::fix::edits::delete_comment;
 use crate::noqa;
 use crate::noqa::{Directive, FileExemption, NoqaDirectives, NoqaMapping};
 use crate::registry::{AsRule, Rule, RuleSet};
@@ -28,7 +29,13 @@ pub(crate) fn check_noqa(
     settings: &LinterSettings,
 ) -> Vec<usize> {
     // Identify any codes that are globally exempted (within the current file).
-    let exemption = FileExemption::try_extract(locator.contents(), comment_ranges, path, locator);
+    let exemption = FileExemption::try_extract(
+        locator.contents(),
+        comment_ranges,
+        &settings.external,
+        path,
+        locator,
+    );
 
     // Extract all `noqa` directives.
     let mut noqa_directives = NoqaDirectives::from_commented_ranges(comment_ranges, path, locator);
@@ -111,7 +118,8 @@ pub(crate) fn check_noqa(
                     if line.matches.is_empty() {
                         let mut diagnostic =
                             Diagnostic::new(UnusedNOQA { codes: None }, directive.range());
-                        diagnostic.set_fix(Fix::safe_edit(delete_noqa(directive.range(), locator)));
+                        diagnostic
+                            .set_fix(Fix::safe_edit(delete_comment(directive.range(), locator)));
 
                         diagnostics.push(diagnostic);
                     }
@@ -177,8 +185,10 @@ pub(crate) fn check_noqa(
                             directive.range(),
                         );
                         if valid_codes.is_empty() {
-                            diagnostic
-                                .set_fix(Fix::safe_edit(delete_noqa(directive.range(), locator)));
+                            diagnostic.set_fix(Fix::safe_edit(delete_comment(
+                                directive.range(),
+                                locator,
+                            )));
                         } else {
                             diagnostic.set_fix(Fix::safe_edit(Edit::range_replacement(
                                 format!("# noqa: {}", valid_codes.join(", ")),
@@ -195,48 +205,3 @@ pub(crate) fn check_noqa(
     ignored_diagnostics.sort_unstable();
     ignored_diagnostics
 }
-
-/// Generate a [`Edit`] to delete a `noqa` directive.
-fn delete_noqa(range: TextRange, locator: &Locator) -> Edit {
-    let line_range = locator.line_range(range.start());
-
-    // Compute the leading space.
-    let prefix = locator.slice(TextRange::new(line_range.start(), range.start()));
-    let leading_space_len = prefix.text_len() - prefix.trim_whitespace_end().text_len();
-
-    // Compute the trailing space.
-    let suffix = locator.slice(TextRange::new(range.end(), line_range.end()));
-    let trailing_space_len = suffix.text_len() - suffix.trim_whitespace_start().text_len();
-
-    // Ex) `# noqa`
-    if line_range
-        == TextRange::new(
-            range.start() - leading_space_len,
-            range.end() + trailing_space_len,
-        )
-    {
-        let full_line_end = locator.full_line_end(line_range.end());
-        Edit::deletion(line_range.start(), full_line_end)
-    }
-    // Ex) `x = 1  # noqa`
-    else if range.end() + trailing_space_len == line_range.end() {
-        Edit::deletion(range.start() - leading_space_len, line_range.end())
-    }
-    // Ex) `x = 1  # noqa  # type: ignore`
-    else if locator
-        .slice(TextRange::new(
-            range.end() + trailing_space_len,
-            line_range.end(),
-        ))
-        .starts_with('#')
-    {
-        Edit::deletion(range.start(), range.end() + trailing_space_len)
-    }
-    // Ex) `x = 1  # noqa here`
-    else {
-        Edit::deletion(
-            range.start() + "# ".text_len(),
-            range.end() + trailing_space_len,
-        )
-    }
-}

crates/ruff_linter/src/checkers/tokens.rs

@@ -6,17 +6,14 @@ use ruff_notebook::CellOffsets;
 use ruff_python_ast::PySourceType;
 use ruff_python_codegen::Stylist;
 use ruff_python_parser::lexer::LexResult;
-use ruff_python_parser::Tok;
 
 use ruff_diagnostics::Diagnostic;
 use ruff_python_index::Indexer;
 use ruff_source_file::Locator;
 
 use crate::directives::TodoComment;
-use crate::lex::docstring_detection::StateMachine;
 use crate::registry::{AsRule, Rule};
 use crate::rules::pycodestyle::rules::BlankLinesChecker;
-use crate::rules::ruff::rules::Context;
 use crate::rules::{
     eradicate, flake8_commas, flake8_executable, flake8_fixme, flake8_implicit_str_concat,
     flake8_pyi, flake8_quotes, flake8_todos, pycodestyle, pygrep_hooks, pylint, pyupgrade, ruff,
@@ -44,14 +41,8 @@ pub(crate) fn check_tokens(
         Rule::BlankLinesAfterFunctionOrClass,
         Rule::BlankLinesBeforeNestedDefinition,
     ]) {
-        let mut blank_lines_checker = BlankLinesChecker::default();
-        blank_lines_checker.check_lines(
-            tokens,
-            locator,
-            stylist,
-            settings.tab_size,
-            &mut diagnostics,
-        );
+        BlankLinesChecker::new(locator, stylist, settings, source_type)
+            .check_lines(tokens, &mut diagnostics);
     }
 
     if settings.rules.enabled(Rule::BlanketNOQA) {
@@ -66,31 +57,15 @@ pub(crate) fn check_tokens(
         pylint::rules::empty_comments(&mut diagnostics, indexer, locator);
     }
 
-    if settings.rules.any_enabled(&[
-        Rule::AmbiguousUnicodeCharacterString,
-        Rule::AmbiguousUnicodeCharacterDocstring,
-        Rule::AmbiguousUnicodeCharacterComment,
-    ]) {
-        let mut state_machine = StateMachine::default();
-        for &(ref tok, range) in tokens.iter().flatten() {
-            let is_docstring = state_machine.consume(tok);
-            let context = match tok {
-                Tok::String { .. } => {
-                    if is_docstring {
-                        Context::Docstring
-                    } else {
-                        Context::String
-                    }
-                }
-                Tok::FStringMiddle { .. } => Context::String,
-                Tok::Comment(_) => Context::Comment,
-                _ => continue,
-            };
-            ruff::rules::ambiguous_unicode_character(
+    if settings
+        .rules
+        .enabled(Rule::AmbiguousUnicodeCharacterComment)
+    {
+        for range in indexer.comment_ranges() {
+            ruff::rules::ambiguous_unicode_character_comment(
                 &mut diagnostics,
                 locator,
-                range,
-                context,
+                *range,
                 settings,
             );
         }

crates/ruff_linter/src/codes.rs

@@ -244,6 +244,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "E0643") => (RuleGroup::Preview, rules::pylint::rules::PotentialIndexError),
         (Pylint, "E0704") => (RuleGroup::Preview, rules::pylint::rules::MisplacedBareRaise),
         (Pylint, "E1132") => (RuleGroup::Preview, rules::pylint::rules::RepeatedKeywordArgument),
+        (Pylint, "E1141") => (RuleGroup::Preview, rules::pylint::rules::DictIterMissingItems),
         (Pylint, "E1142") => (RuleGroup::Stable, rules::pylint::rules::AwaitOutsideAsync),
         (Pylint, "E1205") => (RuleGroup::Stable, rules::pylint::rules::LoggingTooManyArgs),
         (Pylint, "E1206") => (RuleGroup::Stable, rules::pylint::rules::LoggingTooFewArgs),
@@ -251,6 +252,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "E1307") => (RuleGroup::Stable, rules::pylint::rules::BadStringFormatType),
         (Pylint, "E1310") => (RuleGroup::Stable, rules::pylint::rules::BadStrStripCall),
         (Pylint, "E1507") => (RuleGroup::Stable, rules::pylint::rules::InvalidEnvvarValue),
+        (Pylint, "E1519") => (RuleGroup::Preview, rules::pylint::rules::SingledispatchMethod),
         (Pylint, "E1700") => (RuleGroup::Stable, rules::pylint::rules::YieldFromInAsyncFunction),
         (Pylint, "E2502") => (RuleGroup::Stable, rules::pylint::rules::BidirectionalUnicode),
         (Pylint, "E2510") => (RuleGroup::Stable, rules::pylint::rules::InvalidCharacterBackspace),
@@ -291,6 +293,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pylint, "W0127") => (RuleGroup::Stable, rules::pylint::rules::SelfAssigningVariable),
         (Pylint, "W0129") => (RuleGroup::Stable, rules::pylint::rules::AssertOnStringLiteral),
         (Pylint, "W0131") => (RuleGroup::Stable, rules::pylint::rules::NamedExprWithoutContext),
+        (Pylint, "W0133") => (RuleGroup::Preview, rules::pylint::rules::UselessExceptionStatement),
         (Pylint, "W0245") => (RuleGroup::Preview, rules::pylint::rules::SuperWithoutBrackets),
         (Pylint, "W0406") => (RuleGroup::Stable, rules::pylint::rules::ImportSelf),
         (Pylint, "W0602") => (RuleGroup::Stable, rules::pylint::rules::GlobalVariableNotAssigned),
@@ -654,7 +657,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Flake8Bandit, "407") => (RuleGroup::Preview, rules::flake8_bandit::rules::SuspiciousXmlExpatImport),
         (Flake8Bandit, "408") => (RuleGroup::Preview, rules::flake8_bandit::rules::SuspiciousXmlMinidomImport),
         (Flake8Bandit, "409") => (RuleGroup::Preview, rules::flake8_bandit::rules::SuspiciousXmlPulldomImport),
-        (Flake8Bandit, "410") => (RuleGroup::Preview, rules::flake8_bandit::rules::SuspiciousLxmlImport),
+        (Flake8Bandit, "410") => (RuleGroup::Removed, rules::flake8_bandit::rules::SuspiciousLxmlImport),
         (Flake8Bandit, "411") => (RuleGroup::Preview, rules::flake8_bandit::rules::SuspiciousXmlrpcImport),
         (Flake8Bandit, "412") => (RuleGroup::Preview, rules::flake8_bandit::rules::SuspiciousHttpoxyImport),
         (Flake8Bandit, "413") => (RuleGroup::Preview, rules::flake8_bandit::rules::SuspiciousPycryptoImport),
@@ -944,6 +947,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "025") => (RuleGroup::Preview, rules::ruff::rules::UnnecessaryDictComprehensionForIterable),
         (Ruff, "026") => (RuleGroup::Preview, rules::ruff::rules::DefaultFactoryKwarg),
         (Ruff, "027") => (RuleGroup::Preview, rules::ruff::rules::MissingFStringSyntax),
+        (Ruff, "028") => (RuleGroup::Preview, rules::ruff::rules::InvalidFormatterSuppressionComment),
         (Ruff, "100") => (RuleGroup::Stable, rules::ruff::rules::UnusedNOQA),
         (Ruff, "200") => (RuleGroup::Stable, rules::ruff::rules::InvalidPyprojectToml),
         #[cfg(feature = "test-rules")]
@@ -1025,6 +1029,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         #[allow(deprecated)]
         (Refurb, "113") => (RuleGroup::Nursery, rules::refurb::rules::RepeatedAppend),
         (Refurb, "118") => (RuleGroup::Preview, rules::refurb::rules::ReimplementedOperator),
+        (Refurb, "129") => (RuleGroup::Preview, rules::refurb::rules::ReadlinesInFor),
         #[allow(deprecated)]
         (Refurb, "131") => (RuleGroup::Nursery, rules::refurb::rules::DeleteFullSlice),
         #[allow(deprecated)]

crates/ruff_linter/src/cst/helpers.rs

@@ -1,44 +1,7 @@
 use libcst_native::{
-    Expression, Name, NameOrAttribute, ParenthesizableWhitespace, SimpleWhitespace, UnaryOperation,
+    Expression, Name, ParenthesizableWhitespace, SimpleWhitespace, UnaryOperation,
 };
 
-fn compose_call_path_inner<'a>(expr: &'a Expression, parts: &mut Vec<&'a str>) {
-    match expr {
-        Expression::Call(expr) => {
-            compose_call_path_inner(&expr.func, parts);
-        }
-        Expression::Attribute(expr) => {
-            compose_call_path_inner(&expr.value, parts);
-            parts.push(expr.attr.value);
-        }
-        Expression::Name(expr) => {
-            parts.push(expr.value);
-        }
-        _ => {}
-    }
-}
-
-pub(crate) fn compose_call_path(expr: &Expression) -> Option<String> {
-    let mut segments = vec![];
-    compose_call_path_inner(expr, &mut segments);
-    if segments.is_empty() {
-        None
-    } else {
-        Some(segments.join("."))
-    }
-}
-
-pub(crate) fn compose_module_path(module: &NameOrAttribute) -> String {
-    match module {
-        NameOrAttribute::N(name) => name.value.to_string(),
-        NameOrAttribute::A(attr) => {
-            let name = attr.attr.value;
-            let prefix = compose_call_path(&attr.value);
-            prefix.map_or_else(|| name.to_string(), |prefix| format!("{prefix}.{name}"))
-        }
-    }
-}
-
 /// Return a [`ParenthesizableWhitespace`] containing a single space.
 pub(crate) fn space() -> ParenthesizableWhitespace<'static> {
     ParenthesizableWhitespace::SimpleWhitespace(SimpleWhitespace(" "))

crates/ruff_linter/src/fix/codemods.rs

@@ -2,14 +2,16 @@
 //! and return the modified code snippet as output.
 use anyhow::{bail, Result};
 use libcst_native::{
-    Codegen, CodegenState, ImportNames, ParenthesizableWhitespace, SmallStatement, Statement,
+    Codegen, CodegenState, Expression, ImportNames, NameOrAttribute, ParenthesizableWhitespace,
+    SmallStatement, Statement,
 };
+use ruff_python_ast::name::UnqualifiedName;
+use smallvec::{smallvec, SmallVec};
 
 use ruff_python_ast::Stmt;
 use ruff_python_codegen::Stylist;
 use ruff_source_file::Locator;
 
-use crate::cst::helpers::compose_module_path;
 use crate::cst::matchers::match_statement;
 
 /// Glue code to make libcst codegen work with ruff's Stylist
@@ -78,7 +80,7 @@ pub(crate) fn remove_imports<'a>(
     for member in member_names {
         let alias_index = aliases
             .iter()
-            .position(|alias| member == compose_module_path(&alias.name));
+            .position(|alias| member == qualified_name_from_name_or_attribute(&alias.name));
         if let Some(index) = alias_index {
             aliases.remove(index);
         }
@@ -142,7 +144,7 @@ pub(crate) fn retain_imports(
     aliases.retain(|alias| {
         member_names
             .iter()
-            .any(|member| *member == compose_module_path(&alias.name))
+            .any(|member| *member == qualified_name_from_name_or_attribute(&alias.name))
     });
 
     // But avoid destroying any trailing comments.
@@ -164,3 +166,40 @@ pub(crate) fn retain_imports(
 
     Ok(tree.codegen_stylist(stylist))
 }
+
+fn collect_segments<'a>(expr: &'a Expression, parts: &mut SmallVec<[&'a str; 8]>) {
+    match expr {
+        Expression::Call(expr) => {
+            collect_segments(&expr.func, parts);
+        }
+        Expression::Attribute(expr) => {
+            collect_segments(&expr.value, parts);
+            parts.push(expr.attr.value);
+        }
+        Expression::Name(expr) => {
+            parts.push(expr.value);
+        }
+        _ => {}
+    }
+}
+
+fn unqualified_name_from_expression<'a>(expr: &'a Expression<'a>) -> Option<UnqualifiedName<'a>> {
+    let mut segments = smallvec![];
+    collect_segments(expr, &mut segments);
+    if segments.is_empty() {
+        None
+    } else {
+        Some(segments.into_iter().collect())
+    }
+}
+
+fn qualified_name_from_name_or_attribute(module: &NameOrAttribute) -> String {
+    match module {
+        NameOrAttribute::N(name) => name.value.to_string(),
+        NameOrAttribute::A(attr) => {
+            let name = attr.attr.value;
+            let prefix = unqualified_name_from_expression(&attr.value);
+            prefix.map_or_else(|| name.to_string(), |prefix| format!("{prefix}.{name}"))
+        }
+    }
+}

crates/ruff_linter/src/fix/edits.rs

@@ -62,6 +62,51 @@ pub(crate) fn delete_stmt(
     }
 }
 
+/// Generate a [`Edit`] to delete a comment (for example: a `noqa` directive).
+pub(crate) fn delete_comment(range: TextRange, locator: &Locator) -> Edit {
+    let line_range = locator.line_range(range.start());
+
+    // Compute the leading space.
+    let prefix = locator.slice(TextRange::new(line_range.start(), range.start()));
+    let leading_space_len = prefix.text_len() - prefix.trim_whitespace_end().text_len();
+
+    // Compute the trailing space.
+    let suffix = locator.slice(TextRange::new(range.end(), line_range.end()));
+    let trailing_space_len = suffix.text_len() - suffix.trim_whitespace_start().text_len();
+
+    // Ex) `# noqa`
+    if line_range
+        == TextRange::new(
+            range.start() - leading_space_len,
+            range.end() + trailing_space_len,
+        )
+    {
+        let full_line_end = locator.full_line_end(line_range.end());
+        Edit::deletion(line_range.start(), full_line_end)
+    }
+    // Ex) `x = 1  # noqa`
+    else if range.end() + trailing_space_len == line_range.end() {
+        Edit::deletion(range.start() - leading_space_len, line_range.end())
+    }
+    // Ex) `x = 1  # noqa  # type: ignore`
+    else if locator
+        .slice(TextRange::new(
+            range.end() + trailing_space_len,
+            line_range.end(),
+        ))
+        .starts_with('#')
+    {
+        Edit::deletion(range.start(), range.end() + trailing_space_len)
+    }
+    // Ex) `x = 1  # noqa here`
+    else {
+        Edit::deletion(
+            range.start() + "# ".text_len(),
+            range.end() + trailing_space_len,
+        )
+    }
+}
+
 /// Generate a `Fix` to remove the specified imports from an `import` statement.
 pub(crate) fn remove_unused_imports<'a>(
     member_names: impl Iterator<Item = &'a str>,

crates/ruff_linter/src/linter.rs

@@ -407,6 +407,7 @@ pub fn add_noqa_to_path(
         &diagnostics.0,
         &locator,
         indexer.comment_ranges(),
+        &settings.external,
         &directives.noqa_line_for,
         stylist.line_ending(),
     )

crates/ruff_linter/src/logging.rs

@@ -121,7 +121,7 @@ impl LogLevel {
     }
 }
 
-pub fn set_up_logging(level: &LogLevel) -> Result<()> {
+pub fn set_up_logging(level: LogLevel) -> Result<()> {
     fern::Dispatch::new()
         .format(|out, message, record| match record.level() {
             Level::Error => {

crates/ruff_linter/src/noqa.rs

@@ -235,6 +235,7 @@ impl FileExemption {
     pub(crate) fn try_extract(
         contents: &str,
         comment_ranges: &CommentRanges,
+        external: &[String],
         path: &Path,
         locator: &Locator,
     ) -> Option<Self> {
@@ -263,6 +264,11 @@ impl FileExemption {
                         }
                         ParsedFileExemption::Codes(codes) => {
                             exempt_codes.extend(codes.into_iter().filter_map(|code| {
+                                // Ignore externally-defined rules.
+                                if external.iter().any(|external| code.starts_with(external)) {
+                                    return None;
+                                }
+
                                 if let Ok(rule) = Rule::from_code(get_redirect_target(code).unwrap_or(code))
                                 {
                                     Some(rule.noqa_code())
@@ -458,6 +464,7 @@ pub(crate) fn add_noqa(
     diagnostics: &[Diagnostic],
     locator: &Locator,
     comment_ranges: &CommentRanges,
+    external: &[String],
     noqa_line_for: &NoqaMapping,
     line_ending: LineEnding,
 ) -> Result<usize> {
@@ -466,6 +473,7 @@ pub(crate) fn add_noqa(
         diagnostics,
         locator,
         comment_ranges,
+        external,
         noqa_line_for,
         line_ending,
     );
@@ -478,6 +486,7 @@ fn add_noqa_inner(
     diagnostics: &[Diagnostic],
     locator: &Locator,
     comment_ranges: &CommentRanges,
+    external: &[String],
     noqa_line_for: &NoqaMapping,
     line_ending: LineEnding,
 ) -> (usize, String) {
@@ -487,7 +496,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(), comment_ranges, path, locator);
+    let exemption =
+        FileExemption::try_extract(locator.contents(), comment_ranges, external, path, locator);
     let directives = NoqaDirectives::from_commented_ranges(comment_ranges, path, locator);
 
     // Mark any non-ignored diagnostics.
@@ -1001,6 +1011,7 @@ mod tests {
             &[],
             &Locator::new(contents),
             &CommentRanges::default(),
+            &[],
             &noqa_line_for,
             LineEnding::Lf,
         );
@@ -1021,6 +1032,7 @@ mod tests {
             &diagnostics,
             &Locator::new(contents),
             &CommentRanges::default(),
+            &[],
             &noqa_line_for,
             LineEnding::Lf,
         );
@@ -1048,6 +1060,7 @@ mod tests {
             &diagnostics,
             &Locator::new(contents),
             &comment_ranges,
+            &[],
             &noqa_line_for,
             LineEnding::Lf,
         );
@@ -1075,6 +1088,7 @@ mod tests {
             &diagnostics,
             &Locator::new(contents),
             &comment_ranges,
+            &[],
             &noqa_line_for,
             LineEnding::Lf,
         );

crates/ruff_linter/src/registry.rs

@@ -256,8 +256,6 @@ impl Rule {
             | Rule::MixedSpacesAndTabs
             | Rule::TrailingWhitespace => LintSource::PhysicalLines,
             Rule::AmbiguousUnicodeCharacterComment
-            | Rule::AmbiguousUnicodeCharacterDocstring
-            | Rule::AmbiguousUnicodeCharacterString
             | Rule::AvoidableEscapedQuote
             | Rule::BadQuotesDocstring
             | Rule::BadQuotesInlineString

crates/ruff_linter/src/renamer.rs

@@ -232,7 +232,7 @@ impl Renamer {
             }
             BindingKind::SubmoduleImport(import) => {
                 // Ex) Rename `import pandas.core` to `import pandas as pd`.
-                let module_name = import.call_path.first().unwrap();
+                let module_name = import.qualified_name.segments().first().unwrap();
                 Some(Edit::range_replacement(
                     format!("{module_name} as {target}"),
                     binding.range(),
@@ -248,6 +248,7 @@ impl Renamer {
             | BindingKind::Assignment
             | BindingKind::BoundException
             | BindingKind::LoopVar
+            | BindingKind::ComprehensionVar
             | BindingKind::WithItemVar
             | BindingKind::Global
             | BindingKind::Nonlocal(_)

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

@@ -68,8 +68,8 @@ pub(crate) fn variable_name_task_id(
     // If the function doesn't come from Airflow, we can't do anything.
     if !checker
         .semantic()
-        .resolve_call_path(func)
-        .is_some_and(|call_path| matches!(call_path[0], "airflow"))
+        .resolve_qualified_name(func)
+        .is_some_and(|qualified_name| matches!(qualified_name.segments()[0], "airflow"))
     {
         return None;
     }

crates/ruff_linter/src/rules/eradicate/detection.rs

@@ -26,7 +26,7 @@ static HASH_NUMBER: Lazy<Regex> = Lazy::new(|| Regex::new(r"#\d").unwrap());
 static POSITIVE_CASES: Lazy<RegexSet> = Lazy::new(|| {
     RegexSet::new([
         // Keywords
-        r"^(?:elif\s+.*\s*:|else\s*:|try\s*:|finally\s*:|except\s+.*\s*:)$",
+        r"^(?:elif\s+.*\s*:.*|else\s*:.*|try\s*:.*|finally\s*:.*|except.*:.*|case\s+.*\s*:.*)$",
         // Partial dictionary
         r#"^['"]\w+['"]\s*:.+[,{]\s*(#.*)?$"#,
         // Multiline assignment
@@ -147,6 +147,27 @@ mod tests {
         assert!(!comment_contains_code("#to print", &[]));
     }
 
+    #[test]
+    fn comment_contains_code_single_line() {
+        assert!(comment_contains_code("# case 1: print()", &[]));
+        assert!(comment_contains_code("# try: get(1, 2, 3)", &[]));
+        assert!(comment_contains_code("# else: print()", &[]));
+        assert!(comment_contains_code("# elif x == 10: print()", &[]));
+        assert!(comment_contains_code(
+            "# except Exception as e: print(e)",
+            &[]
+        ));
+        assert!(comment_contains_code("# except: print()", &[]));
+        assert!(comment_contains_code("# finally: close_handle()", &[]));
+
+        assert!(!comment_contains_code("# try: use cache", &[]));
+        assert!(!comment_contains_code("# else: we should return", &[]));
+        assert!(!comment_contains_code(
+            "# call function except: without cache",
+            &[]
+        ));
+    }
+
     #[test]
     fn comment_contains_code_with_multiline() {
         assert!(comment_contains_code("#else:", &[]));
@@ -155,11 +176,15 @@ mod tests {
         assert!(comment_contains_code("#elif True:", &[]));
         assert!(comment_contains_code("#x = foo(", &[]));
         assert!(comment_contains_code("#except Exception:", &[]));
+        assert!(comment_contains_code("# case 1:", &[]));
+        assert!(comment_contains_code("#case 1:", &[]));
+        assert!(comment_contains_code("# try:", &[]));
 
         assert!(!comment_contains_code("# this is = to that :(", &[]));
         assert!(!comment_contains_code("#else", &[]));
         assert!(!comment_contains_code("#or else:", &[]));
         assert!(!comment_contains_code("#else True:", &[]));
+        assert!(!comment_contains_code("# in that case:", &[]));
 
         // Unpacking assignments
         assert!(comment_contains_code(