Omit jemalloc on FreeBSD

2023-10-24 00:48:26 -04:00
505 changed files with 8604 additions and 14732 deletions
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -30,7 +30,7 @@ jobs:
        with:
          fetch-depth: 0

-      - uses: tj-actions/changed-files@v40
+      - uses: tj-actions/changed-files@v39
        id: changed
        with:
          files_yaml: |
@@ -43,7 +43,6 @@ jobs:
              - "!crates/ruff_dev/**"
              - "!crates/ruff_shrinking/**"
              - scripts/*
-              - .github/workflows/ci.yaml

            formatter:
              - Cargo.toml
@@ -58,7 +57,6 @@ jobs:
              - crates/ruff_python_parser/**
              - crates/ruff_dev/**
              - scripts/*
-              - .github/workflows/ci.yaml

  cargo-fmt:
    name: "cargo fmt"
@@ -84,9 +82,12 @@ jobs:
      - name: "Clippy (wasm)"
        run: cargo clippy -p ruff_wasm --target wasm32-unknown-unknown --all-features -- -D warnings

-  cargo-test-linux:
-    runs-on: ubuntu-latest
-    name: "cargo test (linux)"
+  cargo-test:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    name: "cargo test | ${{ matrix.os }}"
    steps:
      - uses: actions/checkout@v4
      - name: "Install Rust toolchain"
@@ -96,54 +97,25 @@ jobs:
        with:
          tool: cargo-insta
      - uses: Swatinem/rust-cache@v2
-      - name: "Run tests"
+      - name: "Run tests (Ubuntu)"
+        if: ${{ matrix.os == 'ubuntu-latest' }}
        run: cargo insta test --all --all-features --unreferenced reject
+      - name: "Run tests (Windows)"
+        if: ${{ matrix.os == 'windows-latest' }}
+        shell: bash
+        # We can't reject unreferenced snapshots on windows because flake8_executable can't run on windows
+        run: cargo insta test --all --all-features
      # 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
+        if: ${{ matrix.os == 'ubuntu-latest' }}
        with:
          name: ruff
          path: target/debug/ruff

-  cargo-test-windows:
-    runs-on: windows-latest
-    name: "cargo test (windows)"
-    steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - name: "Install cargo insta"
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-insta
-      - 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 --all-features
-
-  cargo-test-wasm:
-    runs-on: ubuntu-latest
-    name: "cargo test (wasm)"
-    steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 18
-          cache: "npm"
-          cache-dependency-path: playground/package-lock.json
-      - uses: jetli/wasm-pack-action@v0.4.0
-      - uses: Swatinem/rust-cache@v2
-      - name: "Run wasm-pack"
-        run: |
-          cd crates/ruff_wasm
-          wasm-pack test --node
-
  cargo-fuzz:
    runs-on: ubuntu-latest
    name: "cargo fuzz"
@@ -160,6 +132,25 @@ jobs:
          tool: cargo-fuzz@0.11
      - run: cargo fuzz build -s none

+  cargo-test-wasm:
+    runs-on: ubuntu-latest
+    name: "cargo test (wasm)"
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Install Rust toolchain"
+        run: rustup target add wasm32-unknown-unknown
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          cache: "npm"
+          cache-dependency-path: playground/package-lock.json
+      - uses: jetli/wasm-pack-action@v0.4.0
+      - uses: Swatinem/rust-cache@v2
+      - name: "Run wasm-pack"
+        run: |
+          cd crates/ruff_wasm
+          wasm-pack test --node
+
  scripts:
    name: "test scripts"
    runs-on: ubuntu-latest
@@ -181,10 +172,10 @@ jobs:
    name: "ecosystem"
    runs-on: ubuntu-latest
    needs:
-      - cargo-test-linux
+      - cargo-test
      - determine_changes
    # Only runs on pull requests, since that is the only we way we can find the base version for comparison.
-    if: github.event_name == 'pull_request'
+    if: github.event_name == 'pull_request' && needs.determine_changes.outputs.linter == 'true'
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v4
@@ -192,54 +183,27 @@ jobs:
          python-version: ${{ env.PYTHON_VERSION }}

      - uses: actions/download-artifact@v3
-        name: Download comparison Ruff binary
+        name: Download Ruff binary
        id: ruff-target
        with:
          name: ruff
          path: target/debug

      - uses: dawidd6/action-download-artifact@v2
-        name: Download baseline Ruff binary
+        name: Download base results
        with:
          name: ruff
          branch: ${{ github.event.pull_request.base.ref }}
          check_artifacts: true

-      - name: Install ruff-ecosystem
-        run: |
-          pip install ./python/ruff-ecosystem
-
-      - name: Run `ruff check` ecosystem check
-        if: ${{ needs.determine_changes.outputs.linter == 'true' }}
+      - name: Run ecosystem check
        run: |
          # Make executable, since artifact download doesn't preserve this
-          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
+          chmod +x ruff ${{ steps.ruff-target.outputs.download-path }}/ruff

-          # Set pipefail to avoid hiding errors with tee
-          set -eo pipefail
+          scripts/check_ecosystem.py ruff ${{ steps.ruff-target.outputs.download-path }}/ruff | tee ecosystem-result
+          cat ecosystem-result > $GITHUB_STEP_SUMMARY

-          ruff-ecosystem check ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff --cache ./checkouts --output-format markdown | tee ecosystem-result-check
-
-          cat ecosystem-result-check > $GITHUB_STEP_SUMMARY
-          cat ecosystem-result-check > ecosystem-result
-          echo "" >> ecosystem-result
-
-      - name: Run `ruff format` ecosystem check
-        if: ${{ needs.determine_changes.outputs.formatter == 'true' }}
-        run: |
-          # Make executable, since artifact download doesn't preserve this
-          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
-
-          # Set pipefail to avoid hiding errors with tee
-          set -eo pipefail
-
-          ruff-ecosystem format ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff --cache ./checkouts --output-format markdown | tee ecosystem-result-format
-
-          cat ecosystem-result-format > $GITHUB_STEP_SUMMARY
-          cat ecosystem-result-format >> ecosystem-result
-
-      - name: Export pull request number
-        run: |
          echo ${{ github.event.number }} > pr-number

      - uses: actions/upload-artifact@v3
@@ -355,8 +319,8 @@ jobs:
        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
        run: mkdocs build --strict -f mkdocs.generated.yml

-  check-formatter-instability-and-black-similarity:
-    name: "formatter instabilities and black similarity"
+  check-formatter-ecosystem:
+    name: "Formatter ecosystem and progress checks"
    runs-on: ubuntu-latest
    needs: determine_changes
    if: needs.determine_changes.outputs.formatter == 'true' || github.ref == 'refs/heads/main'
@@ -376,7 +340,7 @@ jobs:
  check-ruff-lsp:
    name: "test ruff-lsp"
    runs-on: ubuntu-latest
-    needs: cargo-test-linux
+    needs: cargo-test
    steps:
      - uses: extractions/setup-just@v1
        env:
--- a/.github/workflows/docs.yaml
+++ b/.github/workflows/docs.yaml
@@ -47,7 +47,7 @@ jobs:
        run: mkdocs build --strict -f mkdocs.generated.yml
      - name: "Deploy to Cloudflare Pages"
        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.3.2
+        uses: cloudflare/wrangler-action@v3.3.1
        with:
          apiToken: ${{ secrets.CF_API_TOKEN }}
          accountId: ${{ secrets.CF_ACCOUNT_ID }}
--- a/.github/workflows/playground.yaml
+++ b/.github/workflows/playground.yaml
@@ -20,7 +20,7 @@ jobs:
      - uses: actions/checkout@v4
      - name: "Install Rust toolchain"
        run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@v3
        with:
          node-version: 18
          cache: "npm"
@@ -40,7 +40,7 @@ jobs:
        working-directory: playground
      - name: "Deploy to Cloudflare Pages"
        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.3.2
+        uses: cloudflare/wrangler-action@v3.3.1
        with:
          apiToken: ${{ secrets.CF_API_TOKEN }}
          accountId: ${{ secrets.CF_ACCOUNT_ID }}
--- a/.github/workflows/pr-comment.yaml
+++ b/.github/workflows/pr-comment.yaml
@@ -41,7 +41,6 @@ jobs:
          workflow: ci.yaml
          pr: ${{ steps.pr-number.outputs.pr-number }}
          path: pr/ecosystem
-          workflow_conclusion: completed
          if_no_artifact_found: ignore

      - name: Generate Comment
--- a/.github/workflows/pre-commit.yaml
+++ b/.github/workflows/pre-commit.yaml
@@ -1,36 +0,0 @@
-# Until Dependabot support is released https://github.com/dependabot/dependabot-core/issues/1524
-name: Pre-commit update
-
-on:
-  # every week on monday
-  schedule:
-    - cron: "0 0 * * 1"
-  workflow_dispatch:
-
-permissions:
-  pull-requests: write
-
-jobs:
-  upgrade:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Configure Git
-        run: |
-          git config user.name "$GITHUB_ACTOR"
-          git config user.email "$GITHUB_ACTOR@users.noreply.github.com"
-
-      - name: Run autoupdate
-        run: |
-          pre-commit autoupdate
-
-      - name: Commit and push
-        run: |
-          git add ".pre-commit-config.yaml"
-          git commit -m "Upgrade pre-commit dependencies"
-          git push origin upgrade/pre-commit
-
-      - name: Open pull request
-        run: |
-          gh pr create --fill
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,115 +1,5 @@
 # Changelog

-## 0.1.3
-
-This release includes a variety of improvements to the Ruff formatter, removing several known and
-unintentional deviations from Black.
-
-### Formatter
-
- Avoid space around pow for `None`, `True` and `False` ([#8189](https://github.com/astral-sh/ruff/pull/8189))
- Avoid sorting all paths in the format command ([#8181](https://github.com/astral-sh/ruff/pull/8181))
- Insert necessary blank line between class and leading comments ([#8224](https://github.com/astral-sh/ruff/pull/8224))
- Avoid introducing new parentheses in annotated assignments ([#8233](https://github.com/astral-sh/ruff/pull/8233))
- Refine the warnings about incompatible linter options ([#8196](https://github.com/astral-sh/ruff/pull/8196))
- Add test and basic implementation for formatter preview mode ([#8044](https://github.com/astral-sh/ruff/pull/8044))
- Refine warning about incompatible `isort` settings ([#8192](https://github.com/astral-sh/ruff/pull/8192))
- Only omit optional parentheses for starting or ending with parentheses ([#8238](https://github.com/astral-sh/ruff/pull/8238))
- Use source type to determine parser mode for formatting ([#8205](https://github.com/astral-sh/ruff/pull/8205))
- Don't warn about magic trailing comma when `isort.force-single-line` is true ([#8244](https://github.com/astral-sh/ruff/pull/8244))
- Use `SourceKind::diff` for formatter ([#8240](https://github.com/astral-sh/ruff/pull/8240))
- Fix `fmt:off` with trailing child comment ([#8234](https://github.com/astral-sh/ruff/pull/8234))
- Formatter parentheses support for `IpyEscapeCommand` ([#8207](https://github.com/astral-sh/ruff/pull/8207))
-
-### Linter
-
- \[`pylint`\] Add buffer methods to `bad-dunder-method-name` (`PLW3201`) exclusions ([#8190](https://github.com/astral-sh/ruff/pull/8190))
- Match rule prefixes from `external` codes setting in `unused-noqa` ([#8177](https://github.com/astral-sh/ruff/pull/8177))
- Use `line-length` setting for isort in lieu of `pycodestyle.max-line-length` ([#8235](https://github.com/astral-sh/ruff/pull/8235))
- Update fix for `unnecessary-paren-on-raise-exception` to unsafe for unknown types ([#8231](https://github.com/astral-sh/ruff/pull/8231))
- Correct quick fix message for `W605` ([#8255](https://github.com/astral-sh/ruff/pull/8255))
-
-### Documentation
-
- Fix typo in max-doc-length documentation ([#8201](https://github.com/astral-sh/ruff/pull/8201))
- Improve documentation around linter-formatter conflicts ([#8257](https://github.com/astral-sh/ruff/pull/8257))
- Fix link to error suppression documentation in `unused-noqa` ([#8172](https://github.com/astral-sh/ruff/pull/8172))
- Add `external` option to `unused-noqa` documentation ([#8171](https://github.com/astral-sh/ruff/pull/8171))
- Add title attribute to icons ([#8060](https://github.com/astral-sh/ruff/pull/8060))
- Clarify unsafe case in RSE102 ([#8256](https://github.com/astral-sh/ruff/pull/8256))
- Fix skipping formatting examples ([#8210](https://github.com/astral-sh/ruff/pull/8210))
- docs: fix name of `magic-trailing-comma` option in README ([#8200](https://github.com/astral-sh/ruff/pull/8200))
- Add note about scope of rule changing in versioning policy ([#8169](https://github.com/astral-sh/ruff/pull/8169))
- Document: Fix default lint rules ([#8218](https://github.com/astral-sh/ruff/pull/8218))
- Fix a wrong setting in configuration.md ([#8186](https://github.com/astral-sh/ruff/pull/8186))
- Fix misspelled TOML headers in the tutorial ([#8209](https://github.com/astral-sh/ruff/pull/8209))
-
-## 0.1.2
-
-This release includes the Beta version of the Ruff formatter — an extremely fast, Black-compatible Python formatter.
-Try it today with `ruff format`! [Check out the blog post](https://astral.sh/blog/the-ruff-formatter) and [read the docs](https://docs.astral.sh/ruff/formatter/).
-
-### Preview features
-
- \[`pylint`\] Implement `non-ascii-module-import` (`C2403`) ([#8056](https://github.com/astral-sh/ruff/pull/8056))
- \[`pylint`\] implement `non-ascii-name` (`C2401`) ([#8038](https://github.com/astral-sh/ruff/pull/8038))
- \[`pylint`\] Implement unnecessary-lambda (W0108) ([#7953](https://github.com/astral-sh/ruff/pull/7953))
- \[`refurb`\] Implement `read-whole-file` (`FURB101`) ([#7682](https://github.com/astral-sh/ruff/pull/7682))
- Add fix for `E223`, `E224`, and `E242` ([#8143](https://github.com/astral-sh/ruff/pull/8143))
- Add fix for `E225`, `E226`, `E227`, and `E228` ([#8136](https://github.com/astral-sh/ruff/pull/8136))
- Add fix for `E252` ([#8142](https://github.com/astral-sh/ruff/pull/8142))
- Add fix for `E261` ([#8114](https://github.com/astral-sh/ruff/pull/8114))
- Add fix for `E273` and `E274` ([#8144](https://github.com/astral-sh/ruff/pull/8144))
- Add fix for `E275` ([#8133](https://github.com/astral-sh/ruff/pull/8133))
- Update `SIM401` to catch ternary operations ([#7415](https://github.com/astral-sh/ruff/pull/7415))
- Update `E721` to allow `is` and `is` not for direct type comparisons ([#7905](https://github.com/astral-sh/ruff/pull/7905))
-
-### Rule changes
-
- Add `backports.strenum` to `deprecated-imports` ([#8113](https://github.com/astral-sh/ruff/pull/8113))
- Update `SIM112` to ignore `https_proxy`, `http_proxy`, and `no_proxy` ([#8140](https://github.com/astral-sh/ruff/pull/8140))
- Update fix for `literal-membership` (`PLR6201`) to be unsafe ([#8097](https://github.com/astral-sh/ruff/pull/8097))
- Update fix for  `mutable-argument-defaults` (`B006`) to be unsafe ([#8108](https://github.com/astral-sh/ruff/pull/8108))
-
-### Formatter
-
- Change `line-ending` default to `auto` ([#8057](https://github.com/astral-sh/ruff/pull/8057))
- Respect parenthesized generators in `has_own_parentheses` ([#8100](https://github.com/astral-sh/ruff/pull/8100))
- Add caching to formatter ([#8089](https://github.com/astral-sh/ruff/pull/8089))
- Remove `--line-length` option from `format` command ([#8131](https://github.com/astral-sh/ruff/pull/8131))
- Add formatter to `line-length` documentation ([#8150](https://github.com/astral-sh/ruff/pull/8150))
- Warn about incompatible formatter options ([#8088](https://github.com/astral-sh/ruff/pull/8088))
- Fix range of unparenthesized tuple subject in match statement ([#8101](https://github.com/astral-sh/ruff/pull/8101))
- Remove experimental formatter warning ([#8148](https://github.com/astral-sh/ruff/pull/8148))
- Don't move type param opening parenthesis comment ([#8163](https://github.com/astral-sh/ruff/pull/8163))
- Update versions in format benchmark script ([#8110](https://github.com/astral-sh/ruff/pull/8110))
- Avoid loading files for cached format results ([#8134](https://github.com/astral-sh/ruff/pull/8134))
-
-### CLI
-
- Show the `ruff format` command in help menus ([#8167](https://github.com/astral-sh/ruff/pull/8167))
- Add `ruff version` command with long version display ([#8034](https://github.com/astral-sh/ruff/pull/8034))
-
-### Configuration
-
- New `pycodestyle.max-line-length` option ([#8039](https://github.com/astral-sh/ruff/pull/8039))
-
-### Bug fixes
-
- Detect `sys.version_info` slices in `outdated-version-block` ([#8112](https://github.com/astral-sh/ruff/pull/8112))
- Avoid if-else simplification for `TYPE_CHECKING` blocks ([#8072](https://github.com/astral-sh/ruff/pull/8072))
- Avoid false-positive print separator diagnostic with starred argument ([#8079](https://github.com/astral-sh/ruff/pull/8079))
-
-### Documentation
-
- Fix message for `too-many-arguments` lint ([#8092](https://github.com/astral-sh/ruff/pull/8092))
- Fix `extend-unsafe-fixes` and `extend-safe-fixes` example ([#8139](https://github.com/astral-sh/ruff/pull/8139))
- Add links to `flake8-import-conventions` options ([#8115](https://github.com/astral-sh/ruff/pull/8115))
- Rework the documentation to incorporate the Ruff formatter ([#7732](https://github.com/astral-sh/ruff/pull/7732))
- Fix `Options` JSON schema description ([#8081](https://github.com/astral-sh/ruff/pull/8081))
- Fix typo (`pytext` -> `pytest`) ([#8117](https://github.com/astral-sh/ruff/pull/8117))
- Improve `magic-value-comparison` example in docs ([#8111](https://github.com/astral-sh/ruff/pull/8111))
-
 ## 0.1.1

 ### Rule changes
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -114,7 +114,7 @@ such that all crates are contained in a flat `crates` directory.
 The vast majority of the code, including all lint rules, lives in the `ruff` crate (located at
 `crates/ruff_linter`). As a contributor, that's the crate that'll be most relevant to you.

-At the time of writing, the repository includes the following crates:
+At time of writing, the repository includes the following crates:

 - `crates/ruff_linter`: library crate containing all lint rules and the core logic for running them.
    If you're working on a rule, this is the crate for you.
@@ -877,5 +877,5 @@ By default, `src` is set to the project root. In the above example, we'd want to
 `src = ["./src"]` to ensure that we locate `./my_project/src/foo` and thus categorize `import foo`
 as first-party in `baz.py`. In practice, for this limited example, setting `src = ["./src"]` is
 unnecessary, as all imports within `./my_project/src/foo` would be categorized as first-party via
-the same-package heuristic; but if your project contains multiple packages, you'll want to set `src`
+the same-package heuristic; but your project contains multiple packages, you'll want to set `src`
 explicitly.
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -313,9 +313,9 @@ dependencies = [

 [[package]]
 name = "clap"
-version = "4.4.7"
+version = "4.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac495e00dcec98c83465d5ad66c5c4fabd652fd6686e7c6269b117e729a6f17b"
+checksum = "d04704f56c2cde07f43e8e2c154b43f216dc5c92fc98ada720177362f953b956"
 dependencies = [
 "clap_builder",
 "clap_derive",
@@ -323,9 +323,9 @@ dependencies = [

 [[package]]
 name = "clap_builder"
-version = "4.4.7"
+version = "4.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77ed9a32a62e6ca27175d00d29d05ca32e396ea1eb5fb01d8256b669cec7663"
+checksum = "0e231faeaca65ebd1ea3c737966bf858971cd38c3849107aa3ea7de90a804e45"
 dependencies = [
 "anstream",
 "anstyle",
@@ -376,9 +376,9 @@ dependencies = [

 [[package]]
 name = "clap_derive"
-version = "4.4.7"
+version = "4.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
+checksum = "0862016ff20d69b84ef8247369fabf5c008a7417002411897d40ee1f4532b873"
 dependencies = [
 "heck",
 "proc-macro2",
@@ -388,9 +388,9 @@ dependencies = [

 [[package]]
 name = "clap_lex"
-version = "0.6.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
+checksum = "cd7cc57abe963c6d3b9d8be5b06ba7c8957a930305ca90304f24ef040aa6f961"

 [[package]]
 name = "clearscreen"
@@ -810,7 +810,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"

 [[package]]
 name = "flake8-to-ruff"
-version = "0.1.3"
+version = "0.1.1"
 dependencies = [
 "anyhow",
 "clap",
@@ -1262,9 +1262,9 @@ dependencies = [

 [[package]]
 name = "libc"
-version = "0.2.149"
+version = "0.2.147"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a08173bc88b7955d1b3145aa561539096c421ac8debde8cbc3612ec635fee29b"
+checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"

 [[package]]
 name = "libcst"
@@ -1309,9 +1309,9 @@ checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"

 [[package]]
 name = "linux-raw-sys"
-version = "0.4.10"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da2479e8c062e40bf0066ffa0bc823de0a9368974af99c9f6df941d2c231e03f"
+checksum = "57bcfdad1b858c2db7c38303a6d2ad4dfaf5eb53dfeb0910128b2c26d6158503"

 [[package]]
 name = "lock_api"
@@ -1801,9 +1801,9 @@ dependencies = [

 [[package]]
 name = "pyproject-toml"
-version = "0.8.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0774c13ff0b8b7ebb4791c050c497aefcfe3f6a222c0829c7017161ed38391ff"
+checksum = "569e259cd132eb8cec5df8b672d187c5260f82ad352156b5da9549d4472e64b0"
 dependencies = [
 "indexmap",
 "pep440_rs",
@@ -1912,15 +1912,6 @@ dependencies = [
 "bitflags 1.3.2",
 ]

-[[package]]
-name = "redox_syscall"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
-dependencies = [
- "bitflags 1.3.2",
-]
-
 [[package]]
 name = "redox_users"
 version = "0.4.3"
@@ -2060,7 +2051,7 @@ dependencies = [

 [[package]]
 name = "ruff_cli"
-version = "0.1.3"
+version = "0.1.1"
 dependencies = [
 "annotate-snippets 0.9.1",
 "anyhow",
@@ -2081,6 +2072,7 @@ dependencies = [
 "insta-cmd",
 "is-macro",
 "itertools 0.11.0",
+ "itoa",
 "log",
 "mimalloc",
 "notify",
@@ -2196,7 +2188,7 @@ dependencies = [

 [[package]]
 name = "ruff_linter"
-version = "0.1.3"
+version = "0.1.1"
 dependencies = [
 "aho-corasick",
 "annotate-snippets 0.9.1",
@@ -2389,7 +2381,6 @@ dependencies = [
 "itertools 0.11.0",
 "lalrpop",
 "lalrpop-util",
- "memchr",
 "ruff_python_ast",
 "ruff_text_size",
 "rustc-hash",
@@ -2447,7 +2438,7 @@ dependencies = [

 [[package]]
 name = "ruff_shrinking"
-version = "0.1.3"
+version = "0.1.1"
 dependencies = [
 "anyhow",
 "clap",
@@ -2559,9 +2550,9 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"

 [[package]]
 name = "rustix"
-version = "0.38.21"
+version = "0.38.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b426b0506e5d50a7d8dafcf2e81471400deb602392c7dd110815afb4eaf02a3"
+checksum = "ed6248e1caa625eb708e266e06159f135e8c26f2bb7ceb72dc4b2766d0340964"
 dependencies = [
 "bitflags 2.4.0",
 "errno",
@@ -2673,9 +2664,9 @@ checksum = "836fa6a3e1e547f9a2c4040802ec865b5d85f4014efe00555d7090a3dcaa1090"

 [[package]]
 name = "serde"
-version = "1.0.190"
+version = "1.0.188"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91d3c334ca1ee894a2c6f6ad698fe8c435b76d504b13d436f0685d648d6d96f7"
+checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e"
 dependencies = [
 "serde_derive",
 ]
@@ -2693,9 +2684,9 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.190"
+version = "1.0.188"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67c5609f394e5c2bd7fc51efda478004ea80ef42fee983d5c67a65e34f32c0e3"
+checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2892,13 +2883,13 @@ dependencies = [

 [[package]]
 name = "tempfile"
-version = "3.8.1"
+version = "3.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef1adac450ad7f4b3c28589471ade84f25f731a7a0fe30d71dfa9f60fd808e5"
+checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef"
 dependencies = [
 "cfg-if",
 "fastrand",
- "redox_syscall 0.4.1",
+ "redox_syscall 0.3.5",
 "rustix",
 "windows-sys 0.48.0",
 ]
@@ -3331,9 +3322,9 @@ checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"

 [[package]]
 name = "uuid"
-version = "1.5.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88ad59a7560b41a70d191093a945f0b87bc1deeda46fb237479708a1d6b6cdfc"
+checksum = "79daa5ed5740825c40b389c5e50312b9c86df53fccd33f281df655642b43869d"
 dependencies = [
 "getrandom",
 "rand",
@@ -3343,9 +3334,9 @@ dependencies = [

 [[package]]
 name = "uuid-macro-internal"
-version = "1.5.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d8c6bba9b149ee82950daefc9623b32bb1dacbfb1890e352f6b887bd582adaf"
+checksum = "f7e1ba1f333bd65ce3c9f27de592fcbc256dafe3af2717f56d7c87761fbaccf4"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,7 @@ license = "MIT"
 anyhow = { version = "1.0.69" }
 bitflags = { version = "2.3.1" }
 chrono = { version = "0.4.31", default-features = false, features = ["clock"] }
-clap = { version = "4.4.7", features = ["derive"] }
+clap = { version = "4.4.6", features = ["derive"] }
 colored = { version = "2.0.0" }
 filetime = { version = "0.2.20" }
 glob = { version = "0.3.1" }
@@ -34,7 +34,7 @@ quote = { version = "1.0.23" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "1.1.0" }
 schemars = { version = "0.8.15" }
-serde = { version = "1.0.190", features = ["derive"] }
+serde = { version = "1.0.152", features = ["derive"] }
 serde_json = { version = "1.0.107" }
 shellexpand = { version = "3.0.0" }
 similar = { version = "2.3.0", features = ["inline"] }
@@ -52,7 +52,7 @@ tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 unicode-ident = { version = "1.0.12" }
 unicode_names2 = { version = "1.2.0" }
 unicode-width = { version = "0.1.11" }
-uuid = { version = "1.5.0", features = ["v4", "fast-rng", "macro-diagnostics", "js"] }
+uuid = { version = "1.4.1", features = ["v4", "fast-rng", "macro-diagnostics", "js"] }
 wsl = { version = "0.1.0" }

 [profile.release]
--- a/README.md
+++ b/README.md
@@ -33,7 +33,7 @@ An extremely fast Python linter and code formatter, written in Rust.
 - 🔧 Fix support, for automatic error correction (e.g., automatically remove unused imports)
 - 📏 Over [700 built-in rules](https://docs.astral.sh/ruff/rules/), with native re-implementations
    of popular Flake8 plugins, like flake8-bugbear
- ⌨️ First-party [editor integrations](https://docs.astral.sh/ruff/integrations/) for
+- ⌨️ First-party [editor integrations](https://docs.astral.sh/ruff/editor-integrations/) for
    [VS Code](https://github.com/astral-sh/ruff-vscode) and [more](https://github.com/astral-sh/ruff-lsp)
 - 🌎 Monorepo-friendly, with [hierarchical and cascading configuration](https://docs.astral.sh/ruff/configuration/#pyprojecttoml-discovery)

@@ -151,7 +151,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 # Run the Ruff linter.
 - repo: https://github.com/astral-sh/ruff-pre-commit
  # Ruff version.
-  rev: v0.1.3
+  rev: v0.1.1
  hooks:
    # Run the Ruff linter.
    - id: ruff
@@ -238,7 +238,7 @@ quote-style = "double"
 indent-style = "space"

 # Like Black, respect magic trailing commas.
-skip-magic-trailing-comma = false
+magic-trailing-comma = "respect"

 # Like Black, automatically detect the appropriate line ending.
 line-ending = "auto"
@@ -409,7 +409,6 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [Mypy](https://github.com/python/mypy)
 - Netflix ([Dispatch](https://github.com/Netflix/dispatch))
 - [Neon](https://github.com/neondatabase/neon)
- [NoneBot](https://github.com/nonebot/nonebot2)
 - [ONNX](https://github.com/onnx/onnx)
 - [OpenBB](https://github.com/OpenBB-finance/OpenBBTerminal)
 - [PDM](https://github.com/pdm-project/pdm)
--- a/crates/flake8_to_ruff/Cargo.toml
+++ b/crates/flake8_to_ruff/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.1.3"
+version = "0.1.1"
 description = """
 Convert Flake8 configuration files to Ruff configuration files.
 """
--- a/crates/ruff_benchmark/benches/formatter.rs
+++ b/crates/ruff_benchmark/benches/formatter.rs
@@ -16,6 +16,7 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 #[cfg(all(
    not(target_os = "windows"),
    not(target_os = "openbsd"),
+    not(target_os = "freebsd"),
    any(
        target_arch = "x86_64",
        target_arch = "aarch64",
--- a/crates/ruff_benchmark/benches/lexer.rs
+++ b/crates/ruff_benchmark/benches/lexer.rs
@@ -11,6 +11,7 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 #[cfg(all(
    not(target_os = "windows"),
    not(target_os = "openbsd"),
+    not(target_os = "freebsd"),
    any(
        target_arch = "x86_64",
        target_arch = "aarch64",
--- a/crates/ruff_benchmark/benches/linter.rs
+++ b/crates/ruff_benchmark/benches/linter.rs
@@ -16,6 +16,7 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 #[cfg(all(
    not(target_os = "windows"),
    not(target_os = "openbsd"),
+    not(target_os = "freebsd"),
    any(
        target_arch = "x86_64",
        target_arch = "aarch64",
--- a/crates/ruff_benchmark/benches/parser.rs
+++ b/crates/ruff_benchmark/benches/parser.rs
@@ -13,6 +13,7 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 #[cfg(all(
    not(target_os = "windows"),
    not(target_os = "openbsd"),
+    not(target_os = "freebsd"),
    any(
        target_arch = "x86_64",
        target_arch = "aarch64",
--- a/crates/ruff_cli/Cargo.toml
+++ b/crates/ruff_cli/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_cli"
-version = "0.1.3"
+version = "0.1.1"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -44,6 +44,7 @@ glob = { workspace = true }
 ignore = { workspace = true }
 is-macro = { workspace = true }
 itertools = { workspace = true }
+itoa = { version = "1.0.6" }
 log = { workspace = true }
 notify = { version = "6.1.1" }
 path-absolutize = { workspace = true, features = ["once_cell_cache"] }
@@ -67,7 +68,7 @@ assert_cmd = { version = "2.0.8" }
 colored = { workspace = true, features = ["no-color"]}
 insta = { workspace = true, features = ["filters", "json"] }
 insta-cmd = { version = "0.4.0" }
-tempfile = "3.8.1"
+tempfile = "3.6.0"
 test-case = { workspace = true }
 ureq = { version = "2.8.0", features = [] }

--- a/crates/ruff_cli/resources/test/fixtures/unformatted.ipynb
+++ b/crates/ruff_cli/resources/test/fixtures/unformatted.ipynb
@@ -11,41 +11,6 @@
    "maths = (numpy.arange(100)**2).sum()\n",
    "stats= numpy.asarray([1,2,3,4]).median()"
   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "83a0b1b8",
-   "metadata": {},
-   "source": [
-    "A markdown cell"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ae12f012",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# A cell with IPython escape command\n",
-    "def some_function(foo, bar):\n",
-    "    pass\n",
-    "%matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "10f3bbf9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "foo = %pwd\n",
-    "def some_function(foo,bar,):\n",
-    "    # Another cell with IPython escape command\n",
-    "    foo = %pwd\n",
-    "    print(foo)"
-   ]
  }
 ],
 "metadata": {
--- a/crates/ruff_cli/src/args.rs
+++ b/crates/ruff_cli/src/args.rs
@@ -13,7 +13,6 @@ use ruff_linter::settings::types::{
 };
 use ruff_linter::{RuleParser, RuleSelector, RuleSelectorParser};
 use ruff_workspace::configuration::{Configuration, RuleSelection};
-use ruff_workspace::options::PycodestyleOptions;
 use ruff_workspace::resolver::ConfigurationTransformer;

 #[derive(Debug, Parser)]
@@ -50,11 +49,7 @@ 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>,
+        format: HelpFormat,
    },
    /// List or describe the available configuration options.
    Config { option: Option<String> },
@@ -62,11 +57,7 @@ pub enum Command {
    Linter {
        /// 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>,
+        format: HelpFormat,
    },
    /// Clear any caches in the current directory and any subdirectories.
    #[clap(alias = "--clean")]
@@ -75,6 +66,8 @@ pub enum Command {
    #[clap(alias = "--generate-shell-completion", hide = true)]
    GenerateShellCompletion { shell: clap_complete_command::Shell },
    /// Run the Ruff formatter on the given files or directories.
+    #[doc(hidden)]
+    #[clap(hide = true)]
    Format(FormatCommand),
    /// Display Ruff's version
    Version {
@@ -409,6 +402,9 @@ pub struct FormatCommand {
    force_exclude: bool,
    #[clap(long, overrides_with("force_exclude"), hide = true)]
    no_force_exclude: bool,
+    /// Set the line-length.
+    #[arg(long, help_heading = "Rule configuration", hide = true)]
+    pub line_length: Option<LineLength>,
    /// Ignore all configuration files.
    #[arg(long, conflicts_with = "config", help_heading = "Miscellaneous")]
    pub isolated: bool,
@@ -507,7 +503,6 @@ impl CheckCommand {
                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,
@@ -552,6 +547,7 @@ impl FormatCommand {
                stdin_filename: self.stdin_filename,
            },
            CliOverrides {
+                line_length: self.line_length,
                respect_gitignore: resolve_bool_arg(
                    self.respect_gitignore,
                    self.no_respect_gitignore,
@@ -628,7 +624,6 @@ pub struct CliOverrides {
    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>>,
@@ -659,12 +654,6 @@ impl ConfigurationTransformer for CliOverrides {
        if let Some(extend_exclude) = &self.extend_exclude {
            config.extend_exclude.extend(extend_exclude.clone());
        }
-        if let Some(extend_per_file_ignores) = &self.extend_per_file_ignores {
-            config
-                .lint
-                .extend_per_file_ignores
-                .extend(collect_per_file_ignores(extend_per_file_ignores.clone()));
-        }
        if let Some(fix) = &self.fix {
            config.fix = Some(*fix);
        }
@@ -700,12 +689,8 @@ impl ConfigurationTransformer for CliOverrides {
        if let Some(force_exclude) = &self.force_exclude {
            config.force_exclude = Some(*force_exclude);
        }
-        if let Some(line_length) = self.line_length {
-            config.line_length = Some(line_length);
-            config.lint.pycodestyle = Some(PycodestyleOptions {
-                max_line_length: Some(line_length),
-                ..config.lint.pycodestyle.unwrap_or_default()
-            });
+        if let Some(line_length) = &self.line_length {
+            config.line_length = Some(*line_length);
        }
        if let Some(preview) = &self.preview {
            config.preview = Some(*preview);
--- a/crates/ruff_cli/src/bin/ruff.rs
+++ b/crates/ruff_cli/src/bin/ruff.rs
@@ -13,6 +13,7 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 #[cfg(all(
    not(target_os = "windows"),
    not(target_os = "openbsd"),
+    not(target_os = "freebsd"),
    any(
        target_arch = "x86_64",
        target_arch = "aarch64",
--- a/crates/ruff_cli/src/cache.rs
+++ b/crates/ruff_cli/src/cache.rs
@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::fmt::Debug;
 use std::fs::{self, File};
 use std::hash::Hasher;
@@ -19,7 +20,7 @@ use serde::{Deserialize, Serialize};
 use ruff_cache::{CacheKey, CacheKeyHasher};
 use ruff_diagnostics::{DiagnosticKind, Fix};
 use ruff_linter::message::Message;
-use ruff_linter::{warn_user, VERSION};
+use ruff_linter::warn_user;
 use ruff_macros::CacheKey;
 use ruff_notebook::NotebookIndex;
 use ruff_python_ast::imports::ImportMap;
@@ -101,8 +102,9 @@ impl Cache {
    pub(crate) fn open(package_root: PathBuf, settings: &Settings) -> Self {
        debug_assert!(package_root.is_absolute(), "package root not canonicalized");

-        let key = format!("{}", cache_key(&package_root, settings));
-        let path = PathBuf::from_iter([&settings.cache_dir, Path::new(VERSION), Path::new(&key)]);
+        let mut buf = itoa::Buffer::new();
+        let key = Path::new(buf.format(cache_key(&package_root, settings)));
+        let path = PathBuf::from_iter([&settings.cache_dir, Path::new("content"), key]);

        let file = match File::open(&path) {
            Ok(file) => file,
@@ -140,7 +142,7 @@ impl Cache {
    fn empty(path: PathBuf, package_root: PathBuf) -> Self {
        let package = PackageCache {
            package_root,
-            files: FxHashMap::default(),
+            files: HashMap::new(),
        };
        Cache::new(path, package)
    }
@@ -292,7 +294,7 @@ struct PackageCache {
    /// single file "packages", e.g. scripts.
    package_root: PathBuf,
    /// Mapping of source file path to it's cached data.
-    files: FxHashMap<RelativePathBuf, FileCache>,
+    files: HashMap<RelativePathBuf, FileCache>,
 }

 /// On disk representation of the cache per source file.
@@ -348,16 +350,16 @@ struct FileCacheData {
 /// version.
 fn cache_key(package_root: &Path, settings: &Settings) -> u64 {
    let mut hasher = CacheKeyHasher::new();
+    env!("CARGO_PKG_VERSION").cache_key(&mut hasher);
    package_root.cache_key(&mut hasher);
    settings.cache_key(&mut hasher);
-
    hasher.finish()
 }

 /// Initialize the cache at the specified `Path`.
 pub(crate) fn init(path: &Path) -> Result<()> {
    // Create the cache directories.
-    fs::create_dir_all(path.join(VERSION))?;
+    fs::create_dir_all(path.join("content"))?;

    // Add the CACHEDIR.TAG.
    if !cachedir::is_tagged(path)? {
--- a/crates/ruff_cli/src/commands/check.rs
+++ b/crates/ruff_cli/src/commands/check.rs
@@ -82,7 +82,7 @@ pub(crate) fn check(

                let settings = resolver.resolve(path, pyproject_config);

-                if (settings.file_resolver.force_exclude || !resolved_file.is_root())
+                if !resolved_file.is_root()
                    && match_exclusion(
                        resolved_file.path(),
                        resolved_file.file_name(),
--- a/crates/ruff_cli/src/commands/check_stdin.rs
+++ b/crates/ruff_cli/src/commands/check_stdin.rs
@@ -18,19 +18,17 @@ pub(crate) fn check_stdin(
    noqa: flags::Noqa,
    fix_mode: flags::FixMode,
 ) -> Result<Diagnostics> {
-    if pyproject_config.settings.file_resolver.force_exclude {
-        if let Some(filename) = filename {
-            if !python_file_at_path(filename, pyproject_config, overrides)? {
-                return Ok(Diagnostics::default());
-            }
+    if let Some(filename) = filename {
+        if !python_file_at_path(filename, pyproject_config, overrides)? {
+            return Ok(Diagnostics::default());
+        }

-            let lint_settings = &pyproject_config.settings.linter;
-            if filename
-                .file_name()
-                .is_some_and(|name| match_exclusion(filename, name, &lint_settings.exclude))
-            {
-                return Ok(Diagnostics::default());
-            }
+        let lint_settings = &pyproject_config.settings.linter;
+        if filename
+            .file_name()
+            .is_some_and(|name| match_exclusion(filename, name, &lint_settings.exclude))
+        {
+            return Ok(Diagnostics::default());
        }
    }
    let package_root = filename.and_then(Path::parent).and_then(|path| {
--- a/crates/ruff_cli/src/commands/format.rs
+++ b/crates/ruff_cli/src/commands/format.rs
@@ -11,7 +11,7 @@ use itertools::Itertools;
 use log::{error, warn};
 use rayon::iter::Either::{Left, Right};
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
-use rustc_hash::FxHashSet;
+use similar::TextDiff;
 use thiserror::Error;
 use tracing::debug;

@@ -19,11 +19,12 @@ use ruff_diagnostics::SourceMap;
 use ruff_linter::fs;
 use ruff_linter::logging::LogLevel;
 use ruff_linter::registry::Rule;
-use ruff_linter::rules::flake8_quotes::settings::Quote;
+use ruff_linter::rules::isort;
+use ruff_linter::settings::rule_table::RuleTable;
 use ruff_linter::source_kind::{SourceError, SourceKind};
 use ruff_linter::warn_user_once;
 use ruff_python_ast::{PySourceType, SourceType};
-use ruff_python_formatter::{format_module_source, FormatModuleError, QuoteStyle};
+use ruff_python_formatter::{format_module_source, FormatModuleError};
 use ruff_text_size::{TextLen, TextRange, TextSize};
 use ruff_workspace::resolver::{
    match_exclusion, python_files_in_path, PyprojectConfig, ResolvedFile, Resolver,
@@ -106,7 +107,7 @@ pub(crate) fn format(
    };

    let start = Instant::now();
-    let (results, mut errors): (Vec<_>, Vec<_>) = paths
+    let (mut results, mut errors): (Vec<_>, Vec<_>) = paths
        .par_iter()
        .filter_map(|entry| {
            match entry {
@@ -117,14 +118,14 @@ pub(crate) fn format(
                        return None;
                    };

-                    let settings = resolver.resolve(path, &pyproject_config);
+                    let resolved_settings = resolver.resolve(path, &pyproject_config);

                    // Ignore files that are excluded from formatting
-                    if (settings.file_resolver.force_exclude || !resolved_file.is_root())
+                    if !resolved_file.is_root()
                        && match_exclusion(
                            path,
                            resolved_file.file_name(),
-                            &settings.formatter.exclude,
+                            &resolved_settings.formatter.exclude,
                        )
                    {
                        return None;
@@ -139,7 +140,13 @@ pub(crate) fn format(

                    Some(
                        match catch_unwind(|| {
-                            format_path(path, &settings.formatter, source_type, mode, cache)
+                            format_path(
+                                path,
+                                &resolved_settings.formatter,
+                                source_type,
+                                mode,
+                                cache,
+                            )
                        }) {
                            Ok(inner) => inner.map(|result| FormatPathResult {
                                path: resolved_file.path().to_path_buf(),
@@ -161,6 +168,27 @@ pub(crate) fn format(
        });
    let duration = start.elapsed();

+    // Make output deterministic, at least as long as we have a path
+    results.sort_unstable_by(|x, y| x.path.cmp(&y.path));
+    errors.sort_by(|x, y| {
+        fn get_key(error: &FormatCommandError) -> Option<&PathBuf> {
+            match &error {
+                FormatCommandError::Ignore(ignore) => {
+                    if let ignore::Error::WithPath { path, .. } = ignore {
+                        Some(path)
+                    } else {
+                        None
+                    }
+                }
+                FormatCommandError::Panic(path, _)
+                | FormatCommandError::Read(path, _)
+                | FormatCommandError::Format(path, _)
+                | FormatCommandError::Write(path, _) => path.as_ref(),
+            }
+        }
+        get_key(x).cmp(&get_key(y))
+    });
+
    debug!(
        "Formatted {} files in {:.2?}",
        results.len() + errors.len(),
@@ -170,21 +198,15 @@ pub(crate) fn format(
    caches.persist()?;

    // Report on any errors.
-    errors.sort_unstable_by(|a, b| a.path().cmp(&b.path()));
-
    for error in &errors {
        error!("{error}");
    }

+    results.sort_unstable_by(|a, b| a.path.cmp(&b.path));
    let results = FormatResults::new(results.as_slice(), mode);
-    match mode {
-        FormatMode::Write => {}
-        FormatMode::Check => {
-            results.write_changed(&mut stdout().lock())?;
-        }
-        FormatMode::Diff => {
-            results.write_diff(&mut stdout().lock())?;
-        }
+
+    if mode.is_diff() {
+        results.write_diff(&mut stdout().lock())?;
    }

    // Report on the formatting changes.
@@ -415,7 +437,7 @@ pub(crate) enum FormatResult {
    /// The file was unchanged, as the formatted contents matched the existing contents.
    Unchanged,

-    /// Skipped formatting because its an unsupported file format
+    /// Skipped formatting because its an unformatted file format
    Skipped,
 }

@@ -448,51 +470,27 @@ impl<'a> FormatResults<'a> {
        })
    }

-    /// Write a diff of the formatting changes to the given writer.
    fn write_diff(&self, f: &mut impl Write) -> io::Result<()> {
-        for (path, unformatted, formatted) in self
-            .results
-            .iter()
-            .filter_map(|result| {
-                if let FormatResult::Diff {
-                    unformatted,
-                    formatted,
-                } = &result.result
-                {
-                    Some((result.path.as_path(), unformatted, formatted))
-                } else {
-                    None
-                }
-            })
-            .sorted_unstable_by_key(|(path, _, _)| *path)
-        {
-            unformatted.diff(formatted, Some(path), f)?;
+        for result in self.results {
+            if let FormatResult::Diff {
+                unformatted,
+                formatted,
+            } = &result.result
+            {
+                let text_diff =
+                    TextDiff::from_lines(unformatted.source_code(), formatted.source_code());
+                let mut unified_diff = text_diff.unified_diff();
+                unified_diff.header(
+                    &fs::relativize_path(&result.path),
+                    &fs::relativize_path(&result.path),
+                );
+                unified_diff.to_writer(&mut *f)?;
+            }
        }

        Ok(())
    }

-    /// Write a list of the files that would be changed to the given writer.
-    fn write_changed(&self, f: &mut impl Write) -> io::Result<()> {
-        for path in self
-            .results
-            .iter()
-            .filter_map(|result| {
-                if result.result.is_formatted() {
-                    Some(result.path.as_path())
-                } else {
-                    None
-                }
-            })
-            .sorted_unstable()
-        {
-            writeln!(f, "Would reformat: {}", fs::relativize_path(path).bold())?;
-        }
-
-        Ok(())
-    }
-
-    /// Write a summary of the formatting results to the given writer.
    fn write_summary(&self, f: &mut impl Write) -> io::Result<()> {
        // Compute the number of changed and unchanged files.
        let mut changed = 0u32;
@@ -500,6 +498,14 @@ impl<'a> FormatResults<'a> {
        for result in self.results {
            match &result.result {
                FormatResult::Formatted => {
+                    // If we're running in check mode, report on any files that would be formatted.
+                    if self.mode.is_check() {
+                        writeln!(
+                            f,
+                            "Would reformat: {}",
+                            fs::relativize_path(&result.path).bold()
+                        )?;
+                    }
                    changed += 1;
                }
                FormatResult::Unchanged => unchanged += 1,
@@ -556,26 +562,6 @@ pub(crate) enum FormatCommandError {
    Read(Option<PathBuf>, SourceError),
    Format(Option<PathBuf>, FormatModuleError),
    Write(Option<PathBuf>, SourceError),
-    Diff(Option<PathBuf>, io::Error),
-}
-
-impl FormatCommandError {
-    fn path(&self) -> Option<&Path> {
-        match self {
-            Self::Ignore(err) => {
-                if let ignore::Error::WithPath { path, .. } = err {
-                    Some(path.as_path())
-                } else {
-                    None
-                }
-            }
-            Self::Panic(path, _)
-            | Self::Read(path, _)
-            | Self::Format(path, _)
-            | Self::Write(path, _)
-            | Self::Diff(path, _) => path.as_deref(),
-        }
-    }
 }

 impl Display for FormatCommandError {
@@ -641,24 +627,6 @@ impl Display for FormatCommandError {
                    write!(f, "{}{} {err}", "Failed to format".bold(), ":".bold())
                }
            }
-            Self::Diff(path, err) => {
-                if let Some(path) = path {
-                    write!(
-                        f,
-                        "{}{}{} {err}",
-                        "Failed to generate diff for ".bold(),
-                        fs::relativize_path(path).bold(),
-                        ":".bold()
-                    )
-                } else {
-                    write!(
-                        f,
-                        "{}{} {err}",
-                        "Failed to generate diff".bold(),
-                        ":".bold()
-                    )
-                }
-            }
            Self::Panic(path, err) => {
                let message = r#"This indicates a bug in Ruff. If you could open an issue at:

@@ -690,123 +658,64 @@ pub(super) fn warn_incompatible_formatter_settings(
    pyproject_config: &PyprojectConfig,
    resolver: Option<&Resolver>,
 ) {
-    // First, collect all rules that are incompatible regardless of the linter-specific settings.
-    let mut incompatible_rules = FxHashSet::default();
    for setting in std::iter::once(&pyproject_config.settings)
        .chain(resolver.iter().flat_map(|resolver| resolver.settings()))
    {
-        for rule in [
-            // The formatter might collapse implicit string concatenation on a single line.
-            Rule::SingleLineImplicitStringConcatenation,
-            // Flags missing trailing commas when all arguments are on its own line:
-            // ```python
-            // def args(
-            //     aaaaaaaa, bbbbbbbbb, cccccccccc, ddddddddd, eeeeeeee, ffffff, gggggggggggg, hhhh
-            // ):
-            //     pass
-            // ```
-            Rule::MissingTrailingComma,
-        ] {
-            if setting.linter.rules.enabled(rule) {
-                incompatible_rules.insert(rule);
-            }
-        }
-    }
+        let mut incompatible_rules = Vec::new();

-    if !incompatible_rules.is_empty() {
-        let mut rule_names: Vec<_> = incompatible_rules
-            .into_iter()
-            .map(|rule| format!("`{}`", rule.noqa_code()))
-            .collect();
-        rule_names.sort();
-        warn_user_once!("The following rules may cause conflicts when used with the formatter: {}. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding them to the `ignore` configuration.", rule_names.join(", "));
-    }
-
-    // Next, validate settings-specific incompatibilities.
-    for setting in std::iter::once(&pyproject_config.settings)
-        .chain(resolver.iter().flat_map(|resolver| resolver.settings()))
-    {
-        // Validate all rules that rely on tab styles.
-        if setting.linter.rules.enabled(Rule::TabIndentation)
-            && setting.formatter.indent_style.is_tab()
-        {
-            warn_user_once!("The `format.indent-style=\"tab\"` option is incompatible with `W191`, which lints against all uses of tabs. We recommend disabling these rules when using the formatter, which enforces a consistent indentation style. Alternatively, set the `format.indent-style` option to `\"space\"`.");
-        }
-
-        // Validate all rules that rely on tab styles.
-        if setting.linter.rules.enabled(Rule::IndentWithSpaces)
-            && setting.formatter.indent_style.is_tab()
-        {
-            warn_user_once!("The `format.indent-style=\"tab\"` option is incompatible with `D206`, with requires space-based indentation. We recommend disabling these rules when using the formatter, which enforces a consistent indentation style. Alternatively, set the `format.indent-style` option to `\"space\"`.");
-        }
-
-        // Validate all rules that rely on custom indent widths.
-        if setting.linter.rules.any_enabled(&[
+        for incompatible_rule in RuleTable::from_iter([
+            Rule::LineTooLong,
+            Rule::TabIndentation,
            Rule::IndentationWithInvalidMultiple,
            Rule::IndentationWithInvalidMultipleComment,
-        ]) && setting.formatter.indent_width.value() != 4
+            Rule::OverIndented,
+            Rule::IndentWithSpaces,
+            Rule::SingleLineImplicitStringConcatenation,
+            Rule::MissingTrailingComma,
+            Rule::ProhibitedTrailingComma,
+            Rule::BadQuotesInlineString,
+            Rule::BadQuotesMultilineString,
+            Rule::BadQuotesDocstring,
+            Rule::AvoidableEscapedQuote,
+        ])
+        .iter_enabled()
        {
-            warn_user_once!("The `format.indent-width` option with a value other than 4 is incompatible with `E111` and `E114`. We recommend disabling these rules when using the formatter, which enforces a consistent indentation width. Alternatively, set the `format.indent-width` option to `4`.");
-        }
-
-        // Validate all rules that rely on quote styles.
-        if setting
-            .linter
-            .rules
-            .any_enabled(&[Rule::BadQuotesInlineString, Rule::AvoidableEscapedQuote])
-        {
-            match (
-                setting.linter.flake8_quotes.inline_quotes,
-                setting.formatter.quote_style,
-            ) {
-                (Quote::Double, QuoteStyle::Single) => {
-                    warn_user_once!("The `flake8-quotes.inline-quotes=\"double\"` option is incompatible with the formatter's `format.quote-style=\"single\"`. We recommend disabling `Q000` and `Q003` when using the formatter, which enforces a consistent quote style. Alternatively, set both options to either `\"single\"` or `\"double\"`.");
-                }
-                (Quote::Single, QuoteStyle::Double) => {
-                    warn_user_once!("The `flake8-quotes.inline-quotes=\"single\"` option is incompatible with the formatter's `format.quote-style=\"double\"`. We recommend disabling `Q000` and `Q003` when using the formatter, which enforces a consistent quote style. Alternatively, set both options to either `\"single\"` or `\"double\"`.");
-                }
-                _ => {}
+            if setting.linter.rules.enabled(incompatible_rule) {
+                incompatible_rules.push(format!("'{}'", incompatible_rule.noqa_code()));
            }
        }

-        if setting.linter.rules.enabled(Rule::BadQuotesMultilineString)
-            && setting.linter.flake8_quotes.multiline_quotes == Quote::Single
-        {
-            warn_user_once!("The `flake8-quotes.multiline-quotes=\"single\"` option is incompatible with the formatter. We recommend disabling `Q001` when using the formatter, which enforces double quotes for multiline strings. Alternatively, set the `flake8-quotes.multiline-quotes` option to `\"double\"`.`");
+        if !incompatible_rules.is_empty() {
+            incompatible_rules.sort();
+            warn!("The following rules may cause conflicts when used with the formatter: {}. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding then to the `ignore` configuration.", incompatible_rules.join(", "));
        }

-        if setting.linter.rules.enabled(Rule::BadQuotesDocstring)
-            && setting.linter.flake8_quotes.docstring_quotes == Quote::Single
-        {
-            warn_user_once!("The `flake8-quotes.multiline-quotes=\"single\"` option is incompatible with the formatter. We recommend disabling `Q002` when using the formatter, which enforces double quotes for docstrings. Alternatively, set the `flake8-quotes.docstring-quotes` option to `\"double\"`.`");
+        let mut incompatible_options = Vec::new();
+
+        let isort_defaults = isort::settings::Settings::default();
+
+        if setting.linter.isort.force_single_line != isort_defaults.force_single_line {
+            incompatible_options.push("'isort.force-single-line'");
        }

-        // Validate all isort settings.
-        if setting.linter.rules.enabled(Rule::UnsortedImports) {
-            // The formatter removes empty lines if the value is larger than 2 but always inserts a empty line after imports.
-            // Two empty lines are okay because `isort` only uses this setting for top-level imports (not in nested blocks).
-            if !matches!(setting.linter.isort.lines_after_imports, 1 | 2 | -1) {
-                warn_user_once!("The isort option `isort.lines-after-imports` with a value other than `-1`, `1` or `2` is incompatible with the formatter. To avoid unexpected behavior, we recommend setting the option to one of: `2`, `1`, or `-1` (default).");
-            }
+        if setting.linter.isort.force_wrap_aliases != isort_defaults.force_wrap_aliases {
+            incompatible_options.push("'isort.force-wrap-aliases'");
+        }

-            // Values larger than two get reduced to one line by the formatter if the import is in a nested block.
-            if setting.linter.isort.lines_between_types > 1 {
-                warn_user_once!("The isort option `isort.lines-between-types` with a value greater than 1 is incompatible with the formatter. To avoid unexpected behavior, we recommend setting the option to one of: `1` or `0` (default).");
-            }
+        if setting.linter.isort.lines_after_imports != isort_defaults.lines_after_imports {
+            incompatible_options.push("'isort.lines-after-imports'");
+        }

-            // isort inserts a trailing comma which the formatter preserves, but only if `skip-magic-trailing-comma` isn't false.
-            // This isn't relevant when using `force-single-line`, since isort will never include a trailing comma in that case.
-            if setting.formatter.magic_trailing_comma.is_ignore()
-                && !setting.linter.isort.force_single_line
-            {
-                if setting.linter.isort.force_wrap_aliases {
-                    warn_user_once!("The isort option `isort.force-wrap-aliases` is incompatible with the formatter `format.skip-magic-trailing-comma=true` option. To avoid unexpected behavior, we recommend either setting `isort.force-wrap-aliases=false` or `format.skip-magic-trailing-comma=false`.");
-                }
+        if setting.linter.isort.lines_between_types != isort_defaults.lines_between_types {
+            incompatible_options.push("'isort.lines_between_types'");
+        }

-                if setting.linter.isort.split_on_trailing_comma {
-                    warn_user_once!("The isort option `isort.split-on-trailing-comma` is incompatible with the formatter `format.skip-magic-trailing-comma=true` option. To avoid unexpected behavior, we recommend either setting `isort.split-on-trailing-comma=false` or `format.skip-magic-trailing-comma=false`.");
-                }
-            }
+        if setting.linter.isort.split_on_trailing_comma != isort_defaults.split_on_trailing_comma {
+            incompatible_options.push("'isort.split_on_trailing_comma'");
+        }
+
+        if !incompatible_options.is_empty() {
+            warn!("The following isort options may cause conflicts when used with the formatter: {}. To avoid unexpected behavior, we recommend disabling these options by removing them from the configuration.", incompatible_options.join(", "));
        }
    }
 }
--- a/crates/ruff_cli/src/commands/format_stdin.rs
+++ b/crates/ruff_cli/src/commands/format_stdin.rs
@@ -3,6 +3,8 @@ use std::path::Path;

 use anyhow::Result;
 use log::error;
+use ruff_linter::fs;
+use similar::TextDiff;

 use ruff_linter::source_kind::SourceKind;
 use ruff_python_ast::{PySourceType, SourceType};
@@ -31,19 +33,17 @@ pub(crate) fn format_stdin(cli: &FormatArguments, overrides: &CliOverrides) -> R

    let mode = FormatMode::from_cli(cli);

-    if pyproject_config.settings.file_resolver.force_exclude {
-        if let Some(filename) = cli.stdin_filename.as_deref() {
-            if !python_file_at_path(filename, &pyproject_config, overrides)? {
-                return Ok(ExitStatus::Success);
-            }
+    if let Some(filename) = cli.stdin_filename.as_deref() {
+        if !python_file_at_path(filename, &pyproject_config, overrides)? {
+            return Ok(ExitStatus::Success);
+        }

-            let format_settings = &pyproject_config.settings.formatter;
-            if filename
-                .file_name()
-                .is_some_and(|name| match_exclusion(filename, name, &format_settings.exclude))
-            {
-                return Ok(ExitStatus::Success);
-            }
+        let format_settings = &pyproject_config.settings.formatter;
+        if filename
+            .file_name()
+            .is_some_and(|name| match_exclusion(filename, name, &format_settings.exclude))
+        {
+            return Ok(ExitStatus::Success);
        }
    }

@@ -109,9 +109,14 @@ 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))?;
+                let mut writer = stdout().lock();
+                let text_diff =
+                    TextDiff::from_lines(source_kind.source_code(), formatted.source_code());
+                let mut unified_diff = text_diff.unified_diff();
+                if let Some(path) = path {
+                    unified_diff.header(&fs::relativize_path(path), &fs::relativize_path(path));
+                }
+                unified_diff.to_writer(&mut writer).unwrap();
            }
        },
        FormattedSource::Unchanged => {
--- a/crates/ruff_cli/src/diagnostics.rs
+++ b/crates/ruff_cli/src/diagnostics.rs
@@ -188,8 +188,13 @@ pub(crate) fn lint_path(
    unsafe_fixes: UnsafeFixes,
 ) -> Result<Diagnostics> {
    // Check the cache.
+    // TODO(charlie): `fixer::Mode::Apply` and `fixer::Mode::Diff` both have
+    // side-effects that aren't captured in the cache. (In practice, it's fine
+    // to cache `fixer::Mode::Apply`, since a file either has no fixes, or we'll
+    // write the fixes to disk, thus invalidating the cache. But it's a bit hard
+    // to reason about. We need to come up with a better solution here.)
    let caching = match cache {
-        Some(cache) if noqa.into() => {
+        Some(cache) if noqa.into() && fix_mode.is_generate() => {
            let relative_path = cache
                .relative_path(path)
                .expect("wrong package cache for file");
@@ -199,17 +204,7 @@ pub(crate) fn lint_path(
                .get(relative_path, &cache_key)
                .and_then(|entry| entry.to_diagnostics(path));
            if let Some(diagnostics) = cached_diagnostics {
-                // `FixMode::Generate` and `FixMode::Diff` rely on side-effects (writing to disk,
-                // and writing the diff to stdout, respectively). If a file has diagnostics, we
-                // need to avoid reading from and writing to the cache in these modes.
-                if match fix_mode {
-                    flags::FixMode::Generate => true,
-                    flags::FixMode::Apply | flags::FixMode::Diff => {
-                        diagnostics.messages.is_empty() && diagnostics.fixed.is_empty()
-                    }
-                } {
-                    return Ok(diagnostics);
-                }
+                return Ok(diagnostics);
            }

            // Stash the file metadata for later so when we update the cache it reflects the prerun
@@ -309,25 +304,15 @@ pub(crate) fn lint_path(
    if let Some((cache, relative_path, key)) = caching {
        // We don't cache parsing errors.
        if parse_error.is_none() {
-            // `FixMode::Generate` and `FixMode::Diff` rely on side-effects (writing to disk,
-            // and writing the diff to stdout, respectively). If a file has diagnostics, we
-            // need to avoid reading from and writing to the cache in these modes.
-            if match fix_mode {
-                flags::FixMode::Generate => true,
-                flags::FixMode::Apply | flags::FixMode::Diff => {
-                    messages.is_empty() && fixed.is_empty()
-                }
-            } {
-                cache.update_lint(
-                    relative_path.to_owned(),
-                    &key,
-                    LintCacheData::from_messages(
-                        &messages,
-                        imports.clone(),
-                        source_kind.as_ipy_notebook().map(Notebook::index).cloned(),
-                    ),
-                );
-            }
+            cache.update_lint(
+                relative_path.to_owned(),
+                &key,
+                LintCacheData::from_messages(
+                    &messages,
+                    imports.clone(),
+                    source_kind.as_ipy_notebook().map(Notebook::index).cloned(),
+                ),
+            );
        }
    }

--- a/crates/ruff_cli/src/lib.rs
+++ b/crates/ruff_cli/src/lib.rs
@@ -18,7 +18,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;
@@ -101,15 +101,6 @@ fn is_stdin(files: &[PathBuf], stdin_filename: Option<&Path>) -> bool {
    file == Path::new("-")
 }

-/// 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,
@@ -150,18 +141,12 @@ pub fn run(
            commands::version::version(output_format)?;
            Ok(ExitStatus::Success)
        }
-        Command::Rule {
-            rule,
-            all,
-            format,
-            mut output_format,
-        } => {
-            output_format = resolve_help_output_format(output_format, format);
+        Command::Rule { rule, all, format } => {
            if all {
-                commands::rule::rules(output_format)?;
+                commands::rule::rules(format)?;
            }
            if let Some(rule) = rule {
-                commands::rule::rule(rule, output_format)?;
+                commands::rule::rule(rule, format)?;
            }
            Ok(ExitStatus::Success)
        }
@@ -169,12 +154,8 @@ 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);
-            commands::linter::linter(output_format)?;
+        Command::Linter { format } => {
+            commands::linter::linter(format)?;
            Ok(ExitStatus::Success)
        }
        Command::Clean => {
@@ -191,6 +172,8 @@ pub fn run(
 }

 fn format(args: FormatCommand, log_level: LogLevel) -> Result<ExitStatus> {
+    warn_user_once!("`ruff format` is not yet stable, and subject to change in future versions.");
+
    let (cli, overrides) = args.partition();

    if is_stdin(&cli.files, cli.stdin_filename.as_deref()) {
--- a/crates/ruff_cli/tests/format.rs
+++ b/crates/ruff_cli/tests/format.rs
@@ -40,6 +40,7 @@ if condition:
        print('Hy "Micha"')  # Should not change quotes

    ----- stderr -----
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
    "###);
 }

@@ -50,7 +51,7 @@ fn format_options() -> Result<()> {
    fs::write(
        &ruff_toml,
        r#"
-indent-width = 8
+tab-size = 8
 line-length = 84

 [format]
@@ -88,6 +89,7 @@ if condition:
    	print('Should change quotes')

    ----- stderr -----
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
    "###);
    Ok(())
 }
@@ -115,6 +117,7 @@ fn mixed_line_endings() -> Result<()> {
    ----- stdout -----

    ----- stderr -----
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
    2 files left unchanged
    "###);
    Ok(())
@@ -184,73 +187,7 @@ OTHER = "OTHER"
    2 files would be reformatted

    ----- stderr -----
-    "###);
-    Ok(())
-}
-
-#[test]
-fn force_exclude() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(
-        &ruff_toml,
-        r#"
-extend-exclude = ["out"]
-
-[format]
-exclude = ["test.py", "generated.py"]
-"#,
-    )?;
-
-    fs::write(
-        tempdir.path().join("main.py"),
-        r#"
-from test import say_hy
-
-if __name__ == "__main__":
-    say_hy("dear Ruff contributor")
-"#,
-    )?;
-
-    // Excluded file but passed to the CLI directly, should be formatted
-    let test_path = tempdir.path().join("test.py");
-    fs::write(
-        &test_path,
-        r#"
-def say_hy(name: str):
-        print(f"Hy {name}")"#,
-    )?;
-
-    fs::write(
-        tempdir.path().join("generated.py"),
-        r#"NUMBERS = [
-     0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
-    10, 11, 12, 13, 14, 15, 16, 17, 18, 19
-]
-OTHER = "OTHER"
-"#,
-    )?;
-
-    let out_dir = tempdir.path().join("out");
-    fs::create_dir(&out_dir)?;
-
-    fs::write(out_dir.join("a.py"), "a = a")?;
-
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .current_dir(tempdir.path())
-        .args(["format", "--no-cache", "--force-exclude", "--check", "--config"])
-        .arg(ruff_toml.file_name().unwrap())
-        // Explicitly pass test.py, should be respect the `format.exclude` when `--force-exclude` is present
-        .arg(test_path.file_name().unwrap())
-        // Format all other files in the directory, should respect the `exclude` and `format.exclude` options
-        .arg("."), @r###"
-    success: false
-    exit_code: 1
-    ----- stdout -----
-    Would reformat: main.py
-    1 file would be reformatted
-
-    ----- stderr -----
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
    "###);
    Ok(())
 }
@@ -276,43 +213,6 @@ exclude = ["generated.py"]
        .pass_stdin(r#"
 from test import say_hy

-if __name__ == '__main__':
-    say_hy("dear Ruff contributor")
-"#), @r###"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    from test import say_hy
-
-    if __name__ == "__main__":
-        say_hy("dear Ruff contributor")
-
-    ----- stderr -----
-    "###);
-    Ok(())
-}
-
-#[test]
-fn force_exclude_stdin() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(
-        &ruff_toml,
-        r#"
-extend-select = ["B", "Q"]
-ignore = ["Q000", "Q001", "Q002", "Q003"]
-
-[format]
-exclude = ["generated.py"]
-"#,
-    )?;
-
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .current_dir(tempdir.path())
-        .args(["format", "--config", &ruff_toml.file_name().unwrap().to_string_lossy(), "--stdin-filename", "generated.py", "--force-exclude", "-"])
-        .pass_stdin(r#"
-from test import say_hy
-
 if __name__ == '__main__':
    say_hy("dear Ruff contributor")
 "#), @r###"
@@ -321,6 +221,7 @@ if __name__ == '__main__':
    ----- stdout -----

    ----- stderr -----
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
    "###);
    Ok(())
 }
@@ -334,9 +235,7 @@ fn format_option_inheritance() -> Result<()> {
        &ruff_toml,
        r#"
 extend = "base.toml"
-
-[lint]
-extend-select = ["COM812"]
+extend-select = ["Q000"]

 [format]
 quote-style = "single"
@@ -379,46 +278,12 @@ if condition:
    	print('Should change quotes')

    ----- stderr -----
-    warning: The following rules may cause conflicts when used with the formatter: `COM812`. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding them to the `ignore` configuration.
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
+    warning: The following rules may cause conflicts when used with the formatter: 'Q000'. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding then to the `ignore` configuration.
    "###);
    Ok(())
 }

-#[test]
-fn deprecated_options() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(
-        &ruff_toml,
-        r#"
-tab-size = 2
-"#,
-    )?;
-
-    insta::with_settings!({filters => vec![
-        (&*regex::escape(ruff_toml.to_str().unwrap()), "[RUFF-TOML-PATH]"),
-    ]}, {
-        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-            .args(["format", "--config"])
-            .arg(&ruff_toml)
-            .arg("-")
-            .pass_stdin(r#"
-if True:
-    pass
-    "#), @r###"
-        success: true
-        exit_code: 0
-        ----- stdout -----
-        if True:
-          pass
-
-        ----- stderr -----
-        warning: The `tab-size` option has been renamed to `indent-width` to emphasize that it configures the indentation used by the formatter as well as the tab width. Please update your configuration to use `indent-width = <value>` instead.
-        "###);
-    });
-    Ok(())
-}
-
 /// Since 0.1.0 the legacy format option is no longer supported
 #[test]
 fn legacy_format_option() -> Result<()> {
@@ -465,27 +330,15 @@ fn conflicting_options() -> Result<()> {
    fs::write(
        &ruff_toml,
        r#"
-indent-width = 2
-
-[lint]
 select = ["ALL"]
 ignore = ["D203", "D212"]

-[lint.isort]
-lines-after-imports = 3
-lines-between-types = 2
+[isort]
+force-single-line = true
 force-wrap-aliases = true
-combine-as-imports = true
+lines-after-imports = 0
+lines-between-types = 2
 split-on-trailing-comma = true
-
-[lint.flake8-quotes]
-inline-quotes = "single"
-docstring-quotes = "single"
-multiline-quotes = "single"
-
-[format]
-skip-magic-trailing-comma = true
-indent-style = "tab"
 "#,
    )?;

@@ -507,16 +360,9 @@ def say_hy(name: str):
    1 file reformatted

    ----- stderr -----
-    warning: The following rules may cause conflicts when used with the formatter: `COM812`, `ISC001`. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding them to the `ignore` configuration.
-    warning: The `format.indent-style="tab"` option is incompatible with `W191`, which lints against all uses of tabs. We recommend disabling these rules when using the formatter, which enforces a consistent indentation style. Alternatively, set the `format.indent-style` option to `"space"`.
-    warning: The `format.indent-style="tab"` option is incompatible with `D206`, with requires space-based indentation. We recommend disabling these rules when using the formatter, which enforces a consistent indentation style. Alternatively, set the `format.indent-style` option to `"space"`.
-    warning: The `flake8-quotes.inline-quotes="single"` option is incompatible with the formatter's `format.quote-style="double"`. We recommend disabling `Q000` and `Q003` when using the formatter, which enforces a consistent quote style. Alternatively, set both options to either `"single"` or `"double"`.
-    warning: The `flake8-quotes.multiline-quotes="single"` option is incompatible with the formatter. We recommend disabling `Q001` when using the formatter, which enforces double quotes for multiline strings. Alternatively, set the `flake8-quotes.multiline-quotes` option to `"double"`.`
-    warning: The `flake8-quotes.multiline-quotes="single"` option is incompatible with the formatter. We recommend disabling `Q002` when using the formatter, which enforces double quotes for docstrings. Alternatively, set the `flake8-quotes.docstring-quotes` option to `"double"`.`
-    warning: The isort option `isort.lines-after-imports` with a value other than `-1`, `1` or `2` is incompatible with the formatter. To avoid unexpected behavior, we recommend setting the option to one of: `2`, `1`, or `-1` (default).
-    warning: The isort option `isort.lines-between-types` with a value greater than 1 is incompatible with the formatter. To avoid unexpected behavior, we recommend setting the option to one of: `1` or `0` (default).
-    warning: The isort option `isort.force-wrap-aliases` is incompatible with the formatter `format.skip-magic-trailing-comma=true` option. To avoid unexpected behavior, we recommend either setting `isort.force-wrap-aliases=false` or `format.skip-magic-trailing-comma=false`.
-    warning: The isort option `isort.split-on-trailing-comma` is incompatible with the formatter `format.skip-magic-trailing-comma=true` option. To avoid unexpected behavior, we recommend either setting `isort.split-on-trailing-comma=false` or `format.skip-magic-trailing-comma=false`.
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
+    warning: The following rules may cause conflicts when used with the formatter: 'COM812', 'COM819', 'D206', 'E501', 'ISC001', 'Q000', 'Q001', 'Q002', 'Q003', 'W191'. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding then to the `ignore` configuration.
+    warning: The following isort options may cause conflicts when used with the formatter: 'isort.force-single-line', 'isort.force-wrap-aliases', 'isort.lines-after-imports', 'isort.lines_between_types'. To avoid unexpected behavior, we recommend disabling these options by removing them from the configuration.
    "###);
    Ok(())
 }
@@ -528,27 +374,15 @@ fn conflicting_options_stdin() -> Result<()> {
    fs::write(
        &ruff_toml,
        r#"
-indent-width = 2
-
-[lint]
 select = ["ALL"]
 ignore = ["D203", "D212"]

-[lint.isort]
-lines-after-imports = 3
-lines-between-types = 2
+[isort]
+force-single-line = true
 force-wrap-aliases = true
-combine-as-imports = true
+lines-after-imports = 0
+lines-between-types = 2
 split-on-trailing-comma = true
-
-[lint.flake8-quotes]
-inline-quotes = "single"
-docstring-quotes = "single"
-multiline-quotes = "single"
-
-[format]
-skip-magic-trailing-comma = true
-indent-style = "tab"
 "#,
    )?;

@@ -563,112 +397,15 @@ def say_hy(name: str):
    exit_code: 0
    ----- stdout -----
    def say_hy(name: str):
-    	print(f"Hy {name}")
+        print(f"Hy {name}")

    ----- stderr -----
-    warning: The following rules may cause conflicts when used with the formatter: `COM812`, `ISC001`. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding them to the `ignore` configuration.
-    warning: The `format.indent-style="tab"` option is incompatible with `W191`, which lints against all uses of tabs. We recommend disabling these rules when using the formatter, which enforces a consistent indentation style. Alternatively, set the `format.indent-style` option to `"space"`.
-    warning: The `format.indent-style="tab"` option is incompatible with `D206`, with requires space-based indentation. We recommend disabling these rules when using the formatter, which enforces a consistent indentation style. Alternatively, set the `format.indent-style` option to `"space"`.
-    warning: The `flake8-quotes.inline-quotes="single"` option is incompatible with the formatter's `format.quote-style="double"`. We recommend disabling `Q000` and `Q003` when using the formatter, which enforces a consistent quote style. Alternatively, set both options to either `"single"` or `"double"`.
-    warning: The `flake8-quotes.multiline-quotes="single"` option is incompatible with the formatter. We recommend disabling `Q001` when using the formatter, which enforces double quotes for multiline strings. Alternatively, set the `flake8-quotes.multiline-quotes` option to `"double"`.`
-    warning: The `flake8-quotes.multiline-quotes="single"` option is incompatible with the formatter. We recommend disabling `Q002` when using the formatter, which enforces double quotes for docstrings. Alternatively, set the `flake8-quotes.docstring-quotes` option to `"double"`.`
-    warning: The isort option `isort.lines-after-imports` with a value other than `-1`, `1` or `2` is incompatible with the formatter. To avoid unexpected behavior, we recommend setting the option to one of: `2`, `1`, or `-1` (default).
-    warning: The isort option `isort.lines-between-types` with a value greater than 1 is incompatible with the formatter. To avoid unexpected behavior, we recommend setting the option to one of: `1` or `0` (default).
-    warning: The isort option `isort.force-wrap-aliases` is incompatible with the formatter `format.skip-magic-trailing-comma=true` option. To avoid unexpected behavior, we recommend either setting `isort.force-wrap-aliases=false` or `format.skip-magic-trailing-comma=false`.
-    warning: The isort option `isort.split-on-trailing-comma` is incompatible with the formatter `format.skip-magic-trailing-comma=true` option. To avoid unexpected behavior, we recommend either setting `isort.split-on-trailing-comma=false` or `format.skip-magic-trailing-comma=false`.
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
+    warning: The following rules may cause conflicts when used with the formatter: 'COM812', 'COM819', 'D206', 'E501', 'ISC001', 'Q000', 'Q001', 'Q002', 'Q003', 'W191'. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding then to the `ignore` configuration.
+    warning: The following isort options may cause conflicts when used with the formatter: 'isort.force-single-line', 'isort.force-wrap-aliases', 'isort.lines-after-imports', 'isort.lines_between_types'. To avoid unexpected behavior, we recommend disabling these options by removing them from the configuration.
    "###);
    Ok(())
 }
-
-#[test]
-fn valid_linter_options() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(
-        &ruff_toml,
-        r#"
-[lint]
-select = ["ALL"]
-ignore = ["D203", "D212", "COM812", "ISC001"]
-
-[lint.isort]
-lines-after-imports = 2
-lines-between-types = 1
-force-wrap-aliases = true
-combine-as-imports = true
-split-on-trailing-comma = true
-
-[lint.flake8-quotes]
-inline-quotes = "single"
-docstring-quotes = "double"
-multiline-quotes = "double"
-
-[format]
-skip-magic-trailing-comma = false
-quote-style = "single"
-"#,
-    )?;
-
-    let test_path = tempdir.path().join("test.py");
-    fs::write(
-        &test_path,
-        r#"
-def say_hy(name: str):
-        print(f"Hy {name}")"#,
-    )?;
-
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(["format", "--no-cache", "--config"])
-        .arg(&ruff_toml)
-        .arg(test_path), @r###"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    1 file reformatted
-
-    ----- stderr -----
-    "###);
-    Ok(())
-}
-
-#[test]
-fn all_rules_default_options() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-
-    fs::write(
-        &ruff_toml,
-        r#"
-[lint]
-select = ["ALL"]
-"#,
-    )?;
-
-    let test_path = tempdir.path().join("test.py");
-    fs::write(
-        &test_path,
-        r#"
-def say_hy(name: str):
-        print(f"Hy {name}")"#,
-    )?;
-
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(["format", "--no-cache", "--config"])
-        .arg(&ruff_toml)
-        .arg(test_path), @r###"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    1 file reformatted
-
-    ----- stderr -----
-    warning: `one-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are incompatible. Ignoring `one-blank-line-before-class`.
-    warning: `multi-line-summary-first-line` (D212) and `multi-line-summary-second-line` (D213) are incompatible. Ignoring `multi-line-summary-second-line`.
-    warning: The following rules may cause conflicts when used with the formatter: `COM812`, `ISC001`. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding them to the `ignore` configuration.
-    "###);
-    Ok(())
-}
-
 #[test]
 fn test_diff() {
    let args = ["format", "--no-cache", "--isolated", "--diff"];
@@ -688,8 +425,8 @@ fn test_diff() {
        success: false
        exit_code: 1
        ----- stdout -----
-        --- resources/test/fixtures/unformatted.ipynb:cell 1
-        +++ resources/test/fixtures/unformatted.ipynb:cell 1
+        --- resources/test/fixtures/unformatted.ipynb
+        +++ resources/test/fixtures/unformatted.ipynb
        @@ -1,3 +1,4 @@
         import numpy
        -maths = (numpy.arange(100)**2).sum()
@@ -697,30 +434,6 @@ fn test_diff() {
        +
        +maths = (numpy.arange(100) ** 2).sum()
        +stats = numpy.asarray([1, 2, 3, 4]).median()
-        --- resources/test/fixtures/unformatted.ipynb:cell 3
-        +++ resources/test/fixtures/unformatted.ipynb:cell 3
-        @@ -1,4 +1,6 @@
-         # A cell with IPython escape command
-         def some_function(foo, bar):
-             pass
-        +
-        +
-         %matplotlib inline
-        --- resources/test/fixtures/unformatted.ipynb:cell 4
-        +++ resources/test/fixtures/unformatted.ipynb:cell 4
-        @@ -1,5 +1,10 @@
-         foo = %pwd
-        -def some_function(foo,bar,):
-        +
-        +
-        +def some_function(
-        +    foo,
-        +    bar,
-        +):
-             # Another cell with IPython escape command
-             foo = %pwd
-             print(foo)
-
        --- resources/test/fixtures/unformatted.py
        +++ resources/test/fixtures/unformatted.py
        @@ -1,3 +1,3 @@
@@ -729,8 +442,8 @@ fn test_diff() {
        +y = 2
         z = 3

-
        ----- stderr -----
+        warning: `ruff format` is not yet stable, and subject to change in future versions.
        2 files would be reformatted, 1 file left unchanged
        "###);
    });
@@ -759,8 +472,8 @@ fn test_diff_no_change() {
        +y = 2
         z = 3

-
        ----- stderr -----
+        warning: `ruff format` is not yet stable, and subject to change in future versions.
        1 file would be reformatted
        "###
        );
@@ -793,8 +506,8 @@ fn test_diff_stdin_unformatted() {
    +y = 2
     z = 3

-
    ----- stderr -----
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
    "###);
 }

@@ -811,5 +524,6 @@ fn test_diff_stdin_formatted() {
    ----- stdout -----

    ----- stderr -----
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
    "###);
 }
--- a/crates/ruff_cli/tests/integration_test.rs
+++ b/crates/ruff_cli/tests/integration_test.rs
@@ -485,6 +485,7 @@ fn stdin_format_jupyter() {
    }

    ----- stderr -----
+    warning: `ruff format` is not yet stable, and subject to change in future versions.
    "###);
 }

--- a/crates/ruff_cli/tests/lint.rs
+++ b/crates/ruff_cli/tests/lint.rs
@@ -262,135 +262,9 @@ from test import say_hy
 if __name__ == "__main__":
    say_hy("dear Ruff contributor")
 "#), @r###"
-    success: false
-    exit_code: 1
+    success: true
+    exit_code: 0
    ----- stdout -----
-    generated.py:4:16: Q000 [*] Double quotes found but single quotes preferred
-    generated.py:5:12: Q000 [*] Double quotes found but single quotes preferred
-    Found 2 errors.
-    [*] 2 fixable with the `--fix` option.
-
-    ----- stderr -----
-    "###);
-    Ok(())
-}
-
-#[test]
-fn line_too_long_width_override() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(
-        &ruff_toml,
-        r#"
-line-length = 80
-select = ["E501"]
-
-[pycodestyle]
-max-line-length = 100
-"#,
-    )?;
-
-    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
-        .args(STDIN_BASE_OPTIONS)
-        .arg("--config")
-        .arg(&ruff_toml)
-        .args(["--stdin-filename", "test.py"])
-        .arg("-")
-        .pass_stdin(r#"
-# longer than 80, but less than 100
-_ = "---------------------------------------------------------------------------亜亜亜亜亜亜"
-# longer than 100
-_ = "---------------------------------------------------------------------------亜亜亜亜亜亜亜亜亜亜亜亜亜亜"
-"#), @r###"
-    success: false
-    exit_code: 1
-    ----- stdout -----
-    test.py:5:91: E501 Line too long (109 > 100)
-    Found 1 error.
-
-    ----- stderr -----
-    "###);
-    Ok(())
-}
-
-#[test]
-fn per_file_ignores_stdin() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(
-        &ruff_toml,
-        r#"
-extend-select = ["B", "Q"]
-
-[lint.flake8-quotes]
-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"])
-        .args(["--per-file-ignores", "generated.py:Q"])
-        .arg("-")
-        .pass_stdin(r#"
-import os
-
-from test import say_hy
-
-if __name__ == "__main__":
-    say_hy("dear Ruff contributor")
-"#), @r###"
-    success: false
-    exit_code: 1
-    ----- stdout -----
-    generated.py:2:8: F401 [*] `os` imported but unused
-    Found 1 error.
-    [*] 1 fixable with the `--fix` option.
-
-    ----- stderr -----
-    "###);
-    Ok(())
-}
-
-#[test]
-fn extend_per_file_ignores_stdin() -> Result<()> {
-    let tempdir = TempDir::new()?;
-    let ruff_toml = tempdir.path().join("ruff.toml");
-    fs::write(
-        &ruff_toml,
-        r#"
-extend-select = ["B", "Q"]
-
-[lint.flake8-quotes]
-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"])
-        .args(["--extend-per-file-ignores", "generated.py:Q"])
-        .arg("-")
-        .pass_stdin(r#"
-import os
-
-from test import say_hy
-
-if __name__ == "__main__":
-    say_hy("dear Ruff contributor")
-"#), @r###"
-    success: false
-    exit_code: 1
-    ----- stdout -----
-    generated.py:2:8: F401 [*] `os` imported but unused
-    Found 1 error.
-    [*] 1 fixable with the `--fix` option.

    ----- stderr -----
    "###);
--- a/crates/ruff_dev/Cargo.toml
+++ b/crates/ruff_dev/Cargo.toml
@@ -41,7 +41,7 @@ serde_json = { workspace = true }
 similar = { workspace = true }
 strum = { workspace = true }
 strum_macros = { workspace = true }
-tempfile = "3.8.1"
+tempfile = "3.6.0"
 toml = { workspace = true, features = ["parse"] }
 tracing = { workspace = true }
 tracing-indicatif = { workspace = true }
--- a/crates/ruff_dev/src/format_dev.rs
+++ b/crates/ruff_dev/src/format_dev.rs
@@ -33,7 +33,7 @@ use ruff_formatter::{FormatError, LineWidth, PrintError};
 use ruff_linter::logging::LogLevel;
 use ruff_linter::settings::types::{FilePattern, FilePatternSet};
 use ruff_python_formatter::{
-    format_module_source, FormatModuleError, MagicTrailingComma, PreviewMode, PyFormatOptions,
+    format_module_source, FormatModuleError, MagicTrailingComma, PyFormatOptions,
 };
 use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, ResolvedFile, Resolver};

@@ -871,7 +871,9 @@ struct BlackOptions {
    line_length: NonZeroU16,
    #[serde(alias = "skip-magic-trailing-comma")]
    skip_magic_trailing_comma: bool,
-    preview: bool,
+    #[allow(unused)]
+    #[serde(alias = "force-exclude")]
+    force_exclude: Option<String>,
 }

 impl Default for BlackOptions {
@@ -879,7 +881,7 @@ impl Default for BlackOptions {
        Self {
            line_length: NonZeroU16::new(88).unwrap(),
            skip_magic_trailing_comma: false,
-            preview: false,
+            force_exclude: None,
        }
    }
 }
@@ -927,11 +929,6 @@ impl BlackOptions {
            } else {
                MagicTrailingComma::Respect
            })
-            .with_preview(if self.preview {
-                PreviewMode::Enabled
-            } else {
-                PreviewMode::Disabled
-            })
    }
 }

--- a/crates/ruff_dev/src/generate_options.rs
+++ b/crates/ruff_dev/src/generate_options.rs
@@ -128,11 +128,7 @@ fn emit_field(output: &mut String, name: &str, field: &OptionField, parent_set:
    output.push_str(&format!(
        "**Example usage**:\n\n```toml\n[tool.ruff{}]\n{}\n```\n",
        if let Some(set_name) = parent_set.name() {
-            if set_name == "format" {
-                String::from(".format")
-            } else {
-                format!(".lint.{set_name}")
-            }
+            format!(".{set_name}")
        } else {
            String::new()
        },
--- a/crates/ruff_dev/src/generate_rules_table.rs
+++ b/crates/ruff_dev/src/generate_rules_table.rs
@@ -22,16 +22,14 @@ fn generate_table(table_out: &mut String, rules: impl IntoIterator<Item = Rule>,
    for rule in rules {
        let fix_token = match rule.fixable() {
            FixAvailability::Always | FixAvailability::Sometimes => {
-                format!("<span title='Automatic fix available'>{FIX_SYMBOL}</span>")
-            }
-            FixAvailability::None => {
-                format!("<span style='opacity: 0.1' aria-hidden='true'>{FIX_SYMBOL}</span>")
+                format!("<span style='opacity: 1'>{FIX_SYMBOL}</span>")
            }
+            FixAvailability::None => format!("<span style='opacity: 0.1'>{FIX_SYMBOL}</span>"),
        };
        let preview_token = if rule.is_preview() || rule.is_nursery() {
-            format!("<span title='Rule is in preview'>{PREVIEW_SYMBOL}</span>")
+            format!("<span style='opacity: 1'>{PREVIEW_SYMBOL}</span>")
        } else {
-            format!("<span style='opacity: 0.1' aria-hidden='true'>{PREVIEW_SYMBOL}</span>")
+            format!("<span style='opacity: 0.1'>{PREVIEW_SYMBOL}</span>")
        };
        let status_token = format!("{fix_token} {preview_token}");

@@ -64,7 +62,7 @@ pub(crate) fn generate() -> String {
    table_out.push('\n');

    table_out.push_str(&format!(
-        "The {PREVIEW_SYMBOL} emoji indicates that a rule is in [\"preview\"](faq.md#what-is-preview)."
+        "The {PREVIEW_SYMBOL} emoji indicates that a rule in [\"preview\"](faq.md#what-is-preview)."
    ));
    table_out.push('\n');
    table_out.push('\n');
--- a/crates/ruff_linter/Cargo.toml
+++ b/crates/ruff_linter/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.1.3"
+version = "0.1.1"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -53,7 +53,7 @@ path-absolutize = { workspace = true, features = [
 ] }
 pathdiff = { version = "0.2.1" }
 pep440_rs = { version = "0.3.12", features = ["serde"] }
-pyproject-toml = { version = "0.8.0" }
+pyproject-toml = { version = "0.7.0" }
 quick-junit = { version = "0.3.2" }
 regex = { workspace = true }
 result-like = { version = "0.4.6" }
@@ -79,7 +79,7 @@ pretty_assertions = "1.3.0"
 test-case = { workspace = true }
 # Disable colored output in tests
 colored = { workspace = true, features = ["no-color"] }
-tempfile = "3.8.1"
+tempfile = "3.6.0"

 [features]
 default = []
--- a/crates/ruff_linter/resources/test/fixtures/flake8_raise/RSE102.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_raise/RSE102.py
@@ -79,6 +79,3 @@ from ZeroDivisionError
 raise IndexError() from ZeroDivisionError

 raise IndexError();
-
-# RSE102
-raise Foo()
--- a/crates/ruff_linter/resources/test/fixtures/isort/pyproject.toml
+++ b/crates/ruff_linter/resources/test/fixtures/isort/pyproject.toml
@@ -1,7 +1,7 @@
 [tool.ruff]
 line-length = 88

-[tool.ruff.lint.isort]
+[tool.ruff.isort]
 lines-after-imports = 3
 lines-between-types = 2
 known-local-folder = ["ruff"]
--- a/crates/ruff_linter/resources/test/fixtures/pycodestyle/E21.py
+++ b/crates/ruff_linter/resources/test/fixtures/pycodestyle/E21.py
@@ -12,19 +12,3 @@ dict['key'] = list[index]
 # This is not prohibited by PEP8, but avoid it.
 class Foo (Bar, Baz):
    pass
-
-
-def fetch_name () -> Union[str, None]:
-    """Fetch name from --person-name in sys.argv.
-
-   Returns:
-        name of the person if available, otherwise None
-    """
-    test = len(5)
-    Logger.info(test)
-    # test commented code
-    # Logger.info("test code")
-    for i in range (0, len (sys.argv)) :
-        if sys.argv[i] == "--name" :
-            return sys.argv[i + 1]
-    return None
--- a/crates/ruff_linter/resources/test/fixtures/pycodestyle/E23.py
+++ b/crates/ruff_linter/resources/test/fixtures/pycodestyle/E23.py
@@ -40,11 +40,5 @@ f"{(a:=1)}"
 f"{(lambda x:x)}"
 f"normal{f"{a:.3f}"}normal"

-#: Okay
-snapshot.file_uri[len(f's3://{self.s3_bucket_name}/'):]
-
-#: E231
-{len(f's3://{self.s3_bucket_name}/'):1}
-
 #: Okay
 a = (1,
--- a/crates/ruff_linter/resources/test/fixtures/pylint/bad_dunder_method_name.py
+++ b/crates/ruff_linter/resources/test/fixtures/pylint/bad_dunder_method_name.py
@@ -49,13 +49,6 @@ class Apples:
    def __doc__(self):
        return "Docstring"

-    # Added in Python 3.12
-    def __buffer__(self):  
-        return memoryview(b'')
-
-    def __release_buffer__(self, buf):
-        pass
-
    # Allow dunder methods recommended by attrs.
    def __attrs_post_init__(self):
        pass
@@ -70,10 +63,6 @@ class Apples:
    def __html__(self):
        pass

-    # Allow Python's __index__
-    def __index__(self):
-        pass
-
    # Allow _missing_, used by enum.Enum.
    @classmethod
    def _missing_(cls, value):
--- a/crates/ruff_linter/resources/test/fixtures/pylint/bad_open_mode.py
+++ b/crates/ruff_linter/resources/test/fixtures/pylint/bad_open_mode.py
@@ -1,34 +0,0 @@
-import pathlib
-
-NAME = "foo.bar"
-open(NAME, "wb")
-open(NAME, "w", encoding="utf-8")
-open(NAME, "rb")
-open(NAME, "x", encoding="utf-8")
-open(NAME, "br")
-open(NAME, "+r", encoding="utf-8")
-open(NAME, "xb")
-open(NAME, "rwx")  # [bad-open-mode]
-open(NAME, mode="rwx")  # [bad-open-mode]
-open(NAME, "rwx", encoding="utf-8")  # [bad-open-mode]
-open(NAME, "rr", encoding="utf-8")  # [bad-open-mode]
-open(NAME, "+", encoding="utf-8")  # [bad-open-mode]
-open(NAME, "xw", encoding="utf-8")  # [bad-open-mode]
-open(NAME, "ab+")
-open(NAME, "a+b")
-open(NAME, "+ab")
-open(NAME, "+rUb")
-open(NAME, "x+b")
-open(NAME, "Ua", encoding="utf-8")  # [bad-open-mode]
-open(NAME, "Ur++", encoding="utf-8")  # [bad-open-mode]
-open(NAME, "Ut", encoding="utf-8")
-open(NAME, "Ubr")
-
-mode = "rw"
-open(NAME, mode)
-
-pathlib.Path(NAME).open("wb")
-pathlib.Path(NAME).open(mode)
-pathlib.Path(NAME).open("rwx")  # [bad-open-mode]
-pathlib.Path(NAME).open(mode="rwx")  # [bad-open-mode]
-pathlib.Path(NAME).open("rwx", encoding="utf-8")  # [bad-open-mode]
--- a/crates/ruff_linter/resources/test/fixtures/pylint/import_outside_top_level.py
+++ b/crates/ruff_linter/resources/test/fixtures/pylint/import_outside_top_level.py
@@ -1,22 +0,0 @@
-from typing import TYPE_CHECKING
-
-# Verify that statements nested in conditionals (such as top-level type-checking blocks)
-# are still considered top-level
-if TYPE_CHECKING:
-    import string
-
-
-def import_in_function():
-    import symtable  # [import-outside-toplevel]
-    import os, sys  # [import-outside-toplevel]
-    import time as thyme  # [import-outside-toplevel]
-    import random as rand, socket as sock  # [import-outside-toplevel]
-    from collections import defaultdict # [import-outside-toplevel]
-    from math import sin as sign, cos as cosplay  # [import-outside-toplevel]
-
-
-class ClassWithImports:
-    import tokenize  # [import-outside-toplevel]
-
-    def __init__(self):
-        import trace  # [import-outside-toplevel]
--- a/crates/ruff_linter/resources/test/fixtures/pylint/useless_with_lock.py
+++ b/crates/ruff_linter/resources/test/fixtures/pylint/useless_with_lock.py
@@ -1,56 +0,0 @@
-import threading
-from threading import Lock, RLock, Condition, Semaphore, BoundedSemaphore
-
-
-with threading.Lock():  # [useless-with-lock]
-    ...
-
-with Lock():  # [useless-with-lock]
-    ...
-
-with threading.Lock() as this_shouldnt_matter:  # [useless-with-lock]
-    ...
-
-with threading.RLock():  # [useless-with-lock]
-    ...
-
-with RLock():  # [useless-with-lock]
-    ...
-
-with threading.Condition():  # [useless-with-lock]
-    ...
-
-with Condition():  # [useless-with-lock]
-    ...
-
-with threading.Semaphore():  # [useless-with-lock]
-    ...
-
-with Semaphore():  # [useless-with-lock]
-    ...
-
-with threading.BoundedSemaphore():  # [useless-with-lock]
-    ...
-
-with BoundedSemaphore():  # [useless-with-lock]
-    ...
-
-lock = threading.Lock()
-with lock:  # this is ok
-    ...
-
-rlock = threading.RLock()
-with rlock:  # this is ok
-    ...
-
-cond = threading.Condition()
-with cond:  # this is ok
-    ...
-
-sem = threading.Semaphore()
-with sem:  # this is ok
-    ...
-
-b_sem = threading.BoundedSemaphore()
-with b_sem:  # this is ok
-    ...
--- a/crates/ruff_linter/resources/test/fixtures/pyproject.toml
+++ b/crates/ruff_linter/resources/test/fixtures/pyproject.toml
@@ -5,6 +5,4 @@ extend-exclude = [
  "migrations",
  "with_excluded_file/other_excluded_file.py",
 ]
-
-[tool.ruff.lint]
 per-file-ignores = { "__init__.py" = ["F401"] }
--- a/crates/ruff_linter/resources/test/fixtures/refurb/FURB168.py
+++ b/crates/ruff_linter/resources/test/fixtures/refurb/FURB168.py
@@ -1,51 +0,0 @@
-foo: object
-
-# Errors.
-
-if isinstance(foo, type(None)):
-    pass
-
-if isinstance(foo, (type(None))):
-    pass
-
-if isinstance(foo, (type(None), type(None), type(None))):
-    pass
-
-if isinstance(foo, None | None):
-    pass
-
-if isinstance(foo, (None | None)):
-    pass
-
-if isinstance(foo, None | type(None)):
-    pass
-
-if isinstance(foo, (None | type(None))):
-    pass
-
-# A bit contrived, but is both technically valid and equivalent to the above.
-if isinstance(foo, (type(None) | ((((type(None))))) | ((None | type(None))))):
-    pass
-
-
-# Okay.
-
-if isinstance(foo, int):
-    pass
-
-if isinstance(foo, (int)):
-    pass
-
-if isinstance(foo, (int, str)):
-    pass
-
-if isinstance(foo, (int, type(None), str)):
-    pass
-
-# This is a TypeError, which the rule ignores.
-if isinstance(foo, None):
-    pass
-
-# This is also a TypeError, which the rule ignores.
-if isinstance(foo, (None,)):
-    pass
--- a/crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py
+++ b/crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py
@@ -21,9 +21,6 @@ def f() -> None:
    # Invalid (but external)
    d = 1  # noqa: F841, V101

-    # Invalid (but external)
-    d = 1  # noqa: V500
-
    # fmt: off
    # Invalid - no space before #
    d = 1# noqa: E501
--- a/crates/ruff_linter/resources/test/project/pyproject.toml
+++ b/crates/ruff_linter/resources/test/project/pyproject.toml
@@ -1,7 +1,5 @@
 [tool.ruff]
 src = [".", "python_modules/*"]
 exclude = ["examples/excluded"]
-
-[tool.ruff.lint]
 extend-select = ["I001"]
 extend-ignore = ["F841"]
--- a/crates/ruff_linter/src/checkers/ast/analyze/definitions.rs
+++ b/crates/ruff_linter/src/checkers/ast/analyze/definitions.rs
@@ -170,7 +170,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
                expr.start(),
            ));

-            if expr.implicit_concatenated {
+            if pydocstyle::helpers::should_ignore_docstring(expr) {
                #[allow(deprecated)]
                let location = checker.locator.compute_source_location(expr.start());
                warn_user!(
--- a/crates/ruff_linter/src/checkers/ast/analyze/expression.rs
+++ b/crates/ruff_linter/src/checkers/ast/analyze/expression.rs
@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Arguments, Expr, ExprContext, Operator};
+use ruff_python_ast::{self as ast, Arguments, Constant, Expr, ExprContext, Operator};
 use ruff_python_literal::cformat::{CFormatError, CFormatErrorType};

 use ruff_diagnostics::Diagnostic;
@@ -363,18 +363,20 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
            ]) {
                if let Expr::Attribute(ast::ExprAttribute { value, attr, .. }) = func.as_ref() {
                    let attr = attr.as_str();
-                    if let Expr::StringLiteral(ast::ExprStringLiteral { value: string, .. }) =
-                        value.as_ref()
+                    if let Expr::Constant(ast::ExprConstant {
+                        value: Constant::Str(val),
+                        ..
+                    }) = value.as_ref()
                    {
                        if attr == "join" {
                            // "...".join(...) call
                            if checker.enabled(Rule::StaticJoinToFString) {
-                                flynt::rules::static_join_to_fstring(checker, expr, string);
+                                flynt::rules::static_join_to_fstring(checker, expr, val);
                            }
                        } else if attr == "format" {
                            // "...".format(...) call
                            let location = expr.range();
-                            match pyflakes::format::FormatSummary::try_from(string.as_ref()) {
+                            match pyflakes::format::FormatSummary::try_from(val.as_ref()) {
                                Err(e) => {
                                    if checker.enabled(Rule::StringDotFormatInvalidFormat) {
                                        checker.diagnostics.push(Diagnostic::new(
@@ -419,7 +421,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {

                            if checker.enabled(Rule::BadStringFormatCharacter) {
                                pylint::rules::bad_string_format_character::call(
-                                    checker, string, location,
+                                    checker, val, location,
                                );
                            }
                        }
@@ -747,9 +749,6 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
            if checker.enabled(Rule::SysExitAlias) {
                pylint::rules::sys_exit_alias(checker, func);
            }
-            if checker.enabled(Rule::BadOpenMode) {
-                pylint::rules::bad_open_mode(checker, call);
-            }
            if checker.enabled(Rule::BadStrStripCall) {
                pylint::rules::bad_str_strip_call(checker, func, args);
            }
@@ -909,9 +908,6 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
            if checker.enabled(Rule::ExceptionWithoutExcInfo) {
                flake8_logging::rules::exception_without_exc_info(checker, call);
            }
-            if checker.enabled(Rule::IsinstanceTypeNone) {
-                refurb::rules::isinstance_type_none(checker, call);
-            }
            if checker.enabled(Rule::ImplicitCwd) {
                refurb::rules::no_implicit_cwd(checker, call);
            }
@@ -991,7 +987,11 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
            right,
            range: _,
        }) => {
-            if let Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) = left.as_ref() {
+            if let Expr::Constant(ast::ExprConstant {
+                value: Constant::Str(ast::StringConstant { value, .. }),
+                ..
+            }) = left.as_ref()
+            {
                if checker.any_enabled(&[
                    Rule::PercentFormatInvalidFormat,
                    Rule::PercentFormatExpectedMapping,
@@ -1228,29 +1228,38 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                refurb::rules::single_item_membership_test(checker, expr, left, ops, comparators);
            }
        }
-        Expr::NumberLiteral(_) => {
+        Expr::Constant(ast::ExprConstant {
+            value: Constant::Int(_) | Constant::Float(_) | Constant::Complex { .. },
+            range: _,
+        }) => {
            if checker.source_type.is_stub() && checker.enabled(Rule::NumericLiteralTooLong) {
                flake8_pyi::rules::numeric_literal_too_long(checker, expr);
            }
        }
-        Expr::BytesLiteral(_) => {
+        Expr::Constant(ast::ExprConstant {
+            value: Constant::Bytes(_),
+            range: _,
+        }) => {
            if checker.source_type.is_stub() && checker.enabled(Rule::StringOrBytesTooLong) {
                flake8_pyi::rules::string_or_bytes_too_long(checker, expr);
            }
        }
-        Expr::StringLiteral(string) => {
+        Expr::Constant(ast::ExprConstant {
+            value: Constant::Str(value),
+            range: _,
+        }) => {
            if checker.enabled(Rule::HardcodedBindAllInterfaces) {
                if let Some(diagnostic) =
-                    flake8_bandit::rules::hardcoded_bind_all_interfaces(string)
+                    flake8_bandit::rules::hardcoded_bind_all_interfaces(value, expr.range())
                {
                    checker.diagnostics.push(diagnostic);
                }
            }
            if checker.enabled(Rule::HardcodedTempFile) {
-                flake8_bandit::rules::hardcoded_tmp_directory(checker, string);
+                flake8_bandit::rules::hardcoded_tmp_directory(checker, expr, value);
            }
            if checker.enabled(Rule::UnicodeKindPrefix) {
-                pyupgrade::rules::unicode_kind_prefix(checker, string);
+                pyupgrade::rules::unicode_kind_prefix(checker, expr, value.unicode);
            }
            if checker.source_type.is_stub() {
                if checker.enabled(Rule::StringOrBytesTooLong) {
--- a/crates/ruff_linter/src/checkers/ast/analyze/statement.rs
+++ b/crates/ruff_linter/src/checkers/ast/analyze/statement.rs
@@ -530,9 +530,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
            if checker.enabled(Rule::ModuleImportNotAtTopOfFile) {
                pycodestyle::rules::module_import_not_at_top_of_file(checker, stmt);
            }
-            if checker.enabled(Rule::ImportOutsideTopLevel) {
-                pylint::rules::import_outside_top_level(checker, stmt);
-            }
            if checker.enabled(Rule::GlobalStatement) {
                for name in names {
                    if let Some(asname) = name.asname.as_ref() {
@@ -709,9 +706,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
            if checker.enabled(Rule::ModuleImportNotAtTopOfFile) {
                pycodestyle::rules::module_import_not_at_top_of_file(checker, stmt);
            }
-            if checker.enabled(Rule::ImportOutsideTopLevel) {
-                pylint::rules::import_outside_top_level(checker, stmt);
-            }
            if checker.enabled(Rule::GlobalStatement) {
                for name in names {
                    if let Some(asname) = name.asname.as_ref() {
@@ -1192,9 +1186,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
            if checker.enabled(Rule::ReadWholeFile) {
                refurb::rules::read_whole_file(checker, with_stmt);
            }
-            if checker.enabled(Rule::UselessWithLock) {
-                pylint::rules::useless_with_lock(checker, with_stmt);
-            }
        }
        Stmt::While(ast::StmtWhile { body, orelse, .. }) => {
            if checker.enabled(Rule::FunctionUsesLoopVariable) {
--- a/crates/ruff_linter/src/checkers/ast/mod.rs
+++ b/crates/ruff_linter/src/checkers/ast/mod.rs
@@ -31,8 +31,9 @@ use std::path::Path;
 use itertools::Itertools;
 use log::debug;
 use ruff_python_ast::{
-    self as ast, Arguments, Comprehension, ElifElseClause, ExceptHandler, Expr, ExprContext,
-    Keyword, MatchCase, Parameter, ParameterWithDefault, Parameters, Pattern, Stmt, Suite, UnaryOp,
+    self as ast, Arguments, Comprehension, Constant, ElifElseClause, ExceptHandler, Expr,
+    ExprContext, Keyword, MatchCase, Parameter, ParameterWithDefault, Parameters, Pattern, Stmt,
+    Suite, UnaryOp,
 };
 use ruff_text_size::{Ranged, TextRange, TextSize};

@@ -786,7 +787,11 @@ where
            && self.semantic.in_type_definition()
            && self.semantic.future_annotations()
        {
-            if let Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) = expr {
+            if let Expr::Constant(ast::ExprConstant {
+                value: Constant::Str(value),
+                ..
+            }) = expr
+            {
                self.deferred.string_type_definitions.push((
                    expr.range(),
                    value,
@@ -1181,7 +1186,10 @@ where
                    }
                }
            }
-            Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
+            Expr::Constant(ast::ExprConstant {
+                value: Constant::Str(value),
+                range: _,
+            }) => {
                if self.semantic.in_type_definition()
                    && !self.semantic.in_literal()
                    && !self.semantic.in_f_string()
--- a/crates/ruff_linter/src/checkers/noqa.rs
+++ b/crates/ruff_linter/src/checkers/noqa.rs
@@ -128,10 +128,7 @@ pub(crate) fn check_noqa(
                        }

                        if line.matches.iter().any(|match_| *match_ == code)
-                            || settings
-                                .external
-                                .iter()
-                                .any(|external| code.starts_with(external))
+                            || settings.external.contains(code)
                        {
                            valid_codes.push(code);
                        } else {
--- a/crates/ruff_linter/src/checkers/physical_lines.rs
+++ b/crates/ruff_linter/src/checkers/physical_lines.rs
@@ -95,7 +95,6 @@ mod tests {

    use crate::line_width::LineLength;
    use crate::registry::Rule;
-    use crate::rules::pycodestyle;
    use crate::settings::LinterSettings;

    use super::check_physical_lines;
@@ -115,10 +114,7 @@ mod tests {
                &indexer,
                &[],
                &LinterSettings {
-                    pycodestyle: pycodestyle::settings::Settings {
-                        max_line_length: line_length,
-                        ..pycodestyle::settings::Settings::default()
-                    },
+                    line_length,
                    ..LinterSettings::for_rule(Rule::LineTooLong)
                },
            )
--- a/crates/ruff_linter/src/codes.rs
+++ b/crates/ruff_linter/src/codes.rs
@@ -211,7 +211,6 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
        (Pylint, "C0205") => (RuleGroup::Stable, rules::pylint::rules::SingleStringSlots),
        (Pylint, "C0208") => (RuleGroup::Stable, rules::pylint::rules::IterationOverSet),
        (Pylint, "C0414") => (RuleGroup::Stable, rules::pylint::rules::UselessImportAlias),
-        (Pylint, "C0415") => (RuleGroup::Preview, rules::pylint::rules::ImportOutsideTopLevel),
        (Pylint, "C2401") => (RuleGroup::Preview, rules::pylint::rules::NonAsciiName),
        (Pylint, "C2403") => (RuleGroup::Preview, rules::pylint::rules::NonAsciiImportName),
        #[allow(deprecated)]
@@ -271,14 +270,12 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
        (Pylint, "W0604") => (RuleGroup::Preview, rules::pylint::rules::GlobalAtModuleLevel),
        (Pylint, "W0603") => (RuleGroup::Stable, rules::pylint::rules::GlobalStatement),
        (Pylint, "W0711") => (RuleGroup::Stable, rules::pylint::rules::BinaryOpException),
-        (Pylint, "W1501") => (RuleGroup::Preview, rules::pylint::rules::BadOpenMode),
        (Pylint, "W1508") => (RuleGroup::Stable, rules::pylint::rules::InvalidEnvvarDefault),
        (Pylint, "W1509") => (RuleGroup::Stable, rules::pylint::rules::SubprocessPopenPreexecFn),
        (Pylint, "W1510") => (RuleGroup::Stable, rules::pylint::rules::SubprocessRunWithoutCheck),
        (Pylint, "W1514") => (RuleGroup::Preview, rules::pylint::rules::UnspecifiedEncoding),
        #[allow(deprecated)]
        (Pylint, "W1641") => (RuleGroup::Nursery, rules::pylint::rules::EqWithoutHash),
-        (Pylint, "W2101") => (RuleGroup::Preview, rules::pylint::rules::UselessWithLock),
        (Pylint, "R0904") => (RuleGroup::Preview, rules::pylint::rules::TooManyPublicMethods),
        (Pylint, "W2901") => (RuleGroup::Stable, rules::pylint::rules::RedefinedLoopName),
        #[allow(deprecated)]
@@ -938,7 +935,6 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
        (Refurb, "140") => (RuleGroup::Preview, rules::refurb::rules::ReimplementedStarmap),
        (Refurb, "145") => (RuleGroup::Preview, rules::refurb::rules::SliceCopy),
        (Refurb, "148") => (RuleGroup::Preview, rules::refurb::rules::UnnecessaryEnumerate),
-        (Refurb, "168") => (RuleGroup::Preview, rules::refurb::rules::IsinstanceTypeNone),
        (Refurb, "171") => (RuleGroup::Preview, rules::refurb::rules::SingleItemMembershipTest),
        (Refurb, "177") => (RuleGroup::Preview, rules::refurb::rules::ImplicitCwd),

--- a/crates/ruff_linter/src/doc_lines.rs
+++ b/crates/ruff_linter/src/doc_lines.rs
@@ -3,7 +3,7 @@

 use std::iter::FusedIterator;

-use ruff_python_ast::{self as ast, Stmt, Suite};
+use ruff_python_ast::{self as ast, Constant, Expr, Stmt, Suite};
 use ruff_python_parser::lexer::LexResult;
 use ruff_python_parser::Tok;
 use ruff_text_size::{Ranged, TextSize};
@@ -69,15 +69,15 @@ struct StringLinesVisitor<'a> {

 impl StatementVisitor<'_> for StringLinesVisitor<'_> {
    fn visit_stmt(&mut self, stmt: &Stmt) {
-        if let Stmt::Expr(ast::StmtExpr {
-            value: expr,
-            range: _,
-        }) = stmt
-        {
-            if expr.is_string_literal_expr() {
+        if let Stmt::Expr(ast::StmtExpr { value, range: _ }) = stmt {
+            if let Expr::Constant(ast::ExprConstant {
+                value: Constant::Str(..),
+                ..
+            }) = value.as_ref()
+            {
                for line in UniversalNewlineIterator::with_offset(
-                    self.locator.slice(expr.as_ref()),
-                    expr.start(),
+                    self.locator.slice(value.as_ref()),
+                    value.start(),
                ) {
                    self.string_lines.push(line.start());
                }
--- a/crates/ruff_linter/src/docstrings/extraction.rs
+++ b/crates/ruff_linter/src/docstrings/extraction.rs
@@ -1,23 +1,30 @@
 //! Extract docstrings from an AST.

-use ruff_python_ast::{self as ast, Stmt};
+use ruff_python_ast::{self as ast, Constant, Expr, Stmt};
 use ruff_python_semantic::{Definition, DefinitionId, Definitions, Member, MemberKind};

 /// Extract a docstring from a function or class body.
-pub(crate) fn docstring_from(suite: &[Stmt]) -> Option<&ast::ExprStringLiteral> {
+pub(crate) fn docstring_from(suite: &[Stmt]) -> Option<&Expr> {
    let stmt = suite.first()?;
    // Require the docstring to be a standalone expression.
    let Stmt::Expr(ast::StmtExpr { value, range: _ }) = stmt else {
        return None;
    };
    // Only match strings.
-    value.as_string_literal_expr()
+    if !matches!(
+        value.as_ref(),
+        Expr::Constant(ast::ExprConstant {
+            value: Constant::Str(_),
+            ..
+        })
+    ) {
+        return None;
+    }
+    Some(value)
 }

 /// Extract a docstring from a `Definition`.
-pub(crate) fn extract_docstring<'a>(
-    definition: &'a Definition<'a>,
-) -> Option<&'a ast::ExprStringLiteral> {
+pub(crate) fn extract_docstring<'a>(definition: &'a Definition<'a>) -> Option<&'a Expr> {
    match definition {
        Definition::Module(module) => docstring_from(module.python_ast),
        Definition::Member(member) => docstring_from(member.body()),
--- a/crates/ruff_linter/src/docstrings/mod.rs
+++ b/crates/ruff_linter/src/docstrings/mod.rs
@@ -1,7 +1,7 @@
 use std::fmt::{Debug, Formatter};
 use std::ops::Deref;

-use ruff_python_ast::ExprStringLiteral;
+use ruff_python_ast::Expr;
 use ruff_python_semantic::Definition;
 use ruff_text_size::{Ranged, TextRange};

@@ -14,8 +14,7 @@ pub(crate) mod styles;
 #[derive(Debug)]
 pub(crate) struct Docstring<'a> {
    pub(crate) definition: &'a Definition<'a>,
-    /// The literal AST node representing the docstring.
-    pub(crate) expr: &'a ExprStringLiteral,
+    pub(crate) expr: &'a Expr,
    /// The content of the docstring, including the leading and trailing quotes.
    pub(crate) contents: &'a str,
    /// The range of the docstring body (without the quotes). The range is relative to [`Self::contents`].
--- a/crates/ruff_linter/src/fix/edits.rs
+++ b/crates/ruff_linter/src/fix/edits.rs
@@ -14,7 +14,7 @@ use ruff_source_file::{Locator, NewlineWithTrailingNewline, UniversalNewlines};
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};

 use crate::fix::codemods;
-use crate::line_width::{IndentWidth, LineLength, LineWidthBuilder};
+use crate::line_width::{LineLength, LineWidthBuilder, TabSize};

 /// Return the `Fix` to use when deleting a `Stmt`.
 ///
@@ -293,7 +293,7 @@ pub(crate) fn fits(
    node: AnyNodeRef,
    locator: &Locator,
    line_length: LineLength,
-    tab_size: IndentWidth,
+    tab_size: TabSize,
 ) -> bool {
    all_lines_fit(fix, node, locator, line_length.value() as usize, tab_size)
 }
@@ -305,7 +305,7 @@ pub(crate) fn fits_or_shrinks(
    node: AnyNodeRef,
    locator: &Locator,
    line_length: LineLength,
-    tab_size: IndentWidth,
+    tab_size: TabSize,
 ) -> bool {
    // Use the larger of the line length limit, or the longest line in the existing AST node.
    let line_length = std::iter::once(line_length.value() as usize)
@@ -327,7 +327,7 @@ fn all_lines_fit(
    node: AnyNodeRef,
    locator: &Locator,
    line_length: usize,
-    tab_size: IndentWidth,
+    tab_size: TabSize,
 ) -> bool {
    let prefix = locator.slice(TextRange::new(
        locator.line_start(node.start()),
--- a/crates/ruff_linter/src/line_width.rs
+++ b/crates/ruff_linter/src/line_width.rs
@@ -129,12 +129,12 @@ pub struct LineWidthBuilder {
    /// This is used to calculate the width of tabs.
    column: usize,
    /// The tab size to use when calculating the width of tabs.
-    tab_size: IndentWidth,
+    tab_size: TabSize,
 }

 impl Default for LineWidthBuilder {
    fn default() -> Self {
-        Self::new(IndentWidth::default())
+        Self::new(TabSize::default())
    }
 }

@@ -164,7 +164,7 @@ impl LineWidthBuilder {
    }

    /// Creates a new `LineWidth` with the given tab size.
-    pub fn new(tab_size: IndentWidth) -> Self {
+    pub fn new(tab_size: TabSize) -> Self {
        LineWidthBuilder {
            width: 0,
            column: 0,
@@ -234,28 +234,28 @@ impl PartialOrd<LineLength> for LineWidthBuilder {
 /// The size of a tab.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, CacheKey)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-pub struct IndentWidth(NonZeroU8);
+pub struct TabSize(NonZeroU8);

-impl IndentWidth {
+impl TabSize {
    pub(crate) fn as_usize(self) -> usize {
        self.0.get() as usize
    }
 }

-impl Default for IndentWidth {
+impl Default for TabSize {
    fn default() -> Self {
        Self(NonZeroU8::new(4).unwrap())
    }
 }

-impl From<NonZeroU8> for IndentWidth {
+impl From<NonZeroU8> for TabSize {
    fn from(tab_size: NonZeroU8) -> Self {
        Self(tab_size)
    }
 }

-impl From<IndentWidth> for NonZeroU8 {
-    fn from(value: IndentWidth) -> Self {
+impl From<TabSize> for NonZeroU8 {
+    fn from(value: TabSize) -> Self {
        value.0
    }
 }
--- a/crates/ruff_linter/src/message/text.rs
+++ b/crates/ruff_linter/src/message/text.rs
@@ -12,7 +12,7 @@ use ruff_source_file::{OneIndexed, SourceLocation};
 use ruff_text_size::{Ranged, TextRange, TextSize};

 use crate::fs::relativize_path;
-use crate::line_width::{IndentWidth, LineWidthBuilder};
+use crate::line_width::{LineWidthBuilder, TabSize};
 use crate::message::diff::Diff;
 use crate::message::{Emitter, EmitterContext, Message};
 use crate::registry::AsRule;
@@ -300,7 +300,7 @@ fn replace_whitespace(source: &str, annotation_range: TextRange) -> SourceCode {
    let mut result = String::new();
    let mut last_end = 0;
    let mut range = annotation_range;
-    let mut line_width = LineWidthBuilder::new(IndentWidth::default());
+    let mut line_width = LineWidthBuilder::new(TabSize::default());

    for (index, c) in source.char_indices() {
        let old_width = line_width.get();
--- a/crates/ruff_linter/src/pyproject_toml.rs
+++ b/crates/ruff_linter/src/pyproject_toml.rs
@@ -1,7 +1,8 @@
 use colored::Colorize;
 use log::warn;
-use pyproject_toml::PyProjectToml;
+use pyproject_toml::{BuildSystem, Project};
 use ruff_text_size::{TextRange, TextSize};
+use serde::{Deserialize, Serialize};

 use ruff_diagnostics::Diagnostic;
 use ruff_source_file::SourceFile;
@@ -12,6 +13,16 @@ use crate::rules::ruff::rules::InvalidPyprojectToml;
 use crate::settings::LinterSettings;
 use crate::IOError;

+/// Unlike [`pyproject_toml::PyProjectToml`], in our case `build_system` is also optional
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+struct PyProjectToml {
+    /// Build-related data
+    build_system: Option<BuildSystem>,
+    /// Project metadata
+    project: Option<Project>,
+}
+
 pub fn lint_pyproject_toml(source_file: SourceFile, settings: &LinterSettings) -> Vec<Message> {
    let Some(err) = toml::from_str::<PyProjectToml>(source_file.source_text()).err() else {
        return Vec::default();
--- a/crates/ruff_linter/src/rules/airflow/rules/task_variable_name.rs
+++ b/crates/ruff_linter/src/rules/airflow/rules/task_variable_name.rs
@@ -1,6 +1,7 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast as ast;
+use ruff_python_ast::Constant;
 use ruff_python_ast::Expr;
 use ruff_text_size::Ranged;

@@ -78,7 +79,13 @@ pub(crate) fn variable_name_task_id(
    let keyword = arguments.find_keyword("task_id")?;

    // If the keyword argument is not a string, we can't do anything.
-    let ast::ExprStringLiteral { value: task_id, .. } = keyword.value.as_string_literal_expr()?;
+    let task_id = match &keyword.value {
+        Expr::Constant(constant) => match &constant.value {
+            Constant::Str(ast::StringConstant { value, .. }) => value,
+            _ => return None,
+        },
+        _ => return None,
+    };

    // If the target name is the same as the task_id, no violation.
    if id == task_id {
--- a/crates/ruff_linter/src/rules/flake8_2020/rules/compare.rs
+++ b/crates/ruff_linter/src/rules/flake8_2020/rules/compare.rs
@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, CmpOp, Expr};
+use ruff_python_ast::{self as ast, CmpOp, Constant, Expr};
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -230,16 +230,16 @@ pub(crate) fn compare(checker: &mut Checker, left: &Expr, ops: &[CmpOp], compara
        Expr::Subscript(ast::ExprSubscript { value, slice, .. })
            if is_sys(value, "version_info", checker.semantic()) =>
        {
-            if let Expr::NumberLiteral(ast::ExprNumberLiteral {
-                value: ast::Number::Int(i),
+            if let Expr::Constant(ast::ExprConstant {
+                value: Constant::Int(i),
                ..
            }) = slice.as_ref()
            {
                if *i == 0 {
                    if let (
                        [CmpOp::Eq | CmpOp::NotEq],
-                        [Expr::NumberLiteral(ast::ExprNumberLiteral {
-                            value: ast::Number::Int(n),
+                        [Expr::Constant(ast::ExprConstant {
+                            value: Constant::Int(n),
                            ..
                        })],
                    ) = (ops, comparators)
@@ -253,8 +253,8 @@ pub(crate) fn compare(checker: &mut Checker, left: &Expr, ops: &[CmpOp], compara
                } else if *i == 1 {
                    if let (
                        [CmpOp::Lt | CmpOp::LtE | CmpOp::Gt | CmpOp::GtE],
-                        [Expr::NumberLiteral(ast::ExprNumberLiteral {
-                            value: ast::Number::Int(_),
+                        [Expr::Constant(ast::ExprConstant {
+                            value: Constant::Int(_),
                            ..
                        })],
                    ) = (ops, comparators)
@@ -274,8 +274,8 @@ pub(crate) fn compare(checker: &mut Checker, left: &Expr, ops: &[CmpOp], compara
        {
            if let (
                [CmpOp::Lt | CmpOp::LtE | CmpOp::Gt | CmpOp::GtE],
-                [Expr::NumberLiteral(ast::ExprNumberLiteral {
-                    value: ast::Number::Int(_),
+                [Expr::Constant(ast::ExprConstant {
+                    value: Constant::Int(_),
                    ..
                })],
            ) = (ops, comparators)
@@ -294,10 +294,13 @@ pub(crate) fn compare(checker: &mut Checker, left: &Expr, ops: &[CmpOp], compara
    if is_sys(left, "version", checker.semantic()) {
        if let (
            [CmpOp::Lt | CmpOp::LtE | CmpOp::Gt | CmpOp::GtE],
-            [Expr::StringLiteral(ast::ExprStringLiteral { value, .. })],
+            [Expr::Constant(ast::ExprConstant {
+                value: Constant::Str(s),
+                ..
+            })],
        ) = (ops, comparators)
        {
-            if value.len() == 1 {
+            if s.len() == 1 {
                if checker.enabled(Rule::SysVersionCmpStr10) {
                    checker
                        .diagnostics
--- a/crates/ruff_linter/src/rules/flake8_2020/rules/subscript.rs
+++ b/crates/ruff_linter/src/rules/flake8_2020/rules/subscript.rs
@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::{self as ast, Constant, Expr};
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -177,8 +177,8 @@ pub(crate) fn subscript(checker: &mut Checker, value: &Expr, slice: &Expr) {
                step: None,
                range: _,
            }) => {
-                if let Expr::NumberLiteral(ast::ExprNumberLiteral {
-                    value: ast::Number::Int(i),
+                if let Expr::Constant(ast::ExprConstant {
+                    value: Constant::Int(i),
                    ..
                }) = upper.as_ref()
                {
@@ -194,8 +194,8 @@ pub(crate) fn subscript(checker: &mut Checker, value: &Expr, slice: &Expr) {
                }
            }

-            Expr::NumberLiteral(ast::ExprNumberLiteral {
-                value: ast::Number::Int(i),
+            Expr::Constant(ast::ExprConstant {
+                value: Constant::Int(i),
                ..
            }) => {
                if *i == 2 && checker.enabled(Rule::SysVersion2) {
--- a/crates/ruff_linter/src/rules/flake8_annotations/rules/definition.rs
+++ b/crates/ruff_linter/src/rules/flake8_annotations/rules/definition.rs
@@ -3,7 +3,7 @@ use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::ReturnStatementVisitor;
 use ruff_python_ast::identifier::Identifier;
 use ruff_python_ast::statement_visitor::StatementVisitor;
-use ruff_python_ast::{self as ast, Expr, ParameterWithDefault, Stmt};
+use ruff_python_ast::{self as ast, Constant, Expr, ParameterWithDefault, Stmt};
 use ruff_python_parser::typing::parse_type_annotation;
 use ruff_python_semantic::analyze::visibility;
 use ruff_python_semantic::Definition;
@@ -265,7 +265,7 @@ impl Violation for MissingReturnTypePrivateFunction {
 /// or `ruff.toml` file:
 ///
 /// ```toml
-/// [tool.ruff.lint.flake8-annotations]
+/// [tool.ruff.flake8-annotations]
 /// mypy-init-return = true
 /// ```
 ///
@@ -431,7 +431,10 @@ fn is_none_returning(body: &[Stmt]) -> bool {
    visitor.visit_body(body);
    for stmt in visitor.returns {
        if let Some(value) = stmt.value.as_deref() {
-            if !value.is_none_literal_expr() {
+            if !matches!(
+                value,
+                Expr::Constant(constant) if constant.value.is_none()
+            ) {
                return false;
            }
        }
@@ -448,10 +451,9 @@ fn check_dynamically_typed<F>(
 ) where
    F: FnOnce() -> String,
 {
-    if let Expr::StringLiteral(ast::ExprStringLiteral {
+    if let Expr::Constant(ast::ExprConstant {
        range,
-        value: string,
-        ..
+        value: Constant::Str(string),
    }) = annotation
    {
        // Quoted annotations
--- a/crates/ruff_linter/src/rules/flake8_bandit/helpers.rs
+++ b/crates/ruff_linter/src/rules/flake8_bandit/helpers.rs
@@ -1,6 +1,6 @@
 use once_cell::sync::Lazy;
 use regex::Regex;
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::{self as ast, Constant, Expr};

 use ruff_python_semantic::SemanticModel;

@@ -10,7 +10,10 @@ static PASSWORD_CANDIDATE_REGEX: Lazy<Regex> = Lazy::new(|| {

 pub(super) fn string_literal(expr: &Expr) -> Option<&str> {
    match expr {
-        Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => Some(value),
+        Expr::Constant(ast::ExprConstant {
+            value: Constant::Str(string),
+            ..
+        }) => Some(string),
        _ => None,
    }
 }
--- a/crates/ruff_linter/src/rules/flake8_bandit/rules/bad_file_permissions.rs
+++ b/crates/ruff_linter/src/rules/flake8_bandit/rules/bad_file_permissions.rs
@@ -3,7 +3,7 @@ use anyhow::Result;
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::call_path::CallPath;
-use ruff_python_ast::{self as ast, Expr, Operator};
+use ruff_python_ast::{self as ast, Constant, Expr, Operator};
 use ruff_python_semantic::SemanticModel;
 use ruff_text_size::Ranged;

@@ -144,8 +144,8 @@ fn py_stat(call_path: &CallPath) -> Option<u16> {
 /// an integer value, but that value is out of range.
 fn parse_mask(expr: &Expr, semantic: &SemanticModel) -> Result<Option<u16>> {
    match expr {
-        Expr::NumberLiteral(ast::ExprNumberLiteral {
-            value: ast::Number::Int(int),
+        Expr::Constant(ast::ExprConstant {
+            value: Constant::Int(int),
            ..
        }) => match int.as_u16() {
            Some(value) => Ok(Some(value)),
--- a/crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_bind_all_interfaces.rs
+++ b/crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_bind_all_interfaces.rs
@@ -1,6 +1,7 @@
+use ruff_text_size::TextRange;
+
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::ExprStringLiteral;

 /// ## What it does
 /// Checks for hardcoded bindings to all network interfaces (`0.0.0.0`).
@@ -34,9 +35,9 @@ impl Violation for HardcodedBindAllInterfaces {
 }

 /// S104
-pub(crate) fn hardcoded_bind_all_interfaces(string: &ExprStringLiteral) -> Option<Diagnostic> {
-    if string.value == "0.0.0.0" {
-        Some(Diagnostic::new(HardcodedBindAllInterfaces, string.range))
+pub(crate) fn hardcoded_bind_all_interfaces(value: &str, range: TextRange) -> Option<Diagnostic> {
+    if value == "0.0.0.0" {
+        Some(Diagnostic::new(HardcodedBindAllInterfaces, range))
    } else {
        None
    }
--- a/crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_password_string.rs
+++ b/crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_password_string.rs
@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::{self as ast, Constant, Expr};
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -55,7 +55,10 @@ fn password_target(target: &Expr) -> Option<&str> {
        Expr::Name(ast::ExprName { id, .. }) => id.as_str(),
        // d["password"] = "s3cr3t"
        Expr::Subscript(ast::ExprSubscript { slice, .. }) => match slice.as_ref() {
-            Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => value,
+            Expr::Constant(ast::ExprConstant {
+                value: Constant::Str(string),
+                ..
+            }) => string,
            _ => return None,
        },
        // obj.password = "s3cr3t"
--- a/crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_tmp_directory.rs
+++ b/crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_tmp_directory.rs
@@ -2,6 +2,7 @@ use ruff_python_ast::{self as ast, Expr};

 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
+use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;

@@ -51,13 +52,13 @@ impl Violation for HardcodedTempFile {
 }

 /// S108
-pub(crate) fn hardcoded_tmp_directory(checker: &mut Checker, string: &ast::ExprStringLiteral) {
+pub(crate) fn hardcoded_tmp_directory(checker: &mut Checker, expr: &Expr, value: &str) {
    if !checker
        .settings
        .flake8_bandit
        .hardcoded_tmp_directory
        .iter()
-        .any(|prefix| string.value.starts_with(prefix))
+        .any(|prefix| value.starts_with(prefix))
    {
        return;
    }
@@ -76,8 +77,8 @@ pub(crate) fn hardcoded_tmp_directory(checker: &mut Checker, string: &ast::ExprS

    checker.diagnostics.push(Diagnostic::new(
        HardcodedTempFile {
-            string: string.value.clone(),
+            string: value.to_string(),
        },
-        string.range,
+        expr.range(),
    ));
 }
--- a/crates/ruff_linter/src/rules/flake8_bandit/rules/jinja2_autoescape_false.rs
+++ b/crates/ruff_linter/src/rules/flake8_bandit/rules/jinja2_autoescape_false.rs
@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::{self as ast, Constant, Expr};
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -66,7 +66,10 @@ pub(crate) fn jinja2_autoescape_false(checker: &mut Checker, call: &ast::ExprCal
    {
        if let Some(keyword) = call.arguments.find_keyword("autoescape") {
            match &keyword.value {
-                Expr::BooleanLiteral(ast::ExprBooleanLiteral { value: true, .. }) => (),
+                Expr::Constant(ast::ExprConstant {
+                    value: Constant::Bool(true),
+                    ..
+                }) => (),
                Expr::Call(ast::ExprCall { func, .. }) => {
                    if let Expr::Name(ast::ExprName { id, .. }) = func.as_ref() {
                        if id != "select_autoescape" {
--- a/crates/ruff_linter/src/rules/flake8_bandit/rules/request_without_timeout.rs
+++ b/crates/ruff_linter/src/rules/flake8_bandit/rules/request_without_timeout.rs
@@ -1,7 +1,7 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast as ast;
-
+use ruff_python_ast::helpers::is_const_none;
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -64,7 +64,7 @@ pub(crate) fn request_without_timeout(checker: &mut Checker, call: &ast::ExprCal
        })
    {
        if let Some(keyword) = call.arguments.find_keyword("timeout") {
-            if keyword.value.is_none_literal_expr() {
+            if is_const_none(&keyword.value) {
                checker.diagnostics.push(Diagnostic::new(
                    RequestWithoutTimeout { implicit: false },
                    keyword.range(),
--- a/crates/ruff_linter/src/rules/flake8_bandit/rules/shell_injection.rs
+++ b/crates/ruff_linter/src/rules/flake8_bandit/rules/shell_injection.rs
@@ -3,7 +3,7 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::Truthiness;
-use ruff_python_ast::{self as ast, Arguments, Expr, Keyword};
+use ruff_python_ast::{self as ast, Arguments, Constant, Expr, Keyword};
 use ruff_python_semantic::SemanticModel;
 use ruff_text_size::Ranged;

@@ -38,22 +38,18 @@ use crate::{
 /// - [Common Weakness Enumeration: CWE-78](https://cwe.mitre.org/data/definitions/78.html)
 #[violation]
 pub struct SubprocessPopenWithShellEqualsTrue {
-    safety: Safety,
-    is_exact: bool,
+    seems_safe: bool,
 }

 impl Violation for SubprocessPopenWithShellEqualsTrue {
    #[derive_message_formats]
    fn message(&self) -> String {
-        match (self.safety, self.is_exact) {
-            (Safety::SeemsSafe, true) => format!(
+        if self.seems_safe {
+            format!(
                "`subprocess` call with `shell=True` seems safe, but may be changed in the future; consider rewriting without `shell`"
-            ),
-            (Safety::Unknown, true) => format!("`subprocess` call with `shell=True` identified, security issue"),
-            (Safety::SeemsSafe, false) => format!(
-                "`subprocess` call with truthy `shell` seems safe, but may be changed in the future; consider rewriting without `shell`"
-            ),
-            (Safety::Unknown, false) => format!("`subprocess` call with truthy `shell` identified, security issue"),
+            )
+        } else {
+            format!("`subprocess` call with `shell=True` identified, security issue")
        }
    }
 }
@@ -93,18 +89,16 @@ impl Violation for SubprocessWithoutShellEqualsTrue {
 }

 /// ## What it does
-/// Checks for method calls that set the `shell` parameter to `true` or another
-/// truthy value when invoking a subprocess.
+/// Checks for method calls that set the `shell` parameter to `true` when
+/// invoking a subprocess.
 ///
 /// ## Why is this bad?
-/// Setting the `shell` parameter to `true` or another truthy value when
-/// invoking a subprocess can introduce security vulnerabilities, as it allows
-/// shell metacharacters and whitespace to be passed to child processes,
-/// potentially leading to shell injection attacks.
-///
-/// It is recommended to avoid using `shell=True` unless absolutely necessary
-/// and, when used, to ensure that all inputs are properly sanitized and quoted
-/// to prevent such vulnerabilities.
+/// Setting the `shell` parameter to `true` when invoking a subprocess can
+/// introduce security vulnerabilities, as it allows shell metacharacters and
+/// whitespace to be passed to child processes, potentially leading to shell
+/// injection attacks. It is recommended to avoid using `shell=True` unless
+/// absolutely necessary, and when used, to ensure that all inputs are properly
+/// sanitized and quoted to prevent such vulnerabilities.
 ///
 /// ## Known problems
 /// Prone to false positives as it is triggered on any function call with a
@@ -121,18 +115,12 @@ impl Violation for SubprocessWithoutShellEqualsTrue {
 /// ## References
 /// - [Python documentation: Security Considerations](https://docs.python.org/3/library/subprocess.html#security-considerations)
 #[violation]
-pub struct CallWithShellEqualsTrue {
-    is_exact: bool,
-}
+pub struct CallWithShellEqualsTrue;

 impl Violation for CallWithShellEqualsTrue {
    #[derive_message_formats]
    fn message(&self) -> String {
-        if self.is_exact {
-            format!("Function call with `shell=True` parameter identified, security issue")
-        } else {
-            format!("Function call with truthy `shell` parameter identified, security issue")
-        }
+        format!("Function call with `shell=True` parameter identified, security issue")
    }
 }

@@ -174,15 +162,16 @@ impl Violation for CallWithShellEqualsTrue {
 /// - [Python documentation: `subprocess`](https://docs.python.org/3/library/subprocess.html)
 #[violation]
 pub struct StartProcessWithAShell {
-    safety: Safety,
+    seems_safe: bool,
 }

 impl Violation for StartProcessWithAShell {
    #[derive_message_formats]
    fn message(&self) -> String {
-        match self.safety {
-            Safety::SeemsSafe => format!("Starting a process with a shell: seems safe, but may be changed in the future; consider rewriting without `shell`"),
-            Safety::Unknown => format!("Starting a process with a shell, possible injection detected"),
+        if self.seems_safe {
+            format!("Starting a process with a shell: seems safe, but may be changed in the future; consider rewriting without `shell`")
+        } else {
+            format!("Starting a process with a shell, possible injection detected")
        }
    }
 }
@@ -295,14 +284,13 @@ pub(crate) fn shell_injection(checker: &mut Checker, call: &ast::ExprCall) {
            match shell_keyword {
                // S602
                Some(ShellKeyword {
-                    truthiness: truthiness @ (Truthiness::True | Truthiness::Truthy),
+                    truthiness: Truthiness::Truthy,
                    keyword,
                }) => {
                    if checker.enabled(Rule::SubprocessPopenWithShellEqualsTrue) {
                        checker.diagnostics.push(Diagnostic::new(
                            SubprocessPopenWithShellEqualsTrue {
-                                safety: Safety::from(arg),
-                                is_exact: matches!(truthiness, Truthiness::True),
+                                seems_safe: shell_call_seems_safe(arg),
                            },
                            keyword.range(),
                        ));
@@ -310,7 +298,7 @@ pub(crate) fn shell_injection(checker: &mut Checker, call: &ast::ExprCall) {
                }
                // S603
                Some(ShellKeyword {
-                    truthiness: Truthiness::False | Truthiness::Falsey | Truthiness::Unknown,
+                    truthiness: Truthiness::Falsey | Truthiness::Unknown,
                    keyword,
                }) => {
                    if checker.enabled(Rule::SubprocessWithoutShellEqualsTrue) {
@@ -332,18 +320,15 @@ pub(crate) fn shell_injection(checker: &mut Checker, call: &ast::ExprCall) {
            }
        }
    } else if let Some(ShellKeyword {
-        truthiness: truthiness @ (Truthiness::True | Truthiness::Truthy),
+        truthiness: Truthiness::Truthy,
        keyword,
    }) = shell_keyword
    {
        // S604
        if checker.enabled(Rule::CallWithShellEqualsTrue) {
-            checker.diagnostics.push(Diagnostic::new(
-                CallWithShellEqualsTrue {
-                    is_exact: matches!(truthiness, Truthiness::True),
-                },
-                keyword.range(),
-            ));
+            checker
+                .diagnostics
+                .push(Diagnostic::new(CallWithShellEqualsTrue, keyword.range()));
        }
    }

@@ -353,7 +338,7 @@ pub(crate) fn shell_injection(checker: &mut Checker, call: &ast::ExprCall) {
            if let Some(arg) = call.arguments.args.first() {
                checker.diagnostics.push(Diagnostic::new(
                    StartProcessWithAShell {
-                        safety: Safety::from(arg),
+                        seems_safe: shell_call_seems_safe(arg),
                    },
                    arg.range(),
                ));
@@ -391,7 +376,7 @@ pub(crate) fn shell_injection(checker: &mut Checker, call: &ast::ExprCall) {
                (
                    Some(CallKind::Subprocess),
                    Some(ShellKeyword {
-                        truthiness: Truthiness::True | Truthiness::Truthy,
+                        truthiness: Truthiness::Truthy,
                        keyword: _,
                    })
                )
@@ -468,22 +453,16 @@ fn find_shell_keyword<'a>(
    })
 }

-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-enum Safety {
-    SeemsSafe,
-    Unknown,
-}
-
-impl From<&Expr> for Safety {
-    /// Return the [`Safety`] level for the [`Expr`]. This is based on Bandit's definition: string
-    /// literals are considered okay, but dynamically-computed values are not.
-    fn from(expr: &Expr) -> Self {
-        if expr.is_string_literal_expr() {
-            Self::SeemsSafe
-        } else {
-            Self::Unknown
-        }
-    }
+/// Return `true` if the value provided to the `shell` call seems safe. This is based on Bandit's
+/// definition: string literals are considered okay, but dynamically-computed values are not.
+fn shell_call_seems_safe(arg: &Expr) -> bool {
+    matches!(
+        arg,
+        Expr::Constant(ast::ExprConstant {
+            value: Constant::Str(_),
+            ..
+        })
+    )
 }

 /// Return `true` if the string appears to be a full file path.
--- a/crates/ruff_linter/src/rules/flake8_bandit/rules/snmp_insecure_version.rs
+++ b/crates/ruff_linter/src/rules/flake8_bandit/rules/snmp_insecure_version.rs
@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Expr, Int};
+use ruff_python_ast::{self as ast, Constant, Expr, Int};
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -52,8 +52,8 @@ pub(crate) fn snmp_insecure_version(checker: &mut Checker, call: &ast::ExprCall)
        if let Some(keyword) = call.arguments.find_keyword("mpModel") {
            if matches!(
                keyword.value,
-                Expr::NumberLiteral(ast::ExprNumberLiteral {
-                    value: ast::Number::Int(Int::ZERO | Int::ONE),
+                Expr::Constant(ast::ExprConstant {
+                    value: Constant::Int(Int::ZERO | Int::ONE),
                    ..
                })
            ) {
--- a/crates/ruff_linter/src/rules/flake8_bandit/rules/suspicious_function_call.rs
+++ b/crates/ruff_linter/src/rules/flake8_bandit/rules/suspicious_function_call.rs
@@ -854,7 +854,7 @@ pub(crate) fn suspicious_function_call(checker: &mut Checker, call: &ExprCall) {
            ["six", "moves", "urllib", "request", "urlopen" | "urlretrieve" | "Request"] => {
                // If the `url` argument is a string literal, allow `http` and `https` schemes.
                if call.arguments.args.iter().all(|arg| !arg.is_starred_expr()) && call.arguments.keywords.iter().all(|keyword| keyword.arg.is_some()) {
-                    if let Some(Expr::StringLiteral(ast::ExprStringLiteral { value: url, .. })) = &call.arguments.find_argument("url", 0) {
+                    if let Some(Expr::Constant(ast::ExprConstant { value: ast::Constant::Str(url), .. })) = &call.arguments.find_argument("url", 0) {
                            let url = url.trim_start();
                            if url.starts_with("http://") || url.starts_with("https://") {
                                return None;
--- a/crates/ruff_linter/src/rules/flake8_bandit/rules/weak_cryptographic_key.rs
+++ b/crates/ruff_linter/src/rules/flake8_bandit/rules/weak_cryptographic_key.rs
@@ -2,7 +2,7 @@ use std::fmt::{Display, Formatter};

 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Expr, ExprAttribute, ExprCall};
+use ruff_python_ast::{self as ast, Constant, Expr, ExprAttribute, ExprCall};
 use ruff_text_size::{Ranged, TextRange};

 use crate::checkers::ast::Checker;
@@ -151,8 +151,8 @@ fn extract_cryptographic_key(

 fn extract_int_argument(call: &ExprCall, name: &str, position: usize) -> Option<(u16, TextRange)> {
    let argument = call.arguments.find_argument(name, position)?;
-    let Expr::NumberLiteral(ast::ExprNumberLiteral {
-        value: ast::Number::Int(i),
+    let Expr::Constant(ast::ExprConstant {
+        value: Constant::Int(i),
        ..
    }) = argument
    else {
--- a/crates/ruff_linter/src/rules/flake8_bandit/snapshots/ruff_linterrulesflake8_bandittestsS602_S602.py.snap
+++ b/crates/ruff_linter/src/rules/flake8_bandit/snapshots/ruff_linterrulesflake8_bandittestsS602_S602.py.snap
@@ -49,7 +49,7 @@ S602.py:8:13: S602 `subprocess` call with `shell=True` seems safe, but may be ch
 10 | # Check values that truthy values are treated as true.
   |

-S602.py:11:15: S602 `subprocess` call with truthy `shell` seems safe, but may be changed in the future; consider rewriting without `shell`
+S602.py:11:15: S602 `subprocess` call with `shell=True` seems safe, but may be changed in the future; consider rewriting without `shell`
   |
 10 | # Check values that truthy values are treated as true.
 11 | Popen("true", shell=1)
@@ -58,7 +58,7 @@ S602.py:11:15: S602 `subprocess` call with truthy `shell` seems safe, but may be
 13 | Popen("true", shell={1: 1})
   |

-S602.py:12:15: S602 `subprocess` call with truthy `shell` seems safe, but may be changed in the future; consider rewriting without `shell`
+S602.py:12:15: S602 `subprocess` call with `shell=True` seems safe, but may be changed in the future; consider rewriting without `shell`
   |
 10 | # Check values that truthy values are treated as true.
 11 | Popen("true", shell=1)
@@ -68,7 +68,7 @@ S602.py:12:15: S602 `subprocess` call with truthy `shell` seems safe, but may be
 14 | Popen("true", shell=(1,))
   |

-S602.py:13:15: S602 `subprocess` call with truthy `shell` seems safe, but may be changed in the future; consider rewriting without `shell`
+S602.py:13:15: S602 `subprocess` call with `shell=True` seems safe, but may be changed in the future; consider rewriting without `shell`
   |
 11 | Popen("true", shell=1)
 12 | Popen("true", shell=[1])
@@ -77,7 +77,7 @@ S602.py:13:15: S602 `subprocess` call with truthy `shell` seems safe, but may be
 14 | Popen("true", shell=(1,))
   |

-S602.py:14:15: S602 `subprocess` call with truthy `shell` seems safe, but may be changed in the future; consider rewriting without `shell`
+S602.py:14:15: S602 `subprocess` call with `shell=True` seems safe, but may be changed in the future; consider rewriting without `shell`
   |
 12 | Popen("true", shell=[1])
 13 | Popen("true", shell={1: 1})
--- a/crates/ruff_linter/src/rules/flake8_boolean_trap/helpers.rs
+++ b/crates/ruff_linter/src/rules/flake8_boolean_trap/helpers.rs
@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::{self as ast, Constant, Expr};

 /// Returns `true` if a function call is allowed to use a boolean trap.
 pub(super) fn is_allowed_func_call(name: &str) -> bool {
@@ -62,3 +62,14 @@ pub(super) fn allow_boolean_trap(func: &Expr) -> bool {

    false
 }
+
+/// Returns `true` if an expression is a boolean literal.
+pub(super) const fn is_boolean(expr: &Expr) -> bool {
+    matches!(
+        &expr,
+        Expr::Constant(ast::ExprConstant {
+            value: Constant::Bool(_),
+            ..
+        })
+    )
+}
--- a/crates/ruff_linter/src/rules/flake8_boolean_trap/rules/boolean_default_value_positional_argument.rs
+++ b/crates/ruff_linter/src/rules/flake8_boolean_trap/rules/boolean_default_value_positional_argument.rs
@@ -5,7 +5,7 @@ use ruff_python_ast::{Decorator, ParameterWithDefault, Parameters};
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
-use crate::rules::flake8_boolean_trap::helpers::is_allowed_func_def;
+use crate::rules::flake8_boolean_trap::helpers::{is_allowed_func_def, is_boolean};

 /// ## What it does
 /// Checks for the use of boolean positional arguments in function definitions,
@@ -117,10 +117,7 @@ pub(crate) fn boolean_default_value_positional_argument(
        range: _,
    } in parameters.posonlyargs.iter().chain(&parameters.args)
    {
-        if default
-            .as_ref()
-            .is_some_and(|default| default.is_boolean_literal_expr())
-        {
+        if default.as_ref().is_some_and(|default| is_boolean(default)) {
            checker.diagnostics.push(Diagnostic::new(
                BooleanDefaultValuePositionalArgument,
                parameter.name.range(),
--- a/crates/ruff_linter/src/rules/flake8_boolean_trap/rules/boolean_positional_value_in_call.rs
+++ b/crates/ruff_linter/src/rules/flake8_boolean_trap/rules/boolean_positional_value_in_call.rs
@@ -4,7 +4,7 @@ use ruff_python_ast::Expr;
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
-use crate::rules::flake8_boolean_trap::helpers::allow_boolean_trap;
+use crate::rules::flake8_boolean_trap::helpers::{allow_boolean_trap, is_boolean};

 /// ## What it does
 /// Checks for boolean positional arguments in function calls.
@@ -49,7 +49,7 @@ pub(crate) fn boolean_positional_value_in_call(checker: &mut Checker, args: &[Ex
    if allow_boolean_trap(func) {
        return;
    }
-    for arg in args.iter().filter(|arg| arg.is_boolean_literal_expr()) {
+    for arg in args.iter().filter(|arg| is_boolean(arg)) {
        checker
            .diagnostics
            .push(Diagnostic::new(BooleanPositionalValueInCall, arg.range()));
--- a/crates/ruff_linter/src/rules/flake8_boolean_trap/rules/boolean_type_hint_positional_argument.rs
+++ b/crates/ruff_linter/src/rules/flake8_boolean_trap/rules/boolean_type_hint_positional_argument.rs
@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Decorator, Expr, ParameterWithDefault, Parameters};
+use ruff_python_ast::{self as ast, Constant, Decorator, Expr, ParameterWithDefault, Parameters};

 use ruff_diagnostics::Diagnostic;
 use ruff_diagnostics::Violation;
@@ -126,7 +126,10 @@ pub(crate) fn boolean_type_hint_positional_argument(
        // check for both bool (python class) and 'bool' (string annotation)
        let hint = match annotation.as_ref() {
            Expr::Name(name) => &name.id == "bool",
-            Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => value == "bool",
+            Expr::Constant(ast::ExprConstant {
+                value: Constant::Str(ast::StringConstant { value, .. }),
+                ..
+            }) => value == "bool",
            _ => false,
        };
        if !hint || !checker.semantic().is_builtin("bool") {
--- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/abstract_base_class.rs
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/abstract_base_class.rs
@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Arguments, Expr, Keyword, Stmt};
+use ruff_python_ast::{self as ast, Arguments, Constant, Expr, Keyword, Stmt};

 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
@@ -121,12 +121,12 @@ fn is_abc_class(bases: &[Expr], keywords: &[Keyword], semantic: &SemanticModel)
 fn is_empty_body(body: &[Stmt]) -> bool {
    body.iter().all(|stmt| match stmt {
        Stmt::Pass(_) => true,
-        Stmt::Expr(ast::StmtExpr { value, range: _ }) => {
-            matches!(
-                value.as_ref(),
-                Expr::StringLiteral(_) | Expr::EllipsisLiteral(_)
-            )
-        }
+        Stmt::Expr(ast::StmtExpr { value, range: _ }) => match value.as_ref() {
+            Expr::Constant(ast::ExprConstant { value, .. }) => {
+                matches!(value, Constant::Str(..) | Constant::Ellipsis)
+            }
+            _ => false,
+        },
        _ => false,
    })
 }
--- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/duplicate_value.rs
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/duplicate_value.rs
@@ -1,4 +1,4 @@
-use ruff_python_ast::Expr;
+use ruff_python_ast::{self as ast, Expr};
 use rustc_hash::FxHashSet;

 use ruff_diagnostics::{Diagnostic, Violation};
@@ -42,13 +42,13 @@ impl Violation for DuplicateValue {
 pub(crate) fn duplicate_value(checker: &mut Checker, elts: &Vec<Expr>) {
    let mut seen_values: FxHashSet<ComparableExpr> = FxHashSet::default();
    for elt in elts {
-        if elt.is_literal_expr() {
+        if let Expr::Constant(ast::ExprConstant { value, .. }) = elt {
            let comparable_value: ComparableExpr = elt.into();

            if !seen_values.insert(comparable_value) {
                checker.diagnostics.push(Diagnostic::new(
                    DuplicateValue {
-                        value: checker.generator().expr(elt),
+                        value: checker.generator().constant(value),
                    },
                    elt.range(),
                ));
--- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/getattr_with_constant.rs
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/getattr_with_constant.rs
@@ -1,7 +1,7 @@
 use crate::fix::edits::pad;
 use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::{self as ast, Constant, Expr};
 use ruff_python_stdlib::identifiers::{is_identifier, is_mangled_private};
 use ruff_text_size::Ranged;

@@ -66,7 +66,11 @@ pub(crate) fn getattr_with_constant(
    if obj.is_starred_expr() {
        return;
    }
-    let Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) = arg else {
+    let Expr::Constant(ast::ExprConstant {
+        value: Constant::Str(ast::StringConstant { value, .. }),
+        ..
+    }) = arg
+    else {
        return;
    };
    if !is_identifier(value) {
--- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/raise_literal.rs
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/raise_literal.rs
@@ -38,7 +38,7 @@ impl Violation for RaiseLiteral {

 /// B016
 pub(crate) fn raise_literal(checker: &mut Checker, expr: &Expr) {
-    if expr.is_literal_expr() {
+    if expr.is_constant_expr() {
        checker
            .diagnostics
            .push(Diagnostic::new(RaiseLiteral, expr.range()));
--- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/setattr_with_constant.rs
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/setattr_with_constant.rs
@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Expr, ExprContext, Identifier, Stmt};
+use ruff_python_ast::{self as ast, Constant, Expr, ExprContext, Identifier, Stmt};
 use ruff_text_size::{Ranged, TextRange};

 use ruff_diagnostics::{AlwaysFixableViolation, Diagnostic, Edit, Fix};
@@ -80,7 +80,11 @@ pub(crate) fn setattr_with_constant(
    if obj.is_starred_expr() {
        return;
    }
-    let Expr::StringLiteral(ast::ExprStringLiteral { value: name, .. }) = name else {
+    let Expr::Constant(ast::ExprConstant {
+        value: Constant::Str(name),
+        ..
+    }) = name
+    else {
        return;
    };
    if !is_identifier(name) {
--- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/strip_with_multi_characters.rs
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/strip_with_multi_characters.rs
@@ -1,5 +1,5 @@
 use itertools::Itertools;
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::{self as ast, Constant, Expr};

 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
@@ -68,7 +68,11 @@ pub(crate) fn strip_with_multi_characters(
        return;
    }

-    let [Expr::StringLiteral(ast::ExprStringLiteral { value, .. })] = args else {
+    let [Expr::Constant(ast::ExprConstant {
+        value: Constant::Str(value),
+        ..
+    })] = args
+    else {
        return;
    };

--- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/unreliable_callable_check.rs
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/unreliable_callable_check.rs
@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::{self as ast, Constant, Expr};

 use ruff_diagnostics::{Diagnostic, Edit, Fix, FixAvailability, Violation};
 use ruff_macros::{derive_message_formats, violation};
@@ -67,7 +67,11 @@ pub(crate) fn unreliable_callable_check(
    let [obj, attr, ..] = args else {
        return;
    };
-    let Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) = attr else {
+    let Expr::Constant(ast::ExprConstant {
+        value: Constant::Str(ast::StringConstant { value, .. }),
+        ..
+    }) = attr
+    else {
        return;
    };
    if value != "__call__" {
--- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/useless_comparison.rs
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/useless_comparison.rs
@@ -32,8 +32,8 @@ impl Violation for UselessComparison {
    #[derive_message_formats]
    fn message(&self) -> String {
        format!(
-            "Pointless comparison. Did you mean to assign a value? \
-             Otherwise, prepend `assert` or remove it."
+            "Pointless comparison. This comparison does nothing but waste CPU instructions. \
+             Either prepend `assert` or remove it."
        )
    }
 }
--- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/useless_expression.rs
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/useless_expression.rs
@@ -1,7 +1,7 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::helpers::contains_effect;
-use ruff_python_ast::Expr;
+use ruff_python_ast::{self as ast, Constant, Expr};
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -54,7 +54,11 @@ pub(crate) fn useless_expression(checker: &mut Checker, value: &Expr) {
    // Ignore strings, to avoid false positives with docstrings.
    if matches!(
        value,
-        Expr::FString(_) | Expr::StringLiteral(_) | Expr::EllipsisLiteral(_)
+        Expr::FString(_)
+            | Expr::Constant(ast::ExprConstant {
+                value: Constant::Str(..) | Constant::Ellipsis,
+                ..
+            })
    ) {
        return;
    }
--- a/crates/ruff_linter/src/rules/flake8_bugbear/rules/zip_without_explicit_strict.rs
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/rules/zip_without_explicit_strict.rs
@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-
+use ruff_python_ast::helpers::is_const_none;
 use ruff_python_ast::{self as ast, Arguments, Expr};
 use ruff_python_semantic::SemanticModel;
 use ruff_text_size::Ranged;
@@ -81,14 +81,14 @@ fn is_infinite_iterator(arg: &Expr, semantic: &SemanticModel) -> bool {
                }

                // Ex) `itertools.repeat(1, None)`
-                if args.len() == 2 && args[1].is_none_literal_expr() {
+                if args.len() == 2 && is_const_none(&args[1]) {
                    return true;
                }

                // Ex) `iterools.repeat(1, times=None)`
                for keyword in keywords {
                    if keyword.arg.as_ref().is_some_and(|name| name == "times") {
-                        if keyword.value.is_none_literal_expr() {
+                        if is_const_none(&keyword.value) {
                            return true;
                        }
                    }
--- a/crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linterrulesflake8_bugbeartestsB015_B015.py.snap
+++ b/crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linterrulesflake8_bugbeartestsB015_B015.py.snap
@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_bugbear/mod.rs
 ---
-B015.py:3:1: B015 Pointless comparison. Did you mean to assign a value? Otherwise, prepend `assert` or remove it.
+B015.py:3:1: B015 Pointless comparison. This comparison does nothing but waste CPU instructions. Either prepend `assert` or remove it.
  |
 1 | assert 1 == 1
 2 | 
@@ -11,7 +11,7 @@ B015.py:3:1: B015 Pointless comparison. Did you mean to assign a value? Otherwis
 5 | assert 1 in (1, 2)
  |

-B015.py:7:1: B015 Pointless comparison. Did you mean to assign a value? Otherwise, prepend `assert` or remove it.
+B015.py:7:1: B015 Pointless comparison. This comparison does nothing but waste CPU instructions. Either prepend `assert` or remove it.
  |
 5 | assert 1 in (1, 2)
 6 | 
@@ -19,7 +19,7 @@ B015.py:7:1: B015 Pointless comparison. Did you mean to assign a value? Otherwis
  | ^^^^^^^^^^^ B015
  |

-B015.py:17:5: B015 Pointless comparison. Did you mean to assign a value? Otherwise, prepend `assert` or remove it.
+B015.py:17:5: B015 Pointless comparison. This comparison does nothing but waste CPU instructions. Either prepend `assert` or remove it.
   |
 15 |     assert 1 in (1, 2)
 16 | 
@@ -27,7 +27,7 @@ B015.py:17:5: B015 Pointless comparison. Did you mean to assign a value? Otherwi
   |     ^^^^^^^^^^^ B015
   |

-B015.py:24:5: B015 Pointless comparison. Did you mean to assign a value? Otherwise, prepend `assert` or remove it.
+B015.py:24:5: B015 Pointless comparison. This comparison does nothing but waste CPU instructions. Either prepend `assert` or remove it.
   |
 23 | class TestClass:
 24 |     1 == 1
--- a/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_subscript_reversal.rs
+++ b/crates/ruff_linter/src/rules/flake8_comprehensions/rules/unnecessary_subscript_reversal.rs
@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Expr, UnaryOp};
+use ruff_python_ast::{self as ast, Constant, Expr, UnaryOp};
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -79,8 +79,8 @@ pub(crate) fn unnecessary_subscript_reversal(checker: &mut Checker, call: &ast::
    else {
        return;
    };
-    let Expr::NumberLiteral(ast::ExprNumberLiteral {
-        value: ast::Number::Int(val),
+    let Expr::Constant(ast::ExprConstant {
+        value: Constant::Int(val),
        ..
    }) = operand.as_ref()
    else {
--- a/crates/ruff_linter/src/rules/flake8_datetimez/rules/call_datetime_fromtimestamp.rs
+++ b/crates/ruff_linter/src/rules/flake8_datetimez/rules/call_datetime_fromtimestamp.rs
@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-
+use ruff_python_ast::helpers::is_const_none;
 use ruff_python_ast::{self as ast};
 use ruff_text_size::Ranged;

@@ -86,7 +86,7 @@ pub(crate) fn call_datetime_fromtimestamp(checker: &mut Checker, call: &ast::Exp
    }

    // none args
-    if call.arguments.args.len() > 1 && call.arguments.args[1].is_none_literal_expr() {
+    if call.arguments.args.len() > 1 && is_const_none(&call.arguments.args[1]) {
        checker
            .diagnostics
            .push(Diagnostic::new(CallDatetimeFromtimestamp, call.range()));
--- a/crates/ruff_linter/src/rules/flake8_datetimez/rules/call_datetime_now_without_tzinfo.rs
+++ b/crates/ruff_linter/src/rules/flake8_datetimez/rules/call_datetime_now_without_tzinfo.rs
@@ -1,7 +1,7 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::helpers::is_const_none;
+use ruff_python_ast::{self as ast};
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -77,12 +77,7 @@ pub(crate) fn call_datetime_now_without_tzinfo(checker: &mut Checker, call: &ast
    }

    // none args
-    if call
-        .arguments
-        .args
-        .first()
-        .is_some_and(Expr::is_none_literal_expr)
-    {
+    if call.arguments.args.first().is_some_and(is_const_none) {
        checker
            .diagnostics
            .push(Diagnostic::new(CallDatetimeNowWithoutTzinfo, call.range()));
--- a/crates/ruff_linter/src/rules/flake8_datetimez/rules/call_datetime_strptime_without_zone.rs
+++ b/crates/ruff_linter/src/rules/flake8_datetimez/rules/call_datetime_strptime_without_zone.rs
@@ -1,6 +1,6 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::{self as ast, Constant, Expr};
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -75,8 +75,10 @@ pub(crate) fn call_datetime_strptime_without_zone(checker: &mut Checker, call: &
    }

    // Does the `strptime` call contain a format string with a timezone specifier?
-    if let Some(Expr::StringLiteral(ast::ExprStringLiteral { value: format, .. })) =
-        call.arguments.args.get(1).as_ref()
+    if let Some(Expr::Constant(ast::ExprConstant {
+        value: Constant::Str(format),
+        range: _,
+    })) = call.arguments.args.get(1).as_ref()
    {
        if format.contains("%z") {
            return;
--- a/crates/ruff_linter/src/rules/flake8_datetimez/rules/call_datetime_without_tzinfo.rs
+++ b/crates/ruff_linter/src/rules/flake8_datetimez/rules/call_datetime_without_tzinfo.rs
@@ -1,7 +1,7 @@
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
-
-use ruff_python_ast::{self as ast, Expr};
+use ruff_python_ast::helpers::is_const_none;
+use ruff_python_ast::{self as ast};
 use ruff_text_size::Ranged;

 use crate::checkers::ast::Checker;
@@ -73,12 +73,7 @@ pub(crate) fn call_datetime_without_tzinfo(checker: &mut Checker, call: &ast::Ex
    }

    // Positional arg: is constant None.
-    if call
-        .arguments
-        .args
-        .get(7)
-        .is_some_and(Expr::is_none_literal_expr)
-    {
+    if call.arguments.args.get(7).is_some_and(is_const_none) {
        checker
            .diagnostics
            .push(Diagnostic::new(CallDatetimeWithoutTzinfo, call.range()));
--- a/crates/ruff_linter/src/rules/flake8_datetimez/rules/helpers.rs
+++ b/crates/ruff_linter/src/rules/flake8_datetimez/rules/helpers.rs
@@ -1,3 +1,4 @@
+use ruff_python_ast::helpers::is_const_none;
 use ruff_python_ast::{Arguments, Expr, ExprAttribute};

 use crate::checkers::ast::Checker;
@@ -14,5 +15,5 @@ pub(super) fn parent_expr_is_astimezone(checker: &Checker) -> bool {
 pub(super) fn has_non_none_keyword(arguments: &Arguments, keyword: &str) -> bool {
    arguments
        .find_keyword(keyword)
-        .is_some_and(|keyword| !keyword.value.is_none_literal_expr())
+        .is_some_and(|keyword| !is_const_none(&keyword.value))
 }
--- a/crates/ruff_linter/src/rules/flake8_django/rules/all_with_model_form.rs
+++ b/crates/ruff_linter/src/rules/flake8_django/rules/all_with_model_form.rs
@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Arguments, Expr, Stmt};
+use ruff_python_ast::{self as ast, Arguments, Constant, Expr, Stmt};

 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
@@ -80,13 +80,16 @@ pub(crate) fn all_with_model_form(
                if id != "fields" {
                    continue;
                }
-                match value.as_ref() {
-                    Expr::StringLiteral(ast::ExprStringLiteral { value, .. }) => {
+                let Expr::Constant(ast::ExprConstant { value, .. }) = value.as_ref() else {
+                    continue;
+                };
+                match value {
+                    Constant::Str(ast::StringConstant { value, .. }) => {
                        if value == "__all__" {
                            return Some(Diagnostic::new(DjangoAllWithModelForm, element.range()));
                        }
                    }
-                    Expr::BytesLiteral(ast::ExprBytesLiteral { value, .. }) => {
+                    Constant::Bytes(ast::BytesConstant { value, .. }) => {
                        if value == "__all__".as_bytes() {
                            return Some(Diagnostic::new(DjangoAllWithModelForm, element.range()));
                        }
--- a/crates/ruff_linter/src/rules/flake8_errmsg/rules/string_in_exception.rs
+++ b/crates/ruff_linter/src/rules/flake8_errmsg/rules/string_in_exception.rs
@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Arguments, Expr, ExprContext, Stmt};
+use ruff_python_ast::{self as ast, Arguments, Constant, Expr, ExprContext, Stmt};
 use ruff_text_size::{Ranged, TextRange};

 use ruff_diagnostics::{Diagnostic, Edit, Fix, FixAvailability, Violation};
@@ -182,7 +182,10 @@ pub(crate) fn string_in_exception(checker: &mut Checker, stmt: &Stmt, exc: &Expr
        if let Some(first) = args.first() {
            match first {
                // Check for string literals.
-                Expr::StringLiteral(ast::ExprStringLiteral { value: string, .. }) => {
+                Expr::Constant(ast::ExprConstant {
+                    value: Constant::Str(string),
+                    ..
+                }) => {
                    if checker.enabled(Rule::RawStringInException) {
                        if string.len() >= checker.settings.flake8_errmsg.max_string_length {
                            let mut diagnostic =
@@ -229,7 +232,7 @@ pub(crate) fn string_in_exception(checker: &mut Checker, stmt: &Stmt, exc: &Expr
                        if let Expr::Attribute(ast::ExprAttribute { value, attr, .. }) =
                            func.as_ref()
                        {
-                            if attr == "format" && value.is_literal_expr() {
+                            if attr == "format" && value.is_constant_expr() {
                                let mut diagnostic =
                                    Diagnostic::new(DotFormatInException, first.range());
                                if let Some(indentation) =
--- a/crates/ruff_linter/src/rules/flake8_gettext/rules/printf_in_gettext_func_call.rs
+++ b/crates/ruff_linter/src/rules/flake8_gettext/rules/printf_in_gettext_func_call.rs
@@ -1,4 +1,4 @@
-use ruff_python_ast::{self as ast, Expr, Operator};
+use ruff_python_ast::{self as ast, Constant, Expr, Operator};

 use crate::checkers::ast::Checker;
 use ruff_diagnostics::{Diagnostic, Violation};
@@ -58,7 +58,11 @@ pub(crate) fn printf_in_gettext_func_call(checker: &mut Checker, args: &[Expr])
            ..
        }) = &first
        {
-            if left.is_string_literal_expr() {
+            if let Expr::Constant(ast::ExprConstant {
+                value: Constant::Str(_),
+                ..
+            }) = left.as_ref()
+            {
                checker
                    .diagnostics
                    .push(Diagnostic::new(PrintfInGetTextFuncCall {}, first.range()));
--- a/Show More
+++ b/Show More