remove obsolete comment

## Summary

`cargo build --release` currently fails to compile on `main`:

<details>

```
error[E0599]: no method named `hit` found for struct `ReleaseStatistics` in the current scope
   --> crates/red_knot/src/cache.rs:22:29
    |
22  |             self.statistics.hit();
    |                             ^^^ method not found in `ReleaseStatistics`
...
145 | pub struct ReleaseStatistics;
    | ---------------------------- method `hit` not found for this struct

error[E0599]: no method named `miss` found for struct `ReleaseStatistics` in the current scope
   --> crates/red_knot/src/cache.rs:25:29
    |
25  |             self.statistics.miss();
    |                             ^^^^ method not found in `ReleaseStatistics`
...
145 | pub struct ReleaseStatistics;
    | ---------------------------- method `miss` not found for this struct

error[E0599]: no method named `hit` found for struct `ReleaseStatistics` in the current scope
   --> crates/red_knot/src/cache.rs:36:33
    |
36  |                 self.statistics.hit();
    |                                 ^^^ method not found in `ReleaseStatistics`
...
145 | pub struct ReleaseStatistics;
    | ---------------------------- method `hit` not found for this struct

error[E0599]: no method named `miss` found for struct `ReleaseStatistics` in the current scope
   --> crates/red_knot/src/cache.rs:41:33
    |
41  |                 self.statistics.miss();
    |                                 ^^^^ method not found in `ReleaseStatistics`
...
145 | pub struct ReleaseStatistics;
    | ---------------------------- method `miss` not found for this struct
```

</details>

This is because in a release build, `CacheStatistics` is a type alias
for `ReleaseStatistics`, and `ReleaseStatistics` doesn't have `hit()` or
`miss()` methods. (In a debug build, `CacheStatistics` is a type alias
for `DebugStatistics`, which _does_ have those methods.)

Possibly we could make this less likely to happen in the future by
making both structs implement a common trait instead of using type
aliases that vary depending on whether it's a debug build or not? For
now, though, this PR just brings the two structs in sync w.r.t. the
methods they expose.

## Test Plan

`cargo build --release` now once again compiles for me locally

.config/nextest.toml

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

.gitattributes

@@ -2,9 +2,13 @@
 
 crates/ruff_linter/resources/test/fixtures/isort/line_ending_crlf.py text eol=crlf
 crates/ruff_linter/resources/test/fixtures/pycodestyle/W605_1.py text eol=crlf
+crates/ruff_linter/resources/test/fixtures/pycodestyle/W391_2.py text eol=crlf
+crates/ruff_linter/resources/test/fixtures/pycodestyle/W391_3.py text eol=crlf
 
 crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples_crlf.py text eol=crlf
 crates/ruff_python_formatter/tests/snapshots/format@docstring_code_examples_crlf.py.snap text eol=crlf
 
+crates/ruff_python_parser/resources/inline linguist-generated=true
+
 ruff.schema.json linguist-generated=true text=auto eol=lf
 *.md.snap linguist-language=Markdown

.github/CODEOWNERS

@@ -5,5 +5,13 @@
 # - The '*' pattern is global owners.
 # - Order is important. The last matching pattern has the most precedence.
 
-# Jupyter
-/crates/ruff_linter/src/jupyter/ @dhruvmanila
+/crates/ruff_notebook/ @dhruvmanila
+/crates/ruff_formatter/ @MichaReiser
+/crates/ruff_python_formatter/ @MichaReiser
+/crates/ruff_python_parser/ @MichaReiser @dhruvmanila
+
+# flake8-pyi
+/crates/ruff_linter/src/rules/flake8_pyi/ @AlexWaygood
+
+# Script for fuzzing the parser
+/scripts/fuzz-parser/ @AlexWaygood

.github/ISSUE_TEMPLATE.md

@@ -3,6 +3,8 @@ Thank you for taking the time to report an issue! We're glad to have you involve
 
 If you're filing a bug report, please consider including the following information:
 
+* List of keywords you searched for before creating this issue. Write them down here so that others can find this issue more easily and help provide feedback.
+  e.g. "RUF001", "unused variable", "Jupyter notebook"
 * A minimal code snippet that reproduces the bug.
 * The command you invoked (e.g., `ruff /path/to/file.py --fix`), ideally including the `--isolated` flag.
 * The current Ruff settings (any relevant sections from your `pyproject.toml`).

.github/dependabot.yml

@@ -1,21 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    labels: ["internal"]
-    groups:
-      actions:
-        patterns:
-          - "*"
-    ignore:
-      # The latest versions of these are not compatible with our release workflow
-      - dependency-name: "actions/upload-artifact"
-      - dependency-name: "actions/download-artifact"
-
-  - package-ecosystem: "cargo"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    labels: ["internal"]

.github/renovate.json5

@@ -0,0 +1,68 @@
+{
+  $schema: "https://docs.renovatebot.com/renovate-schema.json",
+  dependencyDashboard: true,
+  suppressNotifications: ["prEditedNotification"],
+  extends: ["config:recommended"],
+  labels: ["internal"],
+  schedule: ["before 4am on Monday"],
+  semanticCommits: "disabled",
+  separateMajorMinor: false,
+  prHourlyLimit: 10,
+  enabledManagers: ["github-actions", "pre-commit", "cargo", "pep621", "npm"],
+  cargo: {
+    // See https://docs.renovatebot.com/configuration-options/#rangestrategy
+    rangeStrategy: "update-lockfile",
+  },
+  pep621: {
+    fileMatch: ["^(python|scripts)/.*pyproject\\.toml$"],
+  },
+  npm: {
+    fileMatch: ["^playground/.*package\\.json$"],
+  },
+  "pre-commit": {
+    enabled: true,
+  },
+  packageRules: [
+    {
+      // Group upload/download artifact updates, the versions are dependent
+      groupName: "Artifact GitHub Actions dependencies",
+      matchManagers: ["github-actions"],
+      matchPackagePatterns: ["actions/.*-artifact"],
+      description: "Weekly update of artifact-related GitHub Actions dependencies",
+    },
+    {
+      groupName: "pre-commit dependencies",
+      matchManagers: ["pre-commit"],
+      description: "Weekly update of pre-commit dependencies",
+    },
+    {
+      groupName: "NPM Development dependencies",
+      matchManagers: ["npm"],
+      matchDepTypes: ["devDependencies"],
+      description: "Weekly update of NPM development dependencies",
+    },
+    {
+      groupName: "Monaco",
+      matchManagers: ["npm"],
+      matchPackagePatterns: ["monaco"],
+      description: "Weekly update of the Monaco editor",
+    },
+    {
+      groupName: "strum",
+      matchManagers: ["cargo"],
+      matchPackagePatterns: ["strum"],
+      description: "Weekly update of strum dependencies",
+    },
+    {
+      groupName: "ESLint",
+      matchManagers: ["npm"],
+      matchPackageNames: ["eslint"],
+      allowedVersions: "<9",
+      description: "Constraint ESLint to version 8 until TypeScript-eslint supports ESLint 9", // https://github.com/typescript-eslint/typescript-eslint/issues/8211
+    },
+  ],
+  vulnerabilityAlerts: {
+    commitMessageSuffix: "",
+    labels: ["internal", "security"],
+  },
+}

.github/workflows/ci.yaml

@@ -23,6 +23,8 @@ jobs:
     name: "Determine changes"
     runs-on: ubuntu-latest
     outputs:
+      # Flag that is raised when any code that affects parser is changed
+      parser: ${{ steps.changed.outputs.parser_any_changed }}
       # Flag that is raised when any code that affects linter is changed
       linter: ${{ steps.changed.outputs.linter_any_changed }}
       # Flag that is raised when any code that affects formatter is changed
@@ -35,10 +37,21 @@ jobs:
         with:
           fetch-depth: 0
 
-      - uses: tj-actions/changed-files@v42
+      - uses: tj-actions/changed-files@v44
         id: changed
         with:
           files_yaml: |
+            parser:
+              - Cargo.toml
+              - Cargo.lock
+              - crates/ruff_python_trivia/**
+              - crates/ruff_source_file/**
+              - crates/ruff_text_size/**
+              - crates/ruff_python_ast/**
+              - crates/ruff_python_parser/**
+              - scripts/fuzz-parser/**
+              - .github/workflows/ci.yaml
+
             linter:
               - Cargo.toml
               - Cargo.lock
@@ -111,22 +124,29 @@ jobs:
       - uses: actions/checkout@v4
       - name: "Install Rust toolchain"
         run: rustup show
+      - name: "Install mold"
+        uses: rui314/setup-mold@v1
+      - name: "Install cargo nextest"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-nextest
       - name: "Install cargo insta"
         uses: taiki-e/install-action@v2
         with:
           tool: cargo-insta
       - uses: Swatinem/rust-cache@v2
       - name: "Run tests"
-        run: cargo insta test --all --exclude ruff_dev --all-features --unreferenced reject
-      - name: "Run dev tests"
-        # e.g. generating the schema — these should not run with all features enabled
-        run: cargo insta test -p ruff_dev --unreferenced reject
+        shell: bash
+        env:
+          NEXTEST_PROFILE: "ci"
+        run: cargo insta test --all-features --unreferenced reject --test-runner nextest
+
       # Check for broken links in the documentation.
       - run: cargo doc --all --no-deps
         env:
           # Setting RUSTDOCFLAGS because `cargo doc --check` isn't yet implemented (https://github.com/rust-lang/cargo/issues/10025).
           RUSTDOCFLAGS: "-D warnings"
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: ruff
           path: target/debug/ruff
@@ -141,15 +161,16 @@ jobs:
       - uses: actions/checkout@v4
       - name: "Install Rust toolchain"
         run: rustup show
-      - name: "Install cargo insta"
+      - name: "Install cargo nextest"
         uses: taiki-e/install-action@v2
         with:
-          tool: cargo-insta
+          tool: cargo-nextest
       - uses: Swatinem/rust-cache@v2
       - name: "Run tests"
         shell: bash
-        # We can't reject unreferenced snapshots on windows because flake8_executable can't run on windows
-        run: cargo insta test --all --exclude ruff_dev --all-features
+        run: |
+          cargo nextest run --all-features --profile ci
+          cargo test --all-features --doc
 
   cargo-test-wasm:
     name: "cargo test (wasm)"
@@ -192,6 +213,38 @@ jobs:
           tool: cargo-fuzz@0.11.2
       - run: cargo fuzz build -s none
 
+  fuzz-parser:
+    name: "Fuzz the parser"
+    runs-on: ubuntu-latest
+    needs:
+      - cargo-test-linux
+      - determine_changes
+    if: ${{ needs.determine_changes.outputs.parser == 'true' }}
+    timeout-minutes: 20
+    env:
+      FORCE_COLOR: 1
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Install uv
+        run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - name: Install Python requirements
+        run: uv pip install -r scripts/fuzz-parser/requirements.txt --system
+      - uses: actions/download-artifact@v4
+        name: Download Ruff binary to test
+        id: download-cached-binary
+        with:
+          name: ruff
+          path: ruff-to-test
+      - name: Fuzz
+        run: |
+          # Make executable, since artifact download doesn't preserve this
+          chmod +x ${{ steps.download-cached-binary.outputs.download-path }}/ruff
+
+          python scripts/fuzz-parser/fuzz.py 0-500 --test-executable ${{ steps.download-cached-binary.outputs.download-path }}/ruff
+
   scripts:
     name: "test scripts"
     runs-on: ubuntu-latest
@@ -220,9 +273,7 @@ jobs:
       - determine_changes
     # Only runs on pull requests, since that is the only we way we can find the base version for comparison.
     # Ecosystem check needs linter and/or formatter changes.
-    if: github.event_name == 'pull_request' && ${{
-      needs.determine_changes.outputs.code == 'true'
-      }}
+    if: ${{ github.event_name == 'pull_request' && needs.determine_changes.outputs.code == 'true' }}
     timeout-minutes: 20
     steps:
       - uses: actions/checkout@v4
@@ -230,7 +281,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         name: Download comparison Ruff binary
         id: ruff-target
         with:
@@ -242,6 +293,7 @@ jobs:
         with:
           name: ruff
           branch: ${{ github.event.pull_request.base.ref }}
+          workflow: "ci.yaml"
           check_artifacts: true
 
       - name: Install ruff-ecosystem
@@ -316,13 +368,13 @@ jobs:
         run: |
           echo ${{ github.event.number }} > pr-number
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         name: Upload PR Number
         with:
           name: pr-number
           path: pr-number
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         name: Upload Results
         with:
           name: ecosystem-result
@@ -410,7 +462,7 @@ jobs:
       - uses: actions/setup-python@v5
       - name: "Add SSH key"
         if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        uses: webfactory/ssh-agent@v0.8.0
+        uses: webfactory/ssh-agent@v0.9.0
         with:
           ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
       - name: "Install Rust toolchain"
@@ -463,7 +515,7 @@ jobs:
       - determine_changes
     if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
     steps:
-      - uses: extractions/setup-just@v1
+      - uses: extractions/setup-just@v2
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -476,7 +528,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         name: Download development ruff binary
         id: ruff-target
         with:
@@ -500,7 +552,7 @@ jobs:
   benchmarks:
     runs-on: ubuntu-latest
     needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
+    if: ${{ github.repository == 'astral-sh/ruff' && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
     timeout-minutes: 20
     steps:
       - name: "Checkout Branch"

.github/workflows/docs.yaml

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

.github/workflows/release.yaml

@@ -52,13 +52,13 @@ jobs:
           ruff --help
           python -m ruff --help
       - name: "Upload sdist"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-sdist
           path: dist
 
   macos-x86_64:
-    runs-on: macos-14
+    runs-on: macos-12
     steps:
       - uses: actions/checkout@v4
         with:
@@ -74,10 +74,15 @@ jobs:
         with:
           target: x86_64
           args: --release --locked --out dist
+      - name: "Test wheel - x86_64"
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+          ruff --help
+          python -m ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-macos-x86_64
           path: dist
       - name: "Archive binary"
         run: |
@@ -85,14 +90,14 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/x86_64-apple-darwin/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-macos-x86_64
           path: |
             *.tar.gz
             *.sha256
 
-  macos-universal:
+  macos-aarch64:
     runs-on: macos-14
     steps:
       - uses: actions/checkout@v4
@@ -101,22 +106,23 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
+          architecture: arm64
       - name: "Prep README.md"
         run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels - universal2"
+      - name: "Build wheels - aarch64"
         uses: PyO3/maturin-action@v1
         with:
-          args: --release --locked --target universal2-apple-darwin --out dist
-      - name: "Test wheel - universal2"
+          target: aarch64
+          args: --release --locked --out dist
+      - name: "Test wheel - aarch64"
         run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*universal2.whl --force-reinstall
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
           ruff --help
           python -m ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-aarch64-apple-darwin
           path: dist
       - name: "Archive binary"
         run: |
@@ -124,9 +130,9 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/aarch64-apple-darwin/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-aarch64-apple-darwin
           path: |
             *.tar.gz
             *.sha256
@@ -165,9 +171,9 @@ jobs:
           ruff --help
           python -m ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ matrix.platform.target }}
           path: dist
       - name: "Archive binary"
         shell: bash
@@ -176,9 +182,9 @@ jobs:
           7z a $ARCHIVE_FILE ./target/${{ matrix.platform.target }}/release/ruff.exe
           sha256sum $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-${{ matrix.platform.target }}
           path: |
             *.zip
             *.sha256
@@ -213,9 +219,9 @@ jobs:
           ruff --help
           python -m ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ matrix.target }}
           path: dist
       - name: "Archive binary"
         run: |
@@ -223,9 +229,9 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/${{ matrix.target }}/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-${{ matrix.target }}
           path: |
             *.tar.gz
             *.sha256
@@ -246,8 +252,12 @@ jobs:
             arch: s390x
           - target: powerpc64le-unknown-linux-gnu
             arch: ppc64le
+            # see https://github.com/astral-sh/ruff/issues/10073
+            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
           - target: powerpc64-unknown-linux-gnu
             arch: ppc64
+            # see https://github.com/astral-sh/ruff/issues/10073
+            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
 
     steps:
       - uses: actions/checkout@v4
@@ -280,9 +290,9 @@ jobs:
             pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
             ruff --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ matrix.platform.target }}
           path: dist
       - name: "Archive binary"
         run: |
@@ -290,9 +300,9 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/${{ matrix.platform.target }}/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-${{ matrix.platform.target }}
           path: |
             *.tar.gz
             *.sha256
@@ -332,9 +342,9 @@ jobs:
             .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
             .venv/bin/ruff check --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ matrix.target }}
           path: dist
       - name: "Archive binary"
         run: |
@@ -342,9 +352,9 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/${{ matrix.target }}/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-${{ matrix.target }}
           path: |
             *.tar.gz
             *.sha256
@@ -389,9 +399,9 @@ jobs:
             .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
             .venv/bin/ruff check --help
       - name: "Upload wheels"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: wheels
+          name: wheels-${{ matrix.platform.target }}
           path: dist
       - name: "Archive binary"
         run: |
@@ -399,9 +409,9 @@ jobs:
           tar czvf $ARCHIVE_FILE -C target/${{ matrix.platform.target }}/release ruff
           shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
       - name: "Upload binary"
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
-          name: binaries
+          name: binaries-${{ matrix.platform.target }}
           path: |
             *.tar.gz
             *.sha256
@@ -442,7 +452,7 @@ jobs:
     name: Upload to PyPI
     runs-on: ubuntu-latest
     needs:
-      - macos-universal
+      - macos-aarch64
       - macos-x86_64
       - windows
       - linux
@@ -458,10 +468,11 @@ jobs:
       # For pypi trusted publishing
       id-token: write
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: wheels
+          pattern: wheels-*
           path: wheels
+          merge-multiple: true
       - name: Publish to PyPi
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
@@ -501,12 +512,13 @@ jobs:
       # For GitHub release publishing
       contents: write
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: binaries
+          pattern: binaries-*
           path: binaries
+          merge-multiple: true
       - name: "Publish to GitHub"
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         with:
           draft: true
           files: binaries/*

.gitignore

@@ -92,6 +92,7 @@ coverage.xml
 .hypothesis/
 .pytest_cache/
 cover/
+repos/
 
 # Translations
 *.mo

.markdownlint.yaml

@@ -17,4 +17,4 @@ MD013: false
 # MD024/no-duplicate-heading
 MD024:
   # Allow when nested under different parents e.g. CHANGELOG.md
-  allow_different_nesting: true
+  siblings_only: true

.pre-commit-config.yaml

@@ -13,7 +13,7 @@ exclude: |
 
 repos:
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.15
+    rev: v0.16
     hooks:
       - id: validate-pyproject
 
@@ -31,7 +31,7 @@ repos:
           )$
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.37.0
+    rev: v0.39.0
     hooks:
       - id: markdownlint-fix
         exclude: |
@@ -41,7 +41,7 @@ repos:
           )$
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.16.22
+    rev: v1.20.9
     hooks:
       - id: typos
 
@@ -55,7 +55,7 @@ repos:
         pass_filenames: false # This makes it a lot faster
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.1.4
+    rev: v0.4.1
     hooks:
       - id: ruff-format
       - id: ruff
@@ -70,7 +70,7 @@ repos:
 
   # Prettier
   - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v3.0.3
+    rev: v3.1.0
     hooks:
       - id: prettier
         types: [yaml]

BREAKING_CHANGES.md

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

CHANGELOG.md

@@ -1,5 +1,706 @@
 # Changelog
 
+## 0.4.2
+
+### Rule changes
+
+- \[`flake8-pyi`\] Allow for overloaded `__exit__` and `__aexit__` definitions (`PYI036`) ([#11057](https://github.com/astral-sh/ruff/pull/11057))
+- \[`pyupgrade`\] Catch usages of `"%s" % var` and provide an unsafe fix (`UP031`) ([#11019](https://github.com/astral-sh/ruff/pull/11019))
+- \[`refurb`\] Implement new rule that suggests min/max over `sorted()` (`FURB192`) ([#10868](https://github.com/astral-sh/ruff/pull/10868))
+
+### Server
+
+- Fix an issue with missing diagnostics for Neovim and Helix ([#11092](https://github.com/astral-sh/ruff/pull/11092))
+- Implement hover documentation for `noqa` codes ([#11096](https://github.com/astral-sh/ruff/pull/11096))
+- Introduce common Ruff configuration options with new server settings ([#11062](https://github.com/astral-sh/ruff/pull/11062))
+
+### Bug fixes
+
+- Use `macos-12` for building release wheels to enable macOS 11 compatibility ([#11146](https://github.com/astral-sh/ruff/pull/11146))
+- \[`flake8-blind-expect`\] Allow raise from in `BLE001` ([#11131](https://github.com/astral-sh/ruff/pull/11131))
+- \[`flake8-pyi`\] Allow simple assignments to `None` in enum class scopes (`PYI026`) ([#11128](https://github.com/astral-sh/ruff/pull/11128))
+- \[`flake8-simplify`\] Avoid raising `SIM911` for non-`zip` attribute calls ([#11126](https://github.com/astral-sh/ruff/pull/11126))
+- \[`refurb`\] Avoid `operator.itemgetter` suggestion for single-item tuple ([#11095](https://github.com/astral-sh/ruff/pull/11095))
+- \[`ruff`\] Respect per-file-ignores for `RUF100` with no other diagnostics ([#11058](https://github.com/astral-sh/ruff/pull/11058))
+- \[`ruff`\] Fix async comprehension false positive (`RUF029`) ([#11070](https://github.com/astral-sh/ruff/pull/11070))
+
+### Documentation
+
+- \[`flake8-bugbear`\] Document explicitly disabling strict zip (`B905`) ([#11040](https://github.com/astral-sh/ruff/pull/11040))
+- \[`flake8-type-checking`\] Mention `lint.typing-modules` in `TCH001`, `TCH002`, and `TCH003` ([#11144](https://github.com/astral-sh/ruff/pull/11144))
+- \[`isort`\] Improve documentation around custom `isort` sections ([#11050](https://github.com/astral-sh/ruff/pull/11050))
+- \[`pylint`\] Fix documentation oversight for `invalid-X-returns` ([#11094](https://github.com/astral-sh/ruff/pull/11094))
+
+### Performance
+
+- Use `matchit` to resolve per-file settings ([#11111](https://github.com/astral-sh/ruff/pull/11111))
+
+## 0.4.1
+
+### Preview features
+
+- \[`pylint`\] Implement `invalid-hash-returned` (`PLE0309`) ([#10961](https://github.com/astral-sh/ruff/pull/10961))
+- \[`pylint`\] Implement `invalid-index-returned` (`PLE0305`) ([#10962](https://github.com/astral-sh/ruff/pull/10962))
+
+### Bug fixes
+
+- \[`pylint`\] Allow `NoReturn`-like functions for `__str__`, `__len__`, etc. (`PLE0307`) ([#11017](https://github.com/astral-sh/ruff/pull/11017))
+- Parser: Use empty range when there's "gap" in token source ([#11032](https://github.com/astral-sh/ruff/pull/11032))
+- \[`ruff`\] Ignore stub functions in `unused-async` (`RUF029`) ([#11026](https://github.com/astral-sh/ruff/pull/11026))
+- Parser: Expect indented case block instead of match stmt ([#11033](https://github.com/astral-sh/ruff/pull/11033))
+
+## 0.4.0
+
+### A new, hand-written parser
+
+Ruff's new parser is **>2x faster**, which translates to a **20-40% speedup** for all linting and formatting invocations.
+There's a lot to say about this exciting change, so check out the [blog post](https://astral.sh/blog/ruff-v0.4.0) for more details!
+
+See [#10036](https://github.com/astral-sh/ruff/pull/10036) for implementation details.
+
+### A new language server in Rust
+
+With this release, we also want to highlight our new language server. `ruff server` is a Rust-powered language
+server that comes built-in with Ruff. It can be used with any editor that supports the [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) (LSP).
+It uses a multi-threaded, lock-free architecture inspired by `rust-analyzer` and it will open the door for a lot
+of exciting features. It’s also faster than our previous [Python-based language server](https://github.com/astral-sh/ruff-lsp)
+-- but you probably guessed that already.
+
+`ruff server` is only in alpha, but it has a lot of features that you can try out today:
+
+- Lints Python files automatically and shows quick-fixes when available
+- Formats Python files, with support for range formatting
+- Comes with commands for quickly performing actions: `ruff.applyAutofix`, `ruff.applyFormat`, and `ruff.applyOrganizeImports`
+- Supports `source.fixAll` and `source.organizeImports` source actions
+- Automatically reloads your project configuration when you change it
+
+To setup `ruff server` with your editor, refer to the [README.md](https://github.com/astral-sh/ruff/blob/main/crates/ruff_server/README.md).
+
+### Preview features
+
+- \[`pycodestyle`\] Do not trigger `E3` rules on `def`s following a function/method with a dummy body ([#10704](https://github.com/astral-sh/ruff/pull/10704))
+- \[`pylint`\] Implement `invalid-bytes-returned` (`E0308`) ([#10959](https://github.com/astral-sh/ruff/pull/10959))
+- \[`pylint`\] Implement `invalid-length-returned` (`E0303`) ([#10963](https://github.com/astral-sh/ruff/pull/10963))
+- \[`pylint`\] Implement `self-cls-assignment` (`W0642`) ([#9267](https://github.com/astral-sh/ruff/pull/9267))
+- \[`pylint`\] Omit stubs from `invalid-bool` and `invalid-str-return-type` ([#11008](https://github.com/astral-sh/ruff/pull/11008))
+- \[`ruff`\] New rule `unused-async` (`RUF029`) to detect unneeded `async` keywords on functions ([#9966](https://github.com/astral-sh/ruff/pull/9966))
+
+### Rule changes
+
+- \[`flake8-bandit`\] Allow `urllib.request.urlopen` calls with static `Request` argument (`S310`) ([#10964](https://github.com/astral-sh/ruff/pull/10964))
+- \[`flake8-bugbear`\] Treat `raise NotImplemented`-only bodies as stub functions (`B006`) ([#10990](https://github.com/astral-sh/ruff/pull/10990))
+- \[`flake8-slots`\] Respect same-file `Enum` subclasses (`SLOT000`) ([#11006](https://github.com/astral-sh/ruff/pull/11006))
+- \[`pylint`\] Support inverted comparisons (`PLR1730`) ([#10920](https://github.com/astral-sh/ruff/pull/10920))
+
+### Linter
+
+- Improve handling of builtin symbols in linter rules ([#10919](https://github.com/astral-sh/ruff/pull/10919))
+- Improve display of rules in `--show-settings` ([#11003](https://github.com/astral-sh/ruff/pull/11003))
+- Improve inference capabilities of the `BuiltinTypeChecker` ([#10976](https://github.com/astral-sh/ruff/pull/10976))
+- Resolve classes and functions relative to script name ([#10965](https://github.com/astral-sh/ruff/pull/10965))
+- Improve performance of `RuleTable::any_enabled` ([#10971](https://github.com/astral-sh/ruff/pull/10971))
+
+### Server
+
+*This section is devoted to updates for our new language server, written in Rust.*
+
+- Enable ruff-specific source actions ([#10916](https://github.com/astral-sh/ruff/pull/10916))
+- Refreshes diagnostics for open files when file configuration is changed ([#10988](https://github.com/astral-sh/ruff/pull/10988))
+- Important errors are now shown as popups ([#10951](https://github.com/astral-sh/ruff/pull/10951))
+- Introduce settings for directly configuring the linter and formatter ([#10984](https://github.com/astral-sh/ruff/pull/10984))
+- Resolve configuration for each document individually ([#10950](https://github.com/astral-sh/ruff/pull/10950))
+- Write a setup guide for Neovim ([#10987](https://github.com/astral-sh/ruff/pull/10987))
+
+### Configuration
+
+- Add `RUFF_OUTPUT_FILE` environment variable support ([#10992](https://github.com/astral-sh/ruff/pull/10992))
+
+### Bug fixes
+
+- Avoid `non-augmented-assignment` for reversed, non-commutative operators (`PLR6104`) ([#10909](https://github.com/astral-sh/ruff/pull/10909))
+- Limit commutative non-augmented-assignments to primitive data types (`PLR6104`) ([#10912](https://github.com/astral-sh/ruff/pull/10912))
+- Respect `per-file-ignores` for `RUF100` on blanket `# noqa` ([#10908](https://github.com/astral-sh/ruff/pull/10908))
+- Consider `if` expression for parenthesized with items parsing ([#11010](https://github.com/astral-sh/ruff/pull/11010))
+- Consider binary expr for parenthesized with items parsing ([#11012](https://github.com/astral-sh/ruff/pull/11012))
+- Reset `FOR_TARGET` context for all kinds of parentheses ([#11009](https://github.com/astral-sh/ruff/pull/11009))
+
+## 0.3.7
+
+### Preview features
+
+- \[`flake8-bugbear`\] Implement `loop-iterator-mutation` (`B909`) ([#9578](https://github.com/astral-sh/ruff/pull/9578))
+- \[`pylint`\] Implement rule to prefer augmented assignment (`PLR6104`) ([#9932](https://github.com/astral-sh/ruff/pull/9932))
+
+### Bug fixes
+
+- Avoid TOCTOU errors in cache initialization ([#10884](https://github.com/astral-sh/ruff/pull/10884))
+- \[`pylint`\] Recode `nan-comparison` rule to `W0177` ([#10894](https://github.com/astral-sh/ruff/pull/10894))
+- \[`pylint`\] Reverse min-max logic in `if-stmt-min-max` ([#10890](https://github.com/astral-sh/ruff/pull/10890))
+
+## 0.3.6
+
+### Preview features
+
+- \[`pylint`\] Implement `bad-staticmethod-argument` (`PLW0211`) ([#10781](https://github.com/astral-sh/ruff/pull/10781))
+- \[`pylint`\] Implement `if-stmt-min-max` (`PLR1730`, `PLR1731`) ([#10002](https://github.com/astral-sh/ruff/pull/10002))
+- \[`pyupgrade`\] Replace `str,Enum` multiple inheritance with `StrEnum` `UP042` ([#10713](https://github.com/astral-sh/ruff/pull/10713))
+- \[`refurb`\] Implement `if-expr-instead-of-or-operator` (`FURB110`) ([#10687](https://github.com/astral-sh/ruff/pull/10687))
+- \[`refurb`\] Implement `int-on-sliced-str` (`FURB166`) ([#10650](https://github.com/astral-sh/ruff/pull/10650))
+- \[`refurb`\] Implement `write-whole-file` (`FURB103`) ([#10802](https://github.com/astral-sh/ruff/pull/10802))
+- \[`refurb`\] Support `itemgetter` in `reimplemented-operator` (`FURB118`) ([#10526](https://github.com/astral-sh/ruff/pull/10526))
+- \[`flake8_comprehensions`\] Add `sum`/`min`/`max` to unnecessary comprehension check (`C419`) ([#10759](https://github.com/astral-sh/ruff/pull/10759))
+
+### Rule changes
+
+- \[`pydocstyle`\] Require capitalizing docstrings where the first sentence is a single word (`D403`) ([#10776](https://github.com/astral-sh/ruff/pull/10776))
+- \[`pycodestyle`\] Ignore annotated lambdas in class scopes (`E731`) ([#10720](https://github.com/astral-sh/ruff/pull/10720))
+- \[`flake8-pyi`\] Various improvements to PYI034 ([#10807](https://github.com/astral-sh/ruff/pull/10807))
+- \[`flake8-slots`\] Flag subclasses of call-based `typing.NamedTuple`s as well as subclasses of `collections.namedtuple()` (`SLOT002`) ([#10808](https://github.com/astral-sh/ruff/pull/10808))
+- \[`pyflakes`\] Allow forward references in class bases in stub files (`F821`) ([#10779](https://github.com/astral-sh/ruff/pull/10779))
+- \[`pygrep-hooks`\] Improve `blanket-noqa` error message (`PGH004`) ([#10851](https://github.com/astral-sh/ruff/pull/10851))
+
+### CLI
+
+- Support `FORCE_COLOR` env var ([#10839](https://github.com/astral-sh/ruff/pull/10839))
+
+### Configuration
+
+- Support negated patterns in `[extend-]per-file-ignores` ([#10852](https://github.com/astral-sh/ruff/pull/10852))
+
+### Bug fixes
+
+- \[`flake8-import-conventions`\] Accept non-aliased (but correct) import in `unconventional-import-alias` (`ICN001`) ([#10729](https://github.com/astral-sh/ruff/pull/10729))
+- \[`flake8-quotes`\] Add semantic model flag when inside f-string replacement field ([#10766](https://github.com/astral-sh/ruff/pull/10766))
+- \[`pep8-naming`\] Recursively resolve `TypeDicts` for N815 violations ([#10719](https://github.com/astral-sh/ruff/pull/10719))
+- \[`flake8-quotes`\] Respect `Q00*` ignores in `flake8-quotes` rules ([#10728](https://github.com/astral-sh/ruff/pull/10728))
+- \[`flake8-simplify`\] Show negated condition in `needless-bool` diagnostics (`SIM103`) ([#10854](https://github.com/astral-sh/ruff/pull/10854))
+- \[`ruff`\] Use within-scope shadowed bindings in `asyncio-dangling-task` (`RUF006`) ([#10793](https://github.com/astral-sh/ruff/pull/10793))
+- \[`flake8-pytest-style`\] Fix single-tuple conversion in `pytest-parametrize-values-wrong-type` (`PT007`) ([#10862](https://github.com/astral-sh/ruff/pull/10862))
+- \[`flake8-return`\] Ignore assignments to annotated variables in `unnecessary-assign` (`RET504`) ([#10741](https://github.com/astral-sh/ruff/pull/10741))
+- \[`refurb`\] Do not allow any keyword arguments for `read-whole-file` in `rb` mode (`FURB101`) ([#10803](https://github.com/astral-sh/ruff/pull/10803))
+- \[`pylint`\] Don't recommend decorating staticmethods with `@singledispatch` (`PLE1519`, `PLE1520`) ([#10637](https://github.com/astral-sh/ruff/pull/10637))
+- \[`pydocstyle`\] Use section name range for all section-related docstring diagnostics ([#10740](https://github.com/astral-sh/ruff/pull/10740))
+- Respect `# noqa` directives on `__all__` openers ([#10798](https://github.com/astral-sh/ruff/pull/10798))
+
+## 0.3.5
+
+### Preview features
+
+- \[`pylint`\] Implement `modified-iterating-set` (`E4703`) ([#10473](https://github.com/astral-sh/ruff/pull/10473))
+- \[`refurb`\] Implement `for-loop-set-mutations` (`FURB142`) ([#10583](https://github.com/astral-sh/ruff/pull/10583))
+- \[`refurb`\] Implement `unnecessary-from-float` (`FURB164`) ([#10647](https://github.com/astral-sh/ruff/pull/10647))
+- \[`refurb`\] Implement `verbose-decimal-constructor` (`FURB157`) ([#10533](https://github.com/astral-sh/ruff/pull/10533))
+
+### Rule changes
+
+- \[`flake8-comprehensions`\] Handled special case for `C401` which also matches `C416` ([#10596](https://github.com/astral-sh/ruff/pull/10596))
+- \[`flake8-pyi`\] Mark `unaliased-collections-abc-set-import` fix as "safe" for more cases in stub files (`PYI025`) ([#10547](https://github.com/astral-sh/ruff/pull/10547))
+- \[`numpy`\] Add `row_stack` to NumPy 2.0 migration rule ([#10646](https://github.com/astral-sh/ruff/pull/10646))
+- \[`pycodestyle`\] Allow cell magics before an import (`E402`) ([#10545](https://github.com/astral-sh/ruff/pull/10545))
+- \[`pycodestyle`\] Avoid blank line rules for the first logical line in cell ([#10291](https://github.com/astral-sh/ruff/pull/10291))
+
+### Configuration
+
+- Respected nested namespace packages ([#10541](https://github.com/astral-sh/ruff/pull/10541))
+- \[`flake8-boolean-trap`\] Add setting for user defined allowed boolean trap ([#10531](https://github.com/astral-sh/ruff/pull/10531))
+
+### Bug fixes
+
+- Correctly handle references in `__all__` definitions when renaming symbols in autofixes ([#10527](https://github.com/astral-sh/ruff/pull/10527))
+- Track ranges of names inside `__all__` definitions ([#10525](https://github.com/astral-sh/ruff/pull/10525))
+- \[`flake8-bugbear`\] Avoid false positive for usage after `continue` (`B031`) ([#10539](https://github.com/astral-sh/ruff/pull/10539))
+- \[`flake8-copyright`\] Accept commas in default copyright pattern ([#9498](https://github.com/astral-sh/ruff/pull/9498))
+- \[`flake8-datetimez`\] Allow f-strings with `%z` for `DTZ007` ([#10651](https://github.com/astral-sh/ruff/pull/10651))
+- \[`flake8-pytest-style`\] Fix `PT014` autofix for last item in list ([#10532](https://github.com/astral-sh/ruff/pull/10532))
+- \[`flake8-quotes`\] Ignore `Q000`, `Q001` when string is inside forward ref ([#10585](https://github.com/astral-sh/ruff/pull/10585))
+- \[`isort`\] Always place non-relative imports after relative imports ([#10669](https://github.com/astral-sh/ruff/pull/10669))
+- \[`isort`\] Respect Unicode characters in import sorting ([#10529](https://github.com/astral-sh/ruff/pull/10529))
+- \[`pyflakes`\] Fix F821 false negatives when `from __future__ import annotations` is active (attempt 2) ([#10524](https://github.com/astral-sh/ruff/pull/10524))
+- \[`pyflakes`\] Make `unnecessary-lambda` an always-unsafe fix ([#10668](https://github.com/astral-sh/ruff/pull/10668))
+- \[`pylint`\] Fixed false-positive on the rule `PLW1641` (`eq-without-hash`) ([#10566](https://github.com/astral-sh/ruff/pull/10566))
+- \[`ruff`\] Fix panic in unused `# noqa` removal with multi-byte space (`RUF100`) ([#10682](https://github.com/astral-sh/ruff/pull/10682))
+
+### Documentation
+
+- Add PR title format to `CONTRIBUTING.md` ([#10665](https://github.com/astral-sh/ruff/pull/10665))
+- Fix list markup to include blank lines required ([#10591](https://github.com/astral-sh/ruff/pull/10591))
+- Put `flake8-logging` next to the other flake8 plugins in registry ([#10587](https://github.com/astral-sh/ruff/pull/10587))
+- \[`flake8-bandit`\] Update warning message for rule `S305` to address insecure block cipher mode use ([#10602](https://github.com/astral-sh/ruff/pull/10602))
+- \[`flake8-bugbear`\] Document use of anonymous assignment in `useless-expression` ([#10551](https://github.com/astral-sh/ruff/pull/10551))
+- \[`flake8-datetimez`\] Clarify error messages and docs for `DTZ` rules ([#10621](https://github.com/astral-sh/ruff/pull/10621))
+- \[`pycodestyle`\] Use same before vs. after numbers for `space-around-operator` ([#10640](https://github.com/astral-sh/ruff/pull/10640))
+- \[`ruff`\] Change `quadratic-list-summation` docs to use `iadd` consistently ([#10666](https://github.com/astral-sh/ruff/pull/10666))
+
+## 0.3.4
+
+### Preview features
+
+- \[`flake8-simplify`\] Detect implicit `else` cases in `needless-bool` (`SIM103`) ([#10414](https://github.com/astral-sh/ruff/pull/10414))
+- \[`pylint`\] Implement `nan-comparison` (`PLW0117`) ([#10401](https://github.com/astral-sh/ruff/pull/10401))
+- \[`pylint`\] Implement `nonlocal-and-global` (`E115`) ([#10407](https://github.com/astral-sh/ruff/pull/10407))
+- \[`pylint`\] Implement `singledispatchmethod-function` (`PLE5120`) ([#10428](https://github.com/astral-sh/ruff/pull/10428))
+- \[`refurb`\] Implement `list-reverse-copy` (`FURB187`) ([#10212](https://github.com/astral-sh/ruff/pull/10212))
+
+### Rule changes
+
+- \[`flake8-pytest-style`\] Add automatic fix for `pytest-parametrize-values-wrong-type` (`PT007`) ([#10461](https://github.com/astral-sh/ruff/pull/10461))
+- \[`pycodestyle`\] Allow SPDX license headers to exceed the line length (`E501`) ([#10481](https://github.com/astral-sh/ruff/pull/10481))
+
+### Formatter
+
+- Fix unstable formatting for trailing subscript end-of-line comment ([#10492](https://github.com/astral-sh/ruff/pull/10492))
+
+### Bug fixes
+
+- Avoid code comment detection in PEP 723 script tags ([#10464](https://github.com/astral-sh/ruff/pull/10464))
+- Avoid incorrect tuple transformation in single-element case (`C409`) ([#10491](https://github.com/astral-sh/ruff/pull/10491))
+- Bug fix: Prevent fully defined links [`name`](link) from being reformatted ([#10442](https://github.com/astral-sh/ruff/pull/10442))
+- Consider raw source code for `W605` ([#10480](https://github.com/astral-sh/ruff/pull/10480))
+- Docs: Link inline settings when not part of options section ([#10499](https://github.com/astral-sh/ruff/pull/10499))
+- Don't treat annotations as redefinitions in `.pyi` files ([#10512](https://github.com/astral-sh/ruff/pull/10512))
+- Fix `E231` bug: Inconsistent catch compared to pycodestyle, such as when dict nested in list ([#10469](https://github.com/astral-sh/ruff/pull/10469))
+- Fix pylint upstream categories not showing in docs ([#10441](https://github.com/astral-sh/ruff/pull/10441))
+- Add missing `Options` references to blank line docs ([#10498](https://github.com/astral-sh/ruff/pull/10498))
+- 'Revert "F821: Fix false negatives in .py files when `from __future__ import annotations` is active (#10362)"' ([#10513](https://github.com/astral-sh/ruff/pull/10513))
+- Apply NFKC normalization to unicode identifiers in the lexer ([#10412](https://github.com/astral-sh/ruff/pull/10412))
+- Avoid failures due to non-deterministic binding ordering ([#10478](https://github.com/astral-sh/ruff/pull/10478))
+- \[`flake8-bugbear`\] Allow tuples of exceptions (`B030`) ([#10437](https://github.com/astral-sh/ruff/pull/10437))
+- \[`flake8-quotes`\] Avoid syntax errors due to invalid quotes (`Q000, Q002`) ([#10199](https://github.com/astral-sh/ruff/pull/10199))
+
+## 0.3.3
+
+### Preview features
+
+- \[`flake8-bandit`\]: Implement `S610` rule ([#10316](https://github.com/astral-sh/ruff/pull/10316))
+- \[`pycodestyle`\] Implement `blank-line-at-end-of-file` (`W391`) ([#10243](https://github.com/astral-sh/ruff/pull/10243))
+- \[`pycodestyle`\] Implement `redundant-backslash` (`E502`) ([#10292](https://github.com/astral-sh/ruff/pull/10292))
+- \[`pylint`\] - implement `redeclared-assigned-name` (`W0128`) ([#9268](https://github.com/astral-sh/ruff/pull/9268))
+
+### Rule changes
+
+- \[`flake8_comprehensions`\] Handled special case for `C400` which also matches `C416` ([#10419](https://github.com/astral-sh/ruff/pull/10419))
+- \[`flake8-bandit`\] Implement upstream updates for `S311`, `S324` and `S605` ([#10313](https://github.com/astral-sh/ruff/pull/10313))
+- \[`pyflakes`\] Remove `F401` fix for `__init__` imports by default and allow opt-in to unsafe fix ([#10365](https://github.com/astral-sh/ruff/pull/10365))
+- \[`pylint`\] Implement `invalid-bool-return-type` (`E304`) ([#10377](https://github.com/astral-sh/ruff/pull/10377))
+- \[`pylint`\] Include builtin warnings in useless-exception-statement (`PLW0133`) ([#10394](https://github.com/astral-sh/ruff/pull/10394))
+
+### CLI
+
+- Add message on success to `ruff check` ([#8631](https://github.com/astral-sh/ruff/pull/8631))
+
+### Bug fixes
+
+- \[`PIE970`\] Allow trailing ellipsis in `typing.TYPE_CHECKING` ([#10413](https://github.com/astral-sh/ruff/pull/10413))
+- Avoid `TRIO115` if the argument is a variable ([#10376](https://github.com/astral-sh/ruff/pull/10376))
+- \[`F811`\] Avoid removing shadowed imports that point to different symbols ([#10387](https://github.com/astral-sh/ruff/pull/10387))
+- Fix `F821` and `F822` false positives in `.pyi` files ([#10341](https://github.com/astral-sh/ruff/pull/10341))
+- Fix `F821` false negatives in `.py` files when `from __future__ import annotations` is active ([#10362](https://github.com/astral-sh/ruff/pull/10362))
+- Fix case where `Indexer` fails to identify continuation preceded by newline #10351 ([#10354](https://github.com/astral-sh/ruff/pull/10354))
+- Sort hash maps in `Settings` display ([#10370](https://github.com/astral-sh/ruff/pull/10370))
+- Track conditional deletions in the semantic model ([#10415](https://github.com/astral-sh/ruff/pull/10415))
+- \[`C413`\] Wrap expressions in parentheses when negating ([#10346](https://github.com/astral-sh/ruff/pull/10346))
+- \[`pycodestyle`\] Do not ignore lines before the first logical line in blank lines rules. ([#10382](https://github.com/astral-sh/ruff/pull/10382))
+- \[`pycodestyle`\] Do not trigger `E225` and `E275` when the next token is a ')' ([#10315](https://github.com/astral-sh/ruff/pull/10315))
+- \[`pylint`\] Avoid false-positive slot non-assignment for `__dict__` (`PLE0237`) ([#10348](https://github.com/astral-sh/ruff/pull/10348))
+- Gate f-string struct size test for Rustc \< 1.76 ([#10371](https://github.com/astral-sh/ruff/pull/10371))
+
+### Documentation
+
+- Use `ruff.toml` format in README ([#10393](https://github.com/astral-sh/ruff/pull/10393))
+- \[`RUF008`\] Make it clearer that a mutable default in a dataclass is only valid if it is typed as a ClassVar ([#10395](https://github.com/astral-sh/ruff/pull/10395))
+- \[`pylint`\] Extend docs and test in `invalid-str-return-type` (`E307`) ([#10400](https://github.com/astral-sh/ruff/pull/10400))
+- Remove `.` from `check` and `format` commands ([#10217](https://github.com/astral-sh/ruff/pull/10217))
+
+## 0.3.2
+
+### Preview features
+
+- Improve single-`with` item formatting for Python 3.8 or older ([#10276](https://github.com/astral-sh/ruff/pull/10276))
+
+### Rule changes
+
+- \[`pyupgrade`\] Allow fixes for f-string rule regardless of line length (`UP032`) ([#10263](https://github.com/astral-sh/ruff/pull/10263))
+- \[`pycodestyle`\] Include actual conditions in E712 diagnostics ([#10254](https://github.com/astral-sh/ruff/pull/10254))
+
+### Bug fixes
+
+- Fix trailing kwargs end of line comment after slash ([#10297](https://github.com/astral-sh/ruff/pull/10297))
+- Fix unstable `with` items formatting ([#10274](https://github.com/astral-sh/ruff/pull/10274))
+- Avoid repeating function calls in f-string conversions ([#10265](https://github.com/astral-sh/ruff/pull/10265))
+- Fix E203 false positive for slices in format strings ([#10280](https://github.com/astral-sh/ruff/pull/10280))
+- Fix incorrect `Parameter` range for `*args` and `**kwargs` ([#10283](https://github.com/astral-sh/ruff/pull/10283))
+- Treat `typing.Annotated` subscripts as type definitions ([#10285](https://github.com/astral-sh/ruff/pull/10285))
+
+## 0.3.1
+
+### Preview features
+
+- \[`pycodestyle`\] Fix E301 not triggering on decorated methods. ([#10117](https://github.com/astral-sh/ruff/pull/10117))
+- \[`pycodestyle`\] Respect `isort` settings in blank line rules (`E3*`) ([#10096](https://github.com/astral-sh/ruff/pull/10096))
+- \[`pycodestyle`\] Make blank lines in typing stub files optional (`E3*`) ([#10098](https://github.com/astral-sh/ruff/pull/10098))
+- \[`pylint`\] Implement `singledispatch-method` (`E1519`) ([#10140](https://github.com/astral-sh/ruff/pull/10140))
+- \[`pylint`\] Implement `useless-exception-statement` (`W0133`) ([#10176](https://github.com/astral-sh/ruff/pull/10176))
+
+### Rule changes
+
+- \[`flake8-debugger`\] Check for use of `debugpy` and `ptvsd` debug modules (#10177) ([#10194](https://github.com/astral-sh/ruff/pull/10194))
+- \[`pyupgrade`\] Generate diagnostic for all valid f-string conversions regardless of line length (`UP032`) ([#10238](https://github.com/astral-sh/ruff/pull/10238))
+- \[`pep8_naming`\] Add fixes for `N804` and `N805` ([#10215](https://github.com/astral-sh/ruff/pull/10215))
+
+### CLI
+
+- Colorize the output of `ruff format --diff` ([#10110](https://github.com/astral-sh/ruff/pull/10110))
+- Make `--config` and `--isolated` global flags ([#10150](https://github.com/astral-sh/ruff/pull/10150))
+- Correctly expand tildes and environment variables in paths passed to `--config` ([#10219](https://github.com/astral-sh/ruff/pull/10219))
+
+### Configuration
+
+- Accept a PEP 440 version specifier for `required-version` ([#10216](https://github.com/astral-sh/ruff/pull/10216))
+- Implement isort's `default-section` setting ([#10149](https://github.com/astral-sh/ruff/pull/10149))
+
+### Bug fixes
+
+- Remove trailing space from `CapWords` message ([#10220](https://github.com/astral-sh/ruff/pull/10220))
+- Respect external codes in file-level exemptions ([#10203](https://github.com/astral-sh/ruff/pull/10203))
+- \[`flake8-raise`\] Avoid false-positives for parens-on-raise with `future.exception()` (`RSE102`) ([#10206](https://github.com/astral-sh/ruff/pull/10206))
+- \[`pylint`\] Add fix for unary expressions in `PLC2801` ([#9587](https://github.com/astral-sh/ruff/pull/9587))
+- \[`ruff`\] Fix RUF028 not allowing `# fmt: skip` on match cases ([#10178](https://github.com/astral-sh/ruff/pull/10178))
+
+## 0.3.0
+
+This release introduces the new Ruff formatter 2024.2 style and adds a new lint rule to
+detect invalid formatter suppression comments.
+
+### Preview features
+
+- \[`flake8-bandit`\] Remove suspicious-lxml-import (`S410`) ([#10154](https://github.com/astral-sh/ruff/pull/10154))
+- \[`pycodestyle`\] Allow `os.environ` modifications between imports (`E402`) ([#10066](https://github.com/astral-sh/ruff/pull/10066))
+- \[`pycodestyle`\] Don't warn about a single whitespace character before a comma in a tuple (`E203`) ([#10094](https://github.com/astral-sh/ruff/pull/10094))
+
+### Rule changes
+
+- \[`eradicate`\] Detect commented out `case` statements (`ERA001`) ([#10055](https://github.com/astral-sh/ruff/pull/10055))
+- \[`eradicate`\] Detect single-line code for `try:`, `except:`, etc. (`ERA001`) ([#10057](https://github.com/astral-sh/ruff/pull/10057))
+- \[`flake8-boolean-trap`\] Allow boolean positionals in `__post_init__` ([#10027](https://github.com/astral-sh/ruff/pull/10027))
+- \[`flake8-copyright`\] Allow © in copyright notices ([#10065](https://github.com/astral-sh/ruff/pull/10065))
+- \[`isort`\]: Use one blank line after imports in typing stub files ([#9971](https://github.com/astral-sh/ruff/pull/9971))
+- \[`pylint`\] New Rule `dict-iter-missing-items` (`PLE1141`) ([#9845](https://github.com/astral-sh/ruff/pull/9845))
+- \[`pylint`\] Ignore `sys.version` and `sys.platform` (`PLR1714`) ([#10054](https://github.com/astral-sh/ruff/pull/10054))
+- \[`pyupgrade`\] Detect literals with unary operators (`UP018`) ([#10060](https://github.com/astral-sh/ruff/pull/10060))
+- \[`ruff`\] Expand rule for `list(iterable).pop(0)` idiom (`RUF015`) ([#10148](https://github.com/astral-sh/ruff/pull/10148))
+
+### Formatter
+
+This release introduces the Ruff 2024.2 style, stabilizing the following changes:
+
+- Prefer splitting the assignment's value over the target or type annotation ([#8943](https://github.com/astral-sh/ruff/pull/8943))
+- Remove blank lines before class docstrings ([#9154](https://github.com/astral-sh/ruff/pull/9154))
+- Wrap multiple context managers in `with` parentheses when targeting Python 3.9 or newer ([#9222](https://github.com/astral-sh/ruff/pull/9222))
+- Add a blank line after nested classes with a dummy body (`...`) in typing stub files ([#9155](https://github.com/astral-sh/ruff/pull/9155))
+- Reduce vertical spacing for classes and functions with a dummy (`...`) body ([#7440](https://github.com/astral-sh/ruff/issues/7440), [#9240](https://github.com/astral-sh/ruff/pull/9240))
+- Add a blank line after the module docstring ([#8283](https://github.com/astral-sh/ruff/pull/8283))
+- Parenthesize long type hints in assignments ([#9210](https://github.com/astral-sh/ruff/pull/9210))
+- Preserve indent for single multiline-string call-expressions ([#9673](https://github.com/astral-sh/ruff/pull/9637))
+- Normalize hex escape and unicode escape sequences ([#9280](https://github.com/astral-sh/ruff/pull/9280))
+- Format module docstrings ([#9725](https://github.com/astral-sh/ruff/pull/9725))
+
+### CLI
+
+- Explicitly disallow `extend` as part of a `--config` flag ([#10135](https://github.com/astral-sh/ruff/pull/10135))
+- Remove `build` from the default exclusion list ([#10093](https://github.com/astral-sh/ruff/pull/10093))
+- Deprecate `ruff <path>`, `ruff --explain`, `ruff --clean`, and `ruff --generate-shell-completion` in favor of `ruff check <path>`, `ruff rule`, `ruff clean`, and `ruff generate-shell-completion` ([#10169](https://github.com/astral-sh/ruff/pull/10169))
+- Remove the deprecated CLI option `--format` from `ruff rule` and `ruff linter` ([#10170](https://github.com/astral-sh/ruff/pull/10170))
+
+### Bug fixes
+
+- \[`flake8-bugbear`\] Avoid adding default initializers to stubs (`B006`) ([#10152](https://github.com/astral-sh/ruff/pull/10152))
+- \[`flake8-type-checking`\] Respect runtime-required decorators for function signatures ([#10091](https://github.com/astral-sh/ruff/pull/10091))
+- \[`pycodestyle`\] Mark fixes overlapping with a multiline string as unsafe (`W293`) ([#10049](https://github.com/astral-sh/ruff/pull/10049))
+- \[`pydocstyle`\] Trim whitespace when removing blank lines after section (`D413`) ([#10162](https://github.com/astral-sh/ruff/pull/10162))
+- \[`pylint`\] Delete entire statement, including semicolons (`PLR0203`) ([#10074](https://github.com/astral-sh/ruff/pull/10074))
+- \[`ruff`\] Avoid f-string false positives in `gettext` calls (`RUF027`) ([#10118](https://github.com/astral-sh/ruff/pull/10118))
+- Fix `ruff` crashing on PowerPC systems because of too small page size ([#10080](https://github.com/astral-sh/ruff/pull/10080))
+
+### Performance
+
+- Add cold attribute to less likely printer queue branches in the formatter ([#10121](https://github.com/astral-sh/ruff/pull/10121))
+- Skip unnecessary string normalization in the formatter ([#10116](https://github.com/astral-sh/ruff/pull/10116))
+
+### Documentation
+
+- Remove "Beta" Label from formatter documentation ([#10144](https://github.com/astral-sh/ruff/pull/10144))
+- `line-length` option: fix link to `pycodestyle.max-line-length` ([#10136](https://github.com/astral-sh/ruff/pull/10136))
+
+## 0.2.2
+
+Highlights include:
+
+- Initial support formatting f-strings (in `--preview`).
+- Support for overriding arbitrary configuration options via the CLI through an expanded `--config` argument (e.g., `--config "lint.isort.combine-as-imports=false"`).
+- Significant performance improvements in Ruff's lexer, parser, and lint rules.
+
+### Preview features
+
+- Implement minimal f-string formatting ([#9642](https://github.com/astral-sh/ruff/pull/9642))
+- \[`pycodestyle`\] Add blank line(s) rules (`E301`, `E302`, `E303`, `E304`, `E305`, `E306`) ([#9266](https://github.com/astral-sh/ruff/pull/9266))
+- \[`refurb`\] Implement `readlines_in_for` (`FURB129`) ([#9880](https://github.com/astral-sh/ruff/pull/9880))
+
+### Rule changes
+
+- \[`ruff`\] Ensure closing parentheses for multiline sequences are always on their own line (`RUF022`, `RUF023`) ([#9793](https://github.com/astral-sh/ruff/pull/9793))
+- \[`numpy`\] Add missing deprecation violations (`NPY002`) ([#9862](https://github.com/astral-sh/ruff/pull/9862))
+- \[`flake8-bandit`\] Detect `mark_safe` usages in decorators ([#9887](https://github.com/astral-sh/ruff/pull/9887))
+- \[`ruff`\] Expand `asyncio-dangling-task` (`RUF006`) to include `new_event_loop` ([#9976](https://github.com/astral-sh/ruff/pull/9976))
+- \[`flake8-pyi`\] Ignore 'unused' private type dicts in class scopes ([#9952](https://github.com/astral-sh/ruff/pull/9952))
+
+### Formatter
+
+- Docstring formatting: Preserve tab indentation when using `indent-style=tabs` ([#9915](https://github.com/astral-sh/ruff/pull/9915))
+- Disable top-level docstring formatting for notebooks ([#9957](https://github.com/astral-sh/ruff/pull/9957))
+- Stabilize quote-style's `preserve` mode ([#9922](https://github.com/astral-sh/ruff/pull/9922))
+
+### CLI
+
+- Allow arbitrary configuration options to be overridden via the CLI ([#9599](https://github.com/astral-sh/ruff/pull/9599))
+
+### Bug fixes
+
+- Make `show-settings` filters directory-agnostic ([#9866](https://github.com/astral-sh/ruff/pull/9866))
+- Respect duplicates when rewriting type aliases ([#9905](https://github.com/astral-sh/ruff/pull/9905))
+- Respect tuple assignments in typing analyzer ([#9969](https://github.com/astral-sh/ruff/pull/9969))
+- Use atomic write when persisting cache ([#9981](https://github.com/astral-sh/ruff/pull/9981))
+- Use non-parenthesized range for `DebugText` ([#9953](https://github.com/astral-sh/ruff/pull/9953))
+- \[`flake8-simplify`\] Avoid false positive with `async` for loops (`SIM113`) ([#9996](https://github.com/astral-sh/ruff/pull/9996))
+- \[`flake8-trio`\] Respect `async with` in `timeout-without-await` ([#9859](https://github.com/astral-sh/ruff/pull/9859))
+- \[`perflint`\] Catch a wider range of mutations in `PERF101` ([#9955](https://github.com/astral-sh/ruff/pull/9955))
+- \[`pycodestyle`\] Fix `E30X` panics on blank lines with trailing white spaces ([#9907](https://github.com/astral-sh/ruff/pull/9907))
+- \[`pydocstyle`\] Allow using `parameters` as a subsection header (`D405`) ([#9894](https://github.com/astral-sh/ruff/pull/9894))
+- \[`pydocstyle`\] Fix blank-line docstring rules for module-level docstrings ([#9878](https://github.com/astral-sh/ruff/pull/9878))
+- \[`pylint`\] Accept 0.0 and 1.0 as common magic values (`PLR2004`) ([#9964](https://github.com/astral-sh/ruff/pull/9964))
+- \[`pylint`\] Avoid suggesting set rewrites for non-hashable types ([#9956](https://github.com/astral-sh/ruff/pull/9956))
+- \[`ruff`\] Avoid false negatives with string literals inside of method calls (`RUF027`) ([#9865](https://github.com/astral-sh/ruff/pull/9865))
+- \[`ruff`\] Fix panic on with f-string detection (`RUF027`) ([#9990](https://github.com/astral-sh/ruff/pull/9990))
+- \[`ruff`\] Ignore builtins when detecting missing f-strings ([#9849](https://github.com/astral-sh/ruff/pull/9849))
+
+### Performance
+
+- Use `memchr` for string lexing ([#9888](https://github.com/astral-sh/ruff/pull/9888))
+- Use `memchr` for tab-indentation detection ([#9853](https://github.com/astral-sh/ruff/pull/9853))
+- Reduce `Result<Tok, LexicalError>` size by using `Box<str>` instead of `String` ([#9885](https://github.com/astral-sh/ruff/pull/9885))
+- Reduce size of `Expr` from 80 to 64 bytes ([#9900](https://github.com/astral-sh/ruff/pull/9900))
+- Improve trailing comma rule performance ([#9867](https://github.com/astral-sh/ruff/pull/9867))
+- Remove unnecessary string cloning from the parser ([#9884](https://github.com/astral-sh/ruff/pull/9884))
+
+## 0.2.1
+
+This release includes support for range formatting (i.e., the ability to format specific lines
+within a source file).
+
+### Preview features
+
+- \[`refurb`\] Implement `missing-f-string-syntax` (`RUF027`) ([#9728](https://github.com/astral-sh/ruff/pull/9728))
+- Format module-level docstrings ([#9725](https://github.com/astral-sh/ruff/pull/9725))
+
+### Formatter
+
+- Add `--range` option to `ruff format` ([#9733](https://github.com/astral-sh/ruff/pull/9733))
+- Don't trim last empty line in docstrings ([#9813](https://github.com/astral-sh/ruff/pull/9813))
+
+### Bug fixes
+
+- Skip empty lines when determining base indentation ([#9795](https://github.com/astral-sh/ruff/pull/9795))
+- Drop `__get__` and `__set__` from `unnecessary-dunder-call` ([#9791](https://github.com/astral-sh/ruff/pull/9791))
+- Respect generic `Protocol` in ellipsis removal ([#9841](https://github.com/astral-sh/ruff/pull/9841))
+- Revert "Use publicly available Apple Silicon runners (#9726)" ([#9834](https://github.com/astral-sh/ruff/pull/9834))
+
+### Performance
+
+- Skip LibCST parsing for standard dedent adjustments ([#9769](https://github.com/astral-sh/ruff/pull/9769))
+- Remove CST-based fixer for `C408` ([#9822](https://github.com/astral-sh/ruff/pull/9822))
+- Add our own ignored-names abstractions ([#9802](https://github.com/astral-sh/ruff/pull/9802))
+- Remove CST-based fixers for `C400`, `C401`, `C410`, and `C418` ([#9819](https://github.com/astral-sh/ruff/pull/9819))
+- Use `AhoCorasick` to speed up quote match ([#9773](https://github.com/astral-sh/ruff/pull/9773))
+- Remove CST-based fixers for `C405` and `C409` ([#9821](https://github.com/astral-sh/ruff/pull/9821))
+- Add fast-path for comment detection ([#9808](https://github.com/astral-sh/ruff/pull/9808))
+- Invert order of checks in `zero-sleep-call` ([#9766](https://github.com/astral-sh/ruff/pull/9766))
+- Short-circuit typing matches based on imports ([#9800](https://github.com/astral-sh/ruff/pull/9800))
+- Run dunder method rule on methods directly ([#9815](https://github.com/astral-sh/ruff/pull/9815))
+- Track top-level module imports in the semantic model ([#9775](https://github.com/astral-sh/ruff/pull/9775))
+- Slight speed-up for lowercase and uppercase identifier checks ([#9798](https://github.com/astral-sh/ruff/pull/9798))
+- Remove LibCST-based fixer for `C403` ([#9818](https://github.com/astral-sh/ruff/pull/9818))
+
+### Documentation
+
+- Update `max-pos-args` example to `max-positional-args` ([#9797](https://github.com/astral-sh/ruff/pull/9797))
+- Fixed example code in `weak_cryptographic_key.rs` ([#9774](https://github.com/astral-sh/ruff/pull/9774))
+- Fix references to deprecated `ANN` rules in changelog ([#9771](https://github.com/astral-sh/ruff/pull/9771))
+- Fix default for `max-positional-args` ([#9838](https://github.com/astral-sh/ruff/pull/9838))
+
+## 0.2.0
+
+### Breaking changes
+
+- The `NURSERY` selector cannot be used anymore
+- Legacy selection of nursery rules by exact codes is no longer allowed without preview enabled
+
+See also, the "Remapped rules" section which may result in disabled rules.
+
+### Deprecations
+
+The following rules are now deprecated:
+
+- [`missing-type-self`](https://docs.astral.sh/ruff/rules/missing-type-self/) (`ANN101`)
+- [`missing-type-cls`](https://docs.astral.sh/ruff/rules/missing-type-cls/) (`ANN102`)
+
+The following command line options are now deprecated:
+
+- `--show-source`; use `--output-format full` instead
+- `--no-show-source`; use `--output-format concise` instead
+- `--output-format text`; use `full` or `concise` instead
+
+The following settings have moved and the previous name is deprecated:
+
+- `ruff.allowed-confusables` → [`ruff.lint.allowed-confusables`](https://docs.astral.sh//ruff/settings/#lint_allowed-confusables)
+- `ruff.dummy-variable-rgx` → [`ruff.lint.dummy-variable-rgx`](https://docs.astral.sh//ruff/settings/#lint_dummy-variable-rgx)
+- `ruff.explicit-preview-rules` → [`ruff.lint.explicit-preview-rules`](https://docs.astral.sh//ruff/settings/#lint_explicit-preview-rules)
+- `ruff.extend-fixable` → [`ruff.lint.extend-fixable`](https://docs.astral.sh//ruff/settings/#lint_extend-fixable)
+- `ruff.extend-ignore` → [`ruff.lint.extend-ignore`](https://docs.astral.sh//ruff/settings/#lint_extend-ignore)
+- `ruff.extend-per-file-ignores` → [`ruff.lint.extend-per-file-ignores`](https://docs.astral.sh//ruff/settings/#lint_extend-per-file-ignores)
+- `ruff.extend-safe-fixes` → [`ruff.lint.extend-safe-fixes`](https://docs.astral.sh//ruff/settings/#lint_extend-safe-fixes)
+- `ruff.extend-select` → [`ruff.lint.extend-select`](https://docs.astral.sh//ruff/settings/#lint_extend-select)
+- `ruff.extend-unfixable` → [`ruff.lint.extend-unfixable`](https://docs.astral.sh//ruff/settings/#lint_extend-unfixable)
+- `ruff.extend-unsafe-fixes` → [`ruff.lint.extend-unsafe-fixes`](https://docs.astral.sh//ruff/settings/#lint_extend-unsafe-fixes)
+- `ruff.external` → [`ruff.lint.external`](https://docs.astral.sh//ruff/settings/#lint_external)
+- `ruff.fixable` → [`ruff.lint.fixable`](https://docs.astral.sh//ruff/settings/#lint_fixable)
+- `ruff.flake8-annotations` → [`ruff.lint.flake8-annotations`](https://docs.astral.sh//ruff/settings/#lint_flake8-annotations)
+- `ruff.flake8-bandit` → [`ruff.lint.flake8-bandit`](https://docs.astral.sh//ruff/settings/#lint_flake8-bandit)
+- `ruff.flake8-bugbear` → [`ruff.lint.flake8-bugbear`](https://docs.astral.sh//ruff/settings/#lint_flake8-bugbear)
+- `ruff.flake8-builtins` → [`ruff.lint.flake8-builtins`](https://docs.astral.sh//ruff/settings/#lint_flake8-builtins)
+- `ruff.flake8-comprehensions` → [`ruff.lint.flake8-comprehensions`](https://docs.astral.sh//ruff/settings/#lint_flake8-comprehensions)
+- `ruff.flake8-copyright` → [`ruff.lint.flake8-copyright`](https://docs.astral.sh//ruff/settings/#lint_flake8-copyright)
+- `ruff.flake8-errmsg` → [`ruff.lint.flake8-errmsg`](https://docs.astral.sh//ruff/settings/#lint_flake8-errmsg)
+- `ruff.flake8-gettext` → [`ruff.lint.flake8-gettext`](https://docs.astral.sh//ruff/settings/#lint_flake8-gettext)
+- `ruff.flake8-implicit-str-concat` → [`ruff.lint.flake8-implicit-str-concat`](https://docs.astral.sh//ruff/settings/#lint_flake8-implicit-str-concat)
+- `ruff.flake8-import-conventions` → [`ruff.lint.flake8-import-conventions`](https://docs.astral.sh//ruff/settings/#lint_flake8-import-conventions)
+- `ruff.flake8-pytest-style` → [`ruff.lint.flake8-pytest-style`](https://docs.astral.sh//ruff/settings/#lint_flake8-pytest-style)
+- `ruff.flake8-quotes` → [`ruff.lint.flake8-quotes`](https://docs.astral.sh//ruff/settings/#lint_flake8-quotes)
+- `ruff.flake8-self` → [`ruff.lint.flake8-self`](https://docs.astral.sh//ruff/settings/#lint_flake8-self)
+- `ruff.flake8-tidy-imports` → [`ruff.lint.flake8-tidy-imports`](https://docs.astral.sh//ruff/settings/#lint_flake8-tidy-imports)
+- `ruff.flake8-type-checking` → [`ruff.lint.flake8-type-checking`](https://docs.astral.sh//ruff/settings/#lint_flake8-type-checking)
+- `ruff.flake8-unused-arguments` → [`ruff.lint.flake8-unused-arguments`](https://docs.astral.sh//ruff/settings/#lint_flake8-unused-arguments)
+- `ruff.ignore` → [`ruff.lint.ignore`](https://docs.astral.sh//ruff/settings/#lint_ignore)
+- `ruff.ignore-init-module-imports` → [`ruff.lint.ignore-init-module-imports`](https://docs.astral.sh//ruff/settings/#lint_ignore-init-module-imports)
+- `ruff.isort` → [`ruff.lint.isort`](https://docs.astral.sh//ruff/settings/#lint_isort)
+- `ruff.logger-objects` → [`ruff.lint.logger-objects`](https://docs.astral.sh//ruff/settings/#lint_logger-objects)
+- `ruff.mccabe` → [`ruff.lint.mccabe`](https://docs.astral.sh//ruff/settings/#lint_mccabe)
+- `ruff.pep8-naming` → [`ruff.lint.pep8-naming`](https://docs.astral.sh//ruff/settings/#lint_pep8-naming)
+- `ruff.per-file-ignores` → [`ruff.lint.per-file-ignores`](https://docs.astral.sh//ruff/settings/#lint_per-file-ignores)
+- `ruff.pycodestyle` → [`ruff.lint.pycodestyle`](https://docs.astral.sh//ruff/settings/#lint_pycodestyle)
+- `ruff.pydocstyle` → [`ruff.lint.pydocstyle`](https://docs.astral.sh//ruff/settings/#lint_pydocstyle)
+- `ruff.pyflakes` → [`ruff.lint.pyflakes`](https://docs.astral.sh//ruff/settings/#lint_pyflakes)
+- `ruff.pylint` → [`ruff.lint.pylint`](https://docs.astral.sh//ruff/settings/#lint_pylint)
+- `ruff.pyupgrade` → [`ruff.lint.pyupgrade`](https://docs.astral.sh//ruff/settings/#lint_pyupgrade)
+- `ruff.select` → [`ruff.lint.select`](https://docs.astral.sh//ruff/settings/#lint_select)
+- `ruff.task-tags` → [`ruff.lint.task-tags`](https://docs.astral.sh//ruff/settings/#lint_task-tags)
+- `ruff.typing-modules` → [`ruff.lint.typing-modules`](https://docs.astral.sh//ruff/settings/#lint_typing-modules)
+- `ruff.unfixable` → [`ruff.lint.unfixable`](https://docs.astral.sh//ruff/settings/#lint_unfixable)
+
+### Remapped rules
+
+The following rules have been remapped to new codes:
+
+- [`raise-without-from-inside-except`](https://docs.astral.sh/ruff/rules/raise-without-from-inside-except/): `TRY200` to `B904`
+- [`suspicious-eval-usage`](https://docs.astral.sh/ruff/rules/suspicious-eval-usage/): `PGH001` to `S307`
+- [`logging-warn`](https://docs.astral.sh/ruff/rules/logging-warn/): `PGH002` to `G010`
+- [`static-key-dict-comprehension`](https://docs.astral.sh/ruff/rules/static-key-dict-comprehension): `RUF011` to `B035`
+- [`runtime-string-union`](https://docs.astral.sh/ruff/rules/runtime-string-union): `TCH006` to `TCH010`
+
+### Stabilizations
+
+The following rules have been stabilized and are no longer in preview:
+
+- [`trio-timeout-without-await`](https://docs.astral.sh/ruff/rules/trio-timeout-without-await) (`TRIO100`)
+- [`trio-sync-call`](https://docs.astral.sh/ruff/rules/trio-sync-call) (`TRIO105`)
+- [`trio-async-function-with-timeout`](https://docs.astral.sh/ruff/rules/trio-async-function-with-timeout) (`TRIO109`)
+- [`trio-unneeded-sleep`](https://docs.astral.sh/ruff/rules/trio-unneeded-sleep) (`TRIO110`)
+- [`trio-zero-sleep-call`](https://docs.astral.sh/ruff/rules/trio-zero-sleep-call) (`TRIO115`)
+- [`unnecessary-escaped-quote`](https://docs.astral.sh/ruff/rules/unnecessary-escaped-quote) (`Q004`)
+- [`enumerate-for-loop`](https://docs.astral.sh/ruff/rules/enumerate-for-loop) (`SIM113`)
+- [`zip-dict-keys-and-values`](https://docs.astral.sh/ruff/rules/zip-dict-keys-and-values) (`SIM911`)
+- [`timeout-error-alias`](https://docs.astral.sh/ruff/rules/timeout-error-alias) (`UP041`)
+- [`flask-debug-true`](https://docs.astral.sh/ruff/rules/flask-debug-true) (`S201`)
+- [`tarfile-unsafe-members`](https://docs.astral.sh/ruff/rules/tarfile-unsafe-members) (`S202`)
+- [`ssl-insecure-version`](https://docs.astral.sh/ruff/rules/ssl-insecure-version) (`S502`)
+- [`ssl-with-bad-defaults`](https://docs.astral.sh/ruff/rules/ssl-with-bad-defaults) (`S503`)
+- [`ssl-with-no-version`](https://docs.astral.sh/ruff/rules/ssl-with-no-version) (`S504`)
+- [`weak-cryptographic-key`](https://docs.astral.sh/ruff/rules/weak-cryptographic-key) (`S505`)
+- [`ssh-no-host-key-verification`](https://docs.astral.sh/ruff/rules/ssh-no-host-key-verification) (`S507`)
+- [`django-raw-sql`](https://docs.astral.sh/ruff/rules/django-raw-sql) (`S611`)
+- [`mako-templates`](https://docs.astral.sh/ruff/rules/mako-templates) (`S702`)
+- [`generator-return-from-iter-method`](https://docs.astral.sh/ruff/rules/generator-return-from-iter-method) (`PYI058`)
+- [`runtime-string-union`](https://docs.astral.sh/ruff/rules/runtime-string-union) (`TCH006`)
+- [`numpy2-deprecation`](https://docs.astral.sh/ruff/rules/numpy2-deprecation) (`NPY201`)
+- [`quadratic-list-summation`](https://docs.astral.sh/ruff/rules/quadratic-list-summation) (`RUF017`)
+- [`assignment-in-assert`](https://docs.astral.sh/ruff/rules/assignment-in-assert) (`RUF018`)
+- [`unnecessary-key-check`](https://docs.astral.sh/ruff/rules/unnecessary-key-check) (`RUF019`)
+- [`never-union`](https://docs.astral.sh/ruff/rules/never-union) (`RUF020`)
+- [`direct-logger-instantiation`](https://docs.astral.sh/ruff/rules/direct-logger-instantiation) (`LOG001`)
+- [`invalid-get-logger-argument`](https://docs.astral.sh/ruff/rules/invalid-get-logger-argument) (`LOG002`)
+- [`exception-without-exc-info`](https://docs.astral.sh/ruff/rules/exception-without-exc-info) (`LOG007`)
+- [`undocumented-warn`](https://docs.astral.sh/ruff/rules/undocumented-warn) (`LOG009`)
+
+Fixes for the following rules have been stabilized and are now available without preview:
+
+- [`triple-single-quotes`](https://docs.astral.sh/ruff/rules/triple-single-quotes) (`D300`)
+- [`non-pep604-annotation`](https://docs.astral.sh/ruff/rules/non-pep604-annotation) (`UP007`)
+- [`dict-get-with-none-default`](https://docs.astral.sh/ruff/rules/dict-get-with-none-default) (`SIM910`)
+- [`in-dict-keys`](https://docs.astral.sh/ruff/rules/in-dict-keys) (`SIM118`)
+- [`collapsible-else-if`](https://docs.astral.sh/ruff/rules/collapsible-else-if) (`PLR5501`)
+- [`if-with-same-arms`](https://docs.astral.sh/ruff/rules/if-with-same-arms) (`SIM114`)
+- [`useless-else-on-loop`](https://docs.astral.sh/ruff/rules/useless-else-on-loop) (`PLW0120`)
+- [`unnecessary-literal-union`](https://docs.astral.sh/ruff/rules/unnecessary-literal-union) (`PYI030`)
+- [`unnecessary-spread`](https://docs.astral.sh/ruff/rules/unnecessary-spread) (`PIE800`)
+- [`error-instead-of-exception`](https://docs.astral.sh/ruff/rules/error-instead-of-exception) (`TRY400`)
+- [`redefined-while-unused`](https://docs.astral.sh/ruff/rules/redefined-while-unused) (`F811`)
+- [`duplicate-value`](https://docs.astral.sh/ruff/rules/duplicate-value) (`B033`)
+- [`multiple-imports-on-one-line`](https://docs.astral.sh/ruff/rules/multiple-imports-on-one-line) (`E401`)
+- [`non-pep585-annotation`](https://docs.astral.sh/ruff/rules/non-pep585-annotation) (`UP006`)
+
+Fixes for the following rules have been promoted from unsafe to safe:
+
+- [`unaliased-collections-abc-set-import`](https://docs.astral.sh/ruff/rules/unaliased-collections-abc-set-import) (`PYI025`)
+
+The following behaviors have been stabilized:
+
+- [`module-import-not-at-top-of-file`](https://docs.astral.sh/ruff/rules/module-import-not-at-top-of-file/) (`E402`) allows `sys.path` modifications between imports
+- [`reimplemented-container-builtin`](https://docs.astral.sh/ruff/rules/reimplemented-container-builtin/) (`PIE807`) includes lambdas that can be replaced with `dict`
+- [`unnecessary-placeholder`](https://docs.astral.sh/ruff/rules/unnecessary-placeholder/) (`PIE790`) applies to unnecessary ellipses (`...`)
+- [`if-else-block-instead-of-dict-get`](https://docs.astral.sh/ruff/rules/if-else-block-instead-of-dict-get/) (`SIM401`) applies to `if-else` expressions
+
+### Preview features
+
+- \[`refurb`\] Implement `metaclass_abcmeta` (`FURB180`) ([#9658](https://github.com/astral-sh/ruff/pull/9658))
+- Implement `blank_line_after_nested_stub_class` preview style ([#9155](https://github.com/astral-sh/ruff/pull/9155))
+- The preview rule [`and-or-ternary`](https://docs.astral.sh/ruff/rules/and-or-ternary) (`PLR1706`) was removed
+
+### Bug fixes
+
+- \[`flake8-async`\] Take `pathlib.Path` into account when analyzing async functions ([#9703](https://github.com/astral-sh/ruff/pull/9703))
+- \[`flake8-return`\] - fix indentation syntax error (`RET505`) ([#9705](https://github.com/astral-sh/ruff/pull/9705))
+- Detect multi-statement lines in else removal ([#9748](https://github.com/astral-sh/ruff/pull/9748))
+- `RUF022`, `RUF023`: never add two trailing commas to the end of a sequence ([#9698](https://github.com/astral-sh/ruff/pull/9698))
+- `RUF023`: Don't sort `__match_args__`, only `__slots__` ([#9724](https://github.com/astral-sh/ruff/pull/9724))
+- \[`flake8-simplify`\] - Fix syntax error in autofix (`SIM114`) ([#9704](https://github.com/astral-sh/ruff/pull/9704))
+- \[`pylint`\] Show verbatim constant in `magic-value-comparison` (`PLR2004`) ([#9694](https://github.com/astral-sh/ruff/pull/9694))
+- Removing trailing whitespace inside multiline strings is unsafe ([#9744](https://github.com/astral-sh/ruff/pull/9744))
+- Support `IfExp` with dual string arms in `invalid-envvar-default` ([#9734](https://github.com/astral-sh/ruff/pull/9734))
+- \[`pylint`\] Add `__mro_entries__` to known dunder methods (`PLW3201`) ([#9706](https://github.com/astral-sh/ruff/pull/9706))
+
+### Documentation
+
+- Removed rules are now retained in the documentation ([#9691](https://github.com/astral-sh/ruff/pull/9691))
+- Deprecated rules are now indicated in the documentation ([#9689](https://github.com/astral-sh/ruff/pull/9689))
+
 ## 0.1.15
 
 ### Preview features
@@ -383,7 +1084,7 @@ docstrings via the `docstring-code-format` setting.
 - \[`pylint`\] Default `max-positional-args` to `max-args` ([#8998](https://github.com/astral-sh/ruff/pull/8998))
 - \[`pylint`\] Add `allow-dunder-method-names` setting for `bad-dunder-method-name` (`PLW3201`) ([#8812](https://github.com/astral-sh/ruff/pull/8812))
 - \[`isort`\] Add support for `from-first` setting ([#8663](https://github.com/astral-sh/ruff/pull/8663))
-- \[`isort`\]  Add support for `length-sort` settings ([#8841](https://github.com/astral-sh/ruff/pull/8841))
+- \[`isort`\] Add support for `length-sort` settings ([#8841](https://github.com/astral-sh/ruff/pull/8841))
 
 ### Bug fixes
 
@@ -512,7 +1213,7 @@ docstrings via the `docstring-code-format` setting.
 - \[`flake8-trio`\] Implement `TRIO115` ([#8486](https://github.com/astral-sh/ruff/pull/8486))
 - \[`refurb`\] Implement `type-none-comparison` (`FURB169`) ([#8487](https://github.com/astral-sh/ruff/pull/8487))
 - Flag all comparisons against builtin types in `E721` ([#8491](https://github.com/astral-sh/ruff/pull/8491))
-- Make `SIM118` fix as safe when the expression is a known dictionary  ([#8525](https://github.com/astral-sh/ruff/pull/8525))
+- Make `SIM118` fix as safe when the expression is a known dictionary ([#8525](https://github.com/astral-sh/ruff/pull/8525))
 
 ### Formatter
 
@@ -680,7 +1381,7 @@ Try it today with `ruff format`! [Check out the blog post](https://astral.sh/blo
 - 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))
+- Update fix for `mutable-argument-defaults` (`B006`) to be unsafe ([#8108](https://github.com/astral-sh/ruff/pull/8108))
 
 ### Formatter
 
@@ -808,7 +1509,7 @@ Read Ruff's new [versioning policy](https://docs.astral.sh/ruff/versioning/).
 - \[`refurb`\] Add `single-item-membership-test` (`FURB171`) ([#7815](https://github.com/astral-sh/ruff/pull/7815))
 - \[`pylint`\] Add `and-or-ternary` (`R1706`) ([#7811](https://github.com/astral-sh/ruff/pull/7811))
 
-_New rules are added in [preview](https://docs.astral.sh/ruff/preview/)._
+*New rules are added in [preview](https://docs.astral.sh/ruff/preview/).*
 
 ### Configuration
 

CONTRIBUTING.md

@@ -26,30 +26,25 @@ Welcome! We're happy to have you here. Thank you in advance for your contributio
 - [`cargo dev`](#cargo-dev)
 - [Subsystems](#subsystems)
     - [Compilation Pipeline](#compilation-pipeline)
+    - [Import Categorization](#import-categorization)
+        - [Project root](#project-root)
+        - [Package root](#package-root)
+        - [Import categorization](#import-categorization-1)
 
 ## The Basics
 
-Ruff welcomes contributions in the form of Pull Requests.
+Ruff welcomes contributions in the form of pull requests.
 
 For small changes (e.g., bug fixes), feel free to submit a PR.
 
 For larger changes (e.g., new lint rules, new functionality, new configuration options), consider
 creating an [**issue**](https://github.com/astral-sh/ruff/issues) outlining your proposed change.
-You can also join us on [**Discord**](https://discord.gg/c9MhzV8aU5) to discuss your idea with the
+You can also join us on [Discord](https://discord.com/invite/astral-sh) to discuss your idea with the
 community. We've labeled [beginner-friendly tasks](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)
 in the issue tracker, along with [bugs](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3Abug)
 and [improvements](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3Aaccepted)
 that are ready for contributions.
 
-If you're looking for a place to start, we recommend implementing a new lint rule (see:
-[_Adding a new lint rule_](#example-adding-a-new-lint-rule), which will allow you to learn from and
-pattern-match against the examples in the existing codebase. Many lint rules are inspired by
-existing Python plugins, which can be used as a reference implementation.
-
-As a concrete example: consider taking on one of the rules from the [`flake8-pyi`](https://github.com/astral-sh/ruff/issues/848)
-plugin, and looking to the originating [Python source](https://github.com/PyCQA/flake8-pyi) for
-guidance.
-
 If you have suggestions on how we might improve the contributing documentation, [let us know](https://github.com/astral-sh/ruff/discussions/5693)!
 
 ### Prerequisites
@@ -63,7 +58,7 @@ You'll also need [Insta](https://insta.rs/docs/) to update snapshot tests:
 cargo install cargo-insta
 ```
 
-and pre-commit to run some validation checks:
+And you'll need pre-commit to run some validation checks:
 
 ```shell
 pipx install pre-commit  # or `pip install pre-commit` if you have a virtualenv
@@ -76,6 +71,16 @@ when making a commit:
 pre-commit install
 ```
 
+We recommend [nextest](https://nexte.st/) to run Ruff's test suite (via `cargo nextest run`),
+though it's not strictly necessary:
+
+```shell
+cargo install cargo-nextest --locked
+```
+
+Throughout this guide, any usages of `cargo test` can be replaced with `cargo nextest run`,
+if you choose to install `nextest`.
+
 ### Development
 
 After cloning the repository, run Ruff locally from the repository root with:
@@ -93,7 +98,7 @@ RUFF_UPDATE_SCHEMA=1 cargo test  # Rust testing and updating ruff.schema.json
 pre-commit run --all-files --show-diff-on-failure  # Rust and Python formatting, Markdown and Python linting, etc.
 ```
 
-These checks will run on GitHub Actions when you open your Pull Request, but running them locally
+These checks will run on GitHub Actions when you open your pull request, but running them locally
 will save you time and expedite the merge process.
 
 Note that many code changes also require updating the snapshot tests, which is done interactively
@@ -103,7 +108,14 @@ after running `cargo test` like so:
 cargo insta review
 ```
 
-Your Pull Request will be reviewed by a maintainer, which may involve a few rounds of iteration
+If your pull request relates to a specific lint rule, include the category and rule code in the
+title, as in the following examples:
+
+- \[`flake8-bugbear`\] Avoid false positive for usage after `continue` (`B031`)
+- \[`flake8-simplify`\] Detect implicit `else` cases in `needless-bool` (`SIM103`)
+- \[`pycodestyle`\] Implement `redundant-backslash` (`E502`)
+
+Your pull request will be reviewed by a maintainer, which may involve a few rounds of iteration
 prior to merging.
 
 ### Project Structure
@@ -111,8 +123,8 @@ prior to merging.
 Ruff is structured as a monorepo with a [flat crate structure](https://matklad.github.io/2021/08/22/large-rust-workspaces.html),
 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.
+The vast majority of the code, including all lint rules, lives in the `ruff_linter` 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:
 
@@ -185,11 +197,14 @@ and calling out to lint rule analyzer functions as it goes.
 If you need to inspect the AST, you can run `cargo dev print-ast` with a Python file. Grep
 for the `Diagnostic::new` invocations to understand how other, similar rules are implemented.
 
-Once you're satisfied with your code, add tests for your rule. See [rule testing](#rule-testing-fixtures-and-snapshots)
-for more details.
+Once you're satisfied with your code, add tests for your rule
+(see: [rule testing](#rule-testing-fixtures-and-snapshots)), and regenerate the documentation and
+associated assets (like our JSON Schema) with `cargo dev generate-all`.
 
-Finally, regenerate the documentation and other generated assets (like our JSON Schema) with:
-`cargo dev generate-all`.
+Finally, submit a pull request, and include the category, rule name, and rule code in the title, as
+in:
+
+> \[`pycodestyle`\] Implement `redundant-backslash` (`E502`)
 
 #### Rule naming convention
 
@@ -231,7 +246,7 @@ Once you've completed the code for the rule itself, you can define tests with th
     For example, if you're adding a new rule named `E402`, you would run:
 
     ```shell
-    cargo run -p ruff -- check crates/ruff_linter/resources/test/fixtures/pycodestyle/E402.py --no-cache --select E402
+    cargo run -p ruff -- check crates/ruff_linter/resources/test/fixtures/pycodestyle/E402.py --no-cache --preview --select E402
     ```
 
     **Note:** Only a subset of rules are enabled by default. When testing a new rule, ensure that
@@ -302,7 +317,7 @@ To preview any changes to the documentation locally:
     ```
 
 The documentation should then be available locally at
-[http://127.0.0.1:8000/docs/](http://127.0.0.1:8000/docs/).
+[http://127.0.0.1:8000/ruff/](http://127.0.0.1:8000/ruff/).
 
 ## Release Process
 
@@ -315,13 +330,13 @@ even patch releases may contain [non-backwards-compatible changes](https://semve
 
 ### Creating a new release
 
-We use an experimental in-house tool for managing releases.
-
-1. Install `rooster`: `pip install git+https://github.com/zanieb/rooster@main`
-1. Run `rooster release`; this command will:
+1. Install `uv`: `curl -LsSf https://astral.sh/uv/install.sh | sh`
+1. Run `./scripts/release/bump.sh`; this command will:
+    - Generate a temporary virtual environment with `rooster`
     - Generate a changelog entry in `CHANGELOG.md`
     - Update versions in `pyproject.toml` and `Cargo.toml`
     - Update references to versions in the `README.md` and documentation
+    - Display contributors for the release
 1. The changelog should then be editorialized for consistency
     - Often labels will be missing from pull requests they will need to be manually organized into the proper section
     - Changes should be edited to be user-facing descriptions, avoiding internal details
@@ -345,7 +360,7 @@ We use an experimental in-house tool for managing releases.
     1. Open the draft release in the GitHub release section
     1. Copy the changelog for the release into the GitHub release
         - See previous releases for formatting of section headers
-    1. Generate the contributor list with `rooster contributors` and add to the release notes
+    1. Append the contributors from the `bump.sh` script
 1. If needed, [update the schemastore](https://github.com/astral-sh/ruff/blob/main/scripts/update_schemastore.py).
     1. One can determine if an update is needed when
         `git diff old-version-tag new-version-tag -- ruff.schema.json` returns a non-empty diff.
@@ -373,6 +388,11 @@ We have several ways of benchmarking and profiling Ruff:
 - Microbenchmarks which run the linter or the formatter on individual files. These run on pull requests.
 - Profiling the linter on either the microbenchmarks or entire projects
 
+> \[!NOTE\]
+> When running benchmarks, ensure that your CPU is otherwise idle (e.g., close any background
+> applications, like web browsers). You may also want to switch your CPU to a "performance"
+> mode, if it exists, especially when benchmarking short-lived processes.
+
 ### CPython Benchmark
 
 First, clone [CPython](https://github.com/python/cpython). It's a large and diverse Python codebase,
@@ -794,8 +814,8 @@ To understand Ruff's import categorization system, we first need to define two c
     "project root".)
 - "Package root": The top-most directory defining the Python package that includes a given Python
     file. To find the package root for a given Python file, traverse up its parent directories until
-    you reach a parent directory that doesn't contain an `__init__.py` file (and isn't marked as
-    a [namespace package](https://docs.astral.sh/ruff/settings/#namespace-packages)); take the directory
+    you reach a parent directory that doesn't contain an `__init__.py` file (and isn't in a subtree
+    marked as a [namespace package](https://docs.astral.sh/ruff/settings/#namespace-packages)); take the directory
     just before that, i.e., the first directory in the package.
 
 For example, given:

Cargo.toml

@@ -12,102 +12,113 @@ authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
 license = "MIT"
 
 [workspace.dependencies]
-aho-corasick = { version = "1.1.2" }
+aho-corasick = { version = "1.1.3" }
 annotate-snippets = { version = "0.9.2", features = ["color"] }
-anyhow = { version = "1.0.79" }
-argfile = { version = "0.1.6" }
-assert_cmd = { version = "2.0.13" }
+anyhow = { version = "1.0.80" }
+argfile = { version = "0.2.0" }
 bincode = { version = "1.3.3" }
-bitflags = { version = "2.4.1" }
+bitflags = { version = "2.5.0" }
+bstr = { version = "1.9.1" }
 cachedir = { version = "0.3.1" }
-chrono = { version = "0.4.33", default-features = false, features = ["clock"] }
-clap = { version = "4.4.18", features = ["derive"] }
+chrono = { version = "0.4.35", default-features = false, features = ["clock"] }
+clap = { version = "4.5.3", features = ["derive"] }
 clap_complete_command = { version = "0.5.1" }
-clearscreen = { version = "2.0.0" }
-codspeed-criterion-compat = { version = "2.3.3", default-features = false }
+clearscreen = { version = "3.0.0" }
+codspeed-criterion-compat = { version = "2.6.0", default-features = false }
 colored = { version = "2.1.0" }
-configparser = { version = "3.0.3" }
 console_error_panic_hook = { version = "0.1.7" }
 console_log = { version = "1.0.0" }
-countme = { version ="3.0.1"}
+countme = { version = "3.0.1" }
 criterion = { version = "0.5.1", default-features = false }
+crossbeam-channel = { version = "0.5.12" }
+dashmap = { version = "5.5.3" }
 dirs = { version = "5.0.0" }
 drop_bomb = { version = "0.1.5" }
-env_logger = { version ="0.10.1"}
+env_logger = { version = "0.11.0" }
 fern = { version = "0.6.1" }
 filetime = { version = "0.2.23" }
-fs-err = { version ="2.11.0"}
+fs-err = { version = "2.11.0" }
 glob = { version = "0.3.1" }
 globset = { version = "0.4.14" }
-hexf-parse = { version ="0.2.1"}
+hashbrown = "0.14.3"
+hexf-parse = { version = "0.2.1" }
 ignore = { version = "0.4.22" }
-imara-diff ={ version = "0.1.5"}
+imara-diff = { version = "0.1.5" }
 imperative = { version = "1.0.4" }
-indicatif ={ version = "0.17.7"}
-indoc ={ version = "2.0.4"}
-insta = { version = "1.34.0", feature = ["filters", "glob"] }
-insta-cmd = { version = "0.4.0" }
-is-macro = { version = "0.3.4" }
+indexmap = { version = "2.2.6" }
+indicatif = { version = "0.17.8" }
+indoc = { version = "2.0.4" }
+insta = { version = "1.35.1", feature = ["filters", "glob"] }
+insta-cmd = { version = "0.6.0" }
+is-macro = { version = "0.3.5" }
 is-wsl = { version = "0.4.0" }
-itertools = { version = "0.12.0" }
-js-sys = { version = "0.3.67" }
-lalrpop-util = { version = "0.20.0", default-features = false }
+itertools = { version = "0.12.1" }
+js-sys = { version = "0.3.69" }
+jod-thread = { version = "0.1.2" }
 lexical-parse-float = { version = "0.8.0", features = ["format"] }
+libc = { version = "0.2.153" }
 libcst = { version = "1.1.0", default-features = false }
 log = { version = "0.4.17" }
-memchr = { version = "2.6.4" }
-mimalloc = { version ="0.1.39"}
+lsp-server = { version = "0.7.6" }
+lsp-types = { version = "0.95.0", features = ["proposed"] }
+matchit = { version = "0.8.1" }
+memchr = { version = "2.7.1" }
+mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
 notify = { version = "6.1.1" }
+num_cpus = { version = "1.16.0" }
 once_cell = { version = "1.19.0" }
 path-absolutize = { version = "3.1.1" }
+path-slash = { version = "0.2.1" }
 pathdiff = { version = "0.2.1" }
-pep440_rs = { version = "0.4.0", features = ["serde"] }
+parking_lot = "0.12.1"
+pep440_rs = { version = "0.6.0", features = ["serde"] }
 pretty_assertions = "1.3.0"
-proc-macro2 = { version = "1.0.78" }
-pyproject-toml = { version = "0.8.1" }
-quick-junit = { version = "0.3.5" }
+proc-macro2 = { version = "1.0.79" }
+pyproject-toml = { version = "0.9.0" }
+quick-junit = { version = "0.4.0" }
 quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }
-rayon = { version = "1.8.1" }
+rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 result-like = { version = "0.5.0" }
 rustc-hash = { version = "1.1.0" }
 schemars = { version = "0.8.16" }
-seahash = { version ="4.1.0"}
-semver = { version = "1.0.21" }
-serde = { version = "1.0.196", features = ["derive"] }
-serde-wasm-bindgen = { version = "0.6.3" }
+seahash = { version = "4.1.0" }
+serde = { version = "1.0.197", features = ["derive"] }
+serde-wasm-bindgen = { version = "0.6.4" }
 serde_json = { version = "1.0.113" }
 serde_test = { version = "1.0.152" }
 serde_with = { version = "3.6.0", default-features = false, features = ["macros"] }
 shellexpand = { version = "3.0.0" }
-shlex = { version ="1.3.0"}
+shlex = { version = "1.3.0" }
 similar = { version = "2.4.0", features = ["inline"] }
-smallvec = { version = "1.13.1" }
+smallvec = { version = "1.13.2" }
 static_assertions = "1.1.0"
-strum = { version = "0.25.0", features = ["strum_macros"] }
-strum_macros = { version = "0.25.3" }
-syn = { version = "2.0.40" }
-tempfile = { version ="3.9.0"}
+strum = { version = "0.26.0", features = ["strum_macros"] }
+strum_macros = { version = "0.26.0" }
+syn = { version = "2.0.55" }
+tempfile = { version = "3.9.0" }
 test-case = { version = "3.3.1" }
-thiserror = { version = "1.0.51" }
-tikv-jemallocator = { version ="0.5.0"}
-toml = { version = "0.8.8" }
+thiserror = { version = "1.0.58" }
+tikv-jemallocator = { version = "0.5.0" }
+toml = { version = "0.8.11" }
 tracing = { version = "0.1.40" }
 tracing-indicatif = { version = "0.3.6" }
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
+tracing-tree = { version = "0.3.0" }
 typed-arena = { version = "2.0.2" }
-unic-ucd-category = { version ="0.9"}
+unic-ucd-category = { version = "0.9" }
 unicode-ident = { version = "1.0.12" }
 unicode-width = { version = "0.1.11" }
-unicode_names2 = { version = "1.2.1" }
-ureq = { version = "2.9.1" }
+unicode_names2 = { version = "1.2.2" }
+unicode-normalization = { version = "0.1.23" }
+ureq = { version = "2.9.6" }
 url = { version = "2.5.0" }
 uuid = { version = "1.6.1", features = ["v4", "fast-rng", "macro-diagnostics", "js"] }
 walkdir = { version = "2.3.2" }
-wasm-bindgen = { version = "0.2.84" }
-wasm-bindgen-test = { version = "0.3.40" }
+wasm-bindgen = { version = "0.2.92" }
+wasm-bindgen-test = { version = "0.3.42" }
 wild = { version = "2" }
 
 [workspace.lints.rust]

README.md

@@ -4,11 +4,12 @@
 
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![image](https://img.shields.io/pypi/v/ruff.svg)](https://pypi.python.org/pypi/ruff)
-[![image](https://img.shields.io/pypi/l/ruff.svg)](https://pypi.python.org/pypi/ruff)
+[![image](https://img.shields.io/pypi/l/ruff.svg)](https://github.com/astral-sh/ruff/blob/main/LICENSE)
 [![image](https://img.shields.io/pypi/pyversions/ruff.svg)](https://pypi.python.org/pypi/ruff)
 [![Actions status](https://github.com/astral-sh/ruff/workflows/CI/badge.svg)](https://github.com/astral-sh/ruff/actions)
+[![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?logo=discord&logoColor=white)](https://discord.com/invite/astral-sh)
 
-[**Discord**](https://discord.gg/c9MhzV8aU5) | [**Docs**](https://docs.astral.sh/ruff/) | [**Playground**](https://play.ruff.rs/)
+[**Docs**](https://docs.astral.sh/ruff/) | [**Playground**](https://play.ruff.rs/)
 
 An extremely fast Python linter and code formatter, written in Rust.
 
@@ -31,7 +32,7 @@ An extremely fast Python linter and code formatter, written in Rust.
 - ⚖️ Drop-in parity with [Flake8](https://docs.astral.sh/ruff/faq/#how-does-ruff-compare-to-flake8), isort, and Black
 - 📦 Built-in caching, to avoid re-analyzing unchanged files
 - 🔧 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
+- 📏 Over [800 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
     [VS Code](https://github.com/astral-sh/ruff-vscode) and [more](https://github.com/astral-sh/ruff-lsp)
@@ -49,6 +50,7 @@ times faster than any individual tool.
 Ruff is extremely actively developed and used in major open-source projects like:
 
 - [Apache Airflow](https://github.com/apache/airflow)
+- [Apache Superset](https://github.com/apache/superset)
 - [FastAPI](https://github.com/tiangolo/fastapi)
 - [Hugging Face](https://github.com/huggingface/transformers)
 - [Pandas](https://github.com/pandas-dev/pandas)
@@ -128,7 +130,7 @@ and with [a variety of other package managers](https://docs.astral.sh/ruff/insta
 To run Ruff as a linter, try any of the following:
 
 ```shell
-ruff check .                        # Lint all files in the current directory (and any subdirectories).
+ruff check                          # Lint all files in the current directory (and any subdirectories).
 ruff check path/to/code/            # Lint all files in `/path/to/code` (and any subdirectories).
 ruff check path/to/code/*.py        # Lint all `.py` files in `/path/to/code`.
 ruff check path/to/code/to/file.py  # Lint `file.py`.
@@ -138,7 +140,7 @@ ruff check @arguments.txt           # Lint using an input file, treating its con
 Or, to run Ruff as a formatter:
 
 ```shell
-ruff format .                        # Format all files in the current directory (and any subdirectories).
+ruff format                          # Format all files in the current directory (and any subdirectories).
 ruff format path/to/code/            # Format all files in `/path/to/code` (and any subdirectories).
 ruff format path/to/code/*.py        # Format all `.py` files in `/path/to/code`.
 ruff format path/to/code/to/file.py  # Format `file.py`.
@@ -150,7 +152,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.1.15
+  rev: v0.4.2
   hooks:
     # Run the linter.
     - id: ruff
@@ -172,7 +174,7 @@ jobs:
   ruff:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: chartboost/ruff-action@v1
 ```
 
@@ -182,10 +184,9 @@ Ruff can be configured through a `pyproject.toml`, `ruff.toml`, or `.ruff.toml`
 [_Configuration_](https://docs.astral.sh/ruff/configuration/), or [_Settings_](https://docs.astral.sh/ruff/settings/)
 for a complete list of all configuration options).
 
-If left unspecified, Ruff's default configuration is equivalent to:
+If left unspecified, Ruff's default configuration is equivalent to the following `ruff.toml` file:
 
 ```toml
-[tool.ruff]
 # Exclude a variety of commonly ignored directories.
 exclude = [
     ".bzr",
@@ -223,7 +224,7 @@ indent-width = 4
 # Assume Python 3.8
 target-version = "py38"
 
-[tool.ruff.lint]
+[lint]
 # Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
 select = ["E4", "E7", "E9", "F"]
 ignore = []
@@ -235,7 +236,7 @@ unfixable = []
 # Allow unused variables when underscore-prefixed.
 dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 
-[tool.ruff.format]
+[format]
 # Like Black, use double quotes for strings.
 quote-style = "double"
 
@@ -249,11 +250,20 @@ skip-magic-trailing-comma = false
 line-ending = "auto"
 ```
 
-Some configuration options can be provided via the command-line, such as those related to
-rule enablement and disablement, file discovery, and logging level:
+Note that, in a `pyproject.toml`, each section header should be prefixed with `tool.ruff`. For
+example, `[lint]` should be replaced with `[tool.ruff.lint]`.
+
+Some configuration options can be provided via dedicated command-line arguments, such as those
+related to rule enablement and disablement, file discovery, and logging level:
 
 ```shell
-ruff check path/to/code/ --select F401 --select F403 --quiet
+ruff check --select F401 --select F403 --quiet
+```
+
+The remaining configuration options can be provided through a catch-all `--config` argument:
+
+```shell
+ruff check --config "lint.per-file-ignores = {'some_file.py' = ['F841']}"
 ```
 
 See `ruff help` for more on Ruff's top-level commands, or `ruff help check` and `ruff help format`
@@ -263,7 +273,7 @@ for more on the linting and formatting commands, respectively.
 
 <!-- Begin section: Rules -->
 
-**Ruff supports over 700 lint rules**, many of which are inspired by popular tools like Flake8,
+**Ruff supports over 800 lint rules**, many of which are inspired by popular tools like Flake8,
 isort, pyupgrade, and others. Regardless of the rule's origin, Ruff re-implements every rule in
 Rust as a first-party feature.
 
@@ -341,14 +351,14 @@ For a complete enumeration of the supported rules, see [_Rules_](https://docs.as
 Contributions are welcome and highly appreciated. To get started, check out the
 [**contributing guidelines**](https://docs.astral.sh/ruff/contributing/).
 
-You can also join us on [**Discord**](https://discord.gg/c9MhzV8aU5).
+You can also join us on [**Discord**](https://discord.com/invite/astral-sh).
 
 ## Support
 
 Having trouble? Check out the existing issues on [**GitHub**](https://github.com/astral-sh/ruff/issues),
 or feel free to [**open a new one**](https://github.com/astral-sh/ruff/issues/new).
 
-You can also ask for help on [**Discord**](https://discord.gg/c9MhzV8aU5).
+You can also ask for help on [**Discord**](https://discord.com/invite/astral-sh).
 
 ## Acknowledgements
 
@@ -378,6 +388,7 @@ Ruff is released under the MIT license.
 
 Ruff is used by a number of major open-source projects and companies, including:
 
+- [Albumentations](https://github.com/albumentations-team/albumentations)
 - Amazon ([AWS SAM](https://github.com/aws/serverless-application-model))
 - Anthropic ([Python SDK](https://github.com/anthropics/anthropic-sdk-python))
 - [Apache Airflow](https://github.com/apache/airflow)
@@ -404,6 +415,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [Ibis](https://github.com/ibis-project/ibis)
 - [ivy](https://github.com/unifyai/ivy)
 - [Jupyter](https://github.com/jupyter-server/jupyter_server)
+- [Kraken Tech](https://kraken.tech/)
 - [LangChain](https://github.com/hwchase17/langchain)
 - [Litestar](https://litestar.dev/)
 - [LlamaIndex](https://github.com/jerryjliu/llama_index)
@@ -418,6 +430,7 @@ 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)
+- [Nokia](https://nokia.com/)
 - [NoneBot](https://github.com/nonebot/nonebot2)
 - [NumPyro](https://github.com/pyro-ppl/numpyro)
 - [ONNX](https://github.com/onnx/onnx)
@@ -433,6 +446,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 - [PyInstaller](https://github.com/pyinstaller/pyinstaller)
 - [PyMC](https://github.com/pymc-devs/pymc/)
 - [PyMC-Marketing](https://github.com/pymc-labs/pymc-marketing)
+- [pytest](https://github.com/pytest-dev/pytest)
 - [PyTorch](https://github.com/pytorch/pytorch)
 - [Pydantic](https://github.com/pydantic/pydantic)
 - [Pylint](https://github.com/PyCQA/pylint)
@@ -463,7 +477,7 @@ Ruff is used by a number of major open-source projects and companies, including:
 
 ### Show Your Support
 
-If you're using Ruff, consider adding the Ruff badge to project's `README.md`:
+If you're using Ruff, consider adding the Ruff badge to your project's `README.md`:
 
 ```md
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
@@ -485,10 +499,10 @@ If you're using Ruff, consider adding the Ruff badge to project's `README.md`:
 
 ## License
 
-MIT
+This repository is licensed under the [MIT License](https://github.com/astral-sh/ruff/blob/main/LICENSE)
 
 <div align="center">
   <a target="_blank" href="https://astral.sh" style="background:none">
-    <img src="https://raw.githubusercontent.com/astral-sh/ruff/main/assets/svg/Astral.svg">
+    <img src="https://raw.githubusercontent.com/astral-sh/ruff/main/assets/svg/Astral.svg" alt="Made by Astral">
   </a>
 </div>

_typos.toml

@@ -3,9 +3,17 @@
 extend-exclude = ["**/resources/**/*", "**/snapshots/**/*"]
 
 [default.extend-words]
+"arange" = "arange"  # e.g. `numpy.arange`
 hel = "hel"
 whos = "whos"
 spawnve = "spawnve"
 ned = "ned"
+pn = "pn"  # `import panel as pd` is a thing
 poit = "poit"
 BA = "BA" # acronym for "Bad Allowed", used in testing.
+
+[default]
+extend-ignore-re = [
+  # Line ignore with trailing "spellchecker:disable-line"
+  "(?Rm)^.*#\\s*spellchecker:disable-line$"
+]

crates/red_knot/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "red_knot"
+version = "0.1.0"
+edition.workspace = true
+rust-version.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+repository.workspace = true
+authors.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+ruff_python_parser = { path = "../ruff_python_parser" }
+ruff_python_ast = { path = "../ruff_python_ast" }
+ruff_python_trivia = { path = "../ruff_python_trivia" }
+ruff_text_size = { path = "../ruff_text_size" }
+ruff_index = { path = "../ruff_index" }
+ruff_notebook = { path = "../ruff_notebook" }
+
+anyhow = { workspace = true }
+bitflags = { workspace = true }
+ctrlc = "3.4.4"
+crossbeam-channel = { workspace = true }
+dashmap = { workspace = true }
+hashbrown = { workspace = true }
+indexmap = { workspace = true }
+log = { workspace = true }
+notify = { workspace = true }
+parking_lot = { workspace = true }
+rayon = { workspace = true }
+rustc-hash = { workspace = true }
+smallvec = { workspace = true }
+smol_str = "0.2.1"
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+tracing-tree = { workspace = true }
+
+[dev-dependencies]
+textwrap = "0.16.1"
+tempfile = { workspace = true }
+
+[lints]
+workspace = true

crates/red_knot/src/ast_ids.rs

@@ -0,0 +1,415 @@
+use std::any::type_name;
+use std::fmt::{Debug, Formatter};
+use std::hash::{Hash, Hasher};
+use std::marker::PhantomData;
+
+use rustc_hash::FxHashMap;
+
+use ruff_index::{Idx, IndexVec};
+use ruff_python_ast::visitor::preorder;
+use ruff_python_ast::visitor::preorder::{PreorderVisitor, TraversalSignal};
+use ruff_python_ast::{
+    AnyNodeRef, AstNode, ExceptHandler, ExceptHandlerExceptHandler, Expr, MatchCase, ModModule,
+    NodeKind, Parameter, Stmt, StmtAnnAssign, StmtAssign, StmtAugAssign, StmtClassDef,
+    StmtFunctionDef, StmtGlobal, StmtImport, StmtImportFrom, StmtNonlocal, StmtTypeAlias,
+    TypeParam, TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple, WithItem,
+};
+use ruff_text_size::{Ranged, TextRange};
+
+/// A type agnostic ID that uniquely identifies an AST node in a file.
+#[ruff_index::newtype_index]
+pub struct AstId;
+
+/// A typed ID that uniquely identifies an AST node in a file.
+///
+/// This is different from [`AstId`] in that it is a combination of ID and the type of the node the ID identifies.
+/// Typing the ID prevents mixing IDs of different node types and allows to restrict the API to only accept
+/// nodes for which an ID has been created (not all AST nodes get an ID).
+pub struct TypedAstId<N: HasAstId> {
+    erased: AstId,
+    _marker: PhantomData<fn() -> N>,
+}
+
+impl<N: HasAstId> TypedAstId<N> {
+    /// Upcasts this ID from a more specific node type to a more general node type.
+    pub fn upcast<M: HasAstId>(self) -> TypedAstId<M>
+    where
+        N: Into<M>,
+    {
+        TypedAstId {
+            erased: self.erased,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<N: HasAstId> Copy for TypedAstId<N> {}
+impl<N: HasAstId> Clone for TypedAstId<N> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<N: HasAstId> PartialEq for TypedAstId<N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.erased == other.erased
+    }
+}
+
+impl<N: HasAstId> Eq for TypedAstId<N> {}
+impl<N: HasAstId> Hash for TypedAstId<N> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.erased.hash(state);
+    }
+}
+
+impl<N: HasAstId> Debug for TypedAstId<N> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("TypedAstId")
+            .field(&self.erased)
+            .field(&type_name::<N>())
+            .finish()
+    }
+}
+
+pub struct AstIds {
+    ids: IndexVec<AstId, NodeKey>,
+    reverse: FxHashMap<NodeKey, AstId>,
+}
+
+impl AstIds {
+    // TODO rust analyzer doesn't allocate an ID for every node. It only allocates ids for
+    //  nodes with a corresponding HIR element, that is nodes that are definitions.
+    pub fn from_module(module: &ModModule) -> Self {
+        let mut visitor = AstIdsVisitor::default();
+
+        // TODO: visit_module?
+        // Make sure we visit the root
+        visitor.create_id(module);
+        visitor.visit_body(&module.body);
+
+        while let Some(deferred) = visitor.deferred.pop() {
+            match deferred {
+                DeferredNode::FunctionDefinition(def) => {
+                    def.visit_preorder(&mut visitor);
+                }
+                DeferredNode::ClassDefinition(def) => def.visit_preorder(&mut visitor),
+            }
+        }
+
+        AstIds {
+            ids: visitor.ids,
+            reverse: visitor.reverse,
+        }
+    }
+
+    /// Returns the ID to the root node.
+    pub fn root(&self) -> NodeKey {
+        self.ids[AstId::new(0)]
+    }
+
+    /// Returns the [`TypedAstId`] for a node.
+    pub fn ast_id<N: HasAstId>(&self, node: &N) -> TypedAstId<N> {
+        let key = node.syntax_node_key();
+        TypedAstId {
+            erased: self.reverse.get(&key).copied().unwrap(),
+            _marker: PhantomData,
+        }
+    }
+
+    /// Returns the [`TypedAstId`] for the node identified with the given [`TypedNodeKey`].
+    pub fn ast_id_for_key<N: HasAstId>(&self, node: &TypedNodeKey<N>) -> TypedAstId<N> {
+        let ast_id = self.ast_id_for_node_key(node.inner);
+
+        TypedAstId {
+            erased: ast_id,
+            _marker: PhantomData,
+        }
+    }
+
+    /// Returns the untyped [`AstId`] for the node identified by the given `node` key.
+    pub fn ast_id_for_node_key(&self, node: NodeKey) -> AstId {
+        self.reverse
+            .get(&node)
+            .copied()
+            .expect("Can't find node in AstIds map.")
+    }
+
+    /// Returns the [`TypedNodeKey`] for the node identified by the given [`TypedAstId`].
+    pub fn key<N: HasAstId>(&self, id: TypedAstId<N>) -> TypedNodeKey<N> {
+        let syntax_key = self.ids[id.erased];
+
+        TypedNodeKey::new(syntax_key).unwrap()
+    }
+
+    pub fn node_key<H: HasAstId>(&self, id: TypedAstId<H>) -> NodeKey {
+        self.ids[id.erased]
+    }
+}
+
+impl std::fmt::Debug for AstIds {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let mut map = f.debug_map();
+        for (key, value) in self.ids.iter_enumerated() {
+            map.entry(&key, &value);
+        }
+
+        map.finish()
+    }
+}
+
+impl PartialEq for AstIds {
+    fn eq(&self, other: &Self) -> bool {
+        self.ids == other.ids
+    }
+}
+
+impl Eq for AstIds {}
+
+#[derive(Default)]
+struct AstIdsVisitor<'a> {
+    ids: IndexVec<AstId, NodeKey>,
+    reverse: FxHashMap<NodeKey, AstId>,
+    deferred: Vec<DeferredNode<'a>>,
+}
+
+impl<'a> AstIdsVisitor<'a> {
+    fn create_id<A: HasAstId>(&mut self, node: &A) {
+        let node_key = node.syntax_node_key();
+
+        let id = self.ids.push(node_key);
+        self.reverse.insert(node_key, id);
+    }
+}
+
+impl<'a> PreorderVisitor<'a> for AstIdsVisitor<'a> {
+    fn visit_stmt(&mut self, stmt: &'a Stmt) {
+        match stmt {
+            Stmt::FunctionDef(def) => {
+                self.create_id(def);
+                self.deferred.push(DeferredNode::FunctionDefinition(def));
+                return;
+            }
+            // TODO defer visiting the assignment body, type alias parameters etc?
+            Stmt::ClassDef(def) => {
+                self.create_id(def);
+                self.deferred.push(DeferredNode::ClassDefinition(def));
+                return;
+            }
+            Stmt::Expr(_) => {
+                // Skip
+                return;
+            }
+            Stmt::Return(_) => {}
+            Stmt::Delete(_) => {}
+            Stmt::Assign(assignment) => self.create_id(assignment),
+            Stmt::AugAssign(assignment) => {
+                self.create_id(assignment);
+            }
+            Stmt::AnnAssign(assignment) => self.create_id(assignment),
+            Stmt::TypeAlias(assignment) => self.create_id(assignment),
+            Stmt::For(_) => {}
+            Stmt::While(_) => {}
+            Stmt::If(_) => {}
+            Stmt::With(_) => {}
+            Stmt::Match(_) => {}
+            Stmt::Raise(_) => {}
+            Stmt::Try(_) => {}
+            Stmt::Assert(_) => {}
+            Stmt::Import(import) => self.create_id(import),
+            Stmt::ImportFrom(import_from) => self.create_id(import_from),
+            Stmt::Global(global) => self.create_id(global),
+            Stmt::Nonlocal(non_local) => self.create_id(non_local),
+            Stmt::Pass(_) => {}
+            Stmt::Break(_) => {}
+            Stmt::Continue(_) => {}
+            Stmt::IpyEscapeCommand(_) => {}
+        }
+
+        preorder::walk_stmt(self, stmt);
+    }
+
+    fn visit_expr(&mut self, _expr: &'a Expr) {}
+
+    fn visit_parameter(&mut self, parameter: &'a Parameter) {
+        self.create_id(parameter);
+        preorder::walk_parameter(self, parameter);
+    }
+
+    fn visit_except_handler(&mut self, except_handler: &'a ExceptHandler) {
+        match except_handler {
+            ExceptHandler::ExceptHandler(except_handler) => {
+                self.create_id(except_handler);
+            }
+        }
+
+        preorder::walk_except_handler(self, except_handler);
+    }
+
+    fn visit_with_item(&mut self, with_item: &'a WithItem) {
+        self.create_id(with_item);
+        preorder::walk_with_item(self, with_item);
+    }
+
+    fn visit_match_case(&mut self, match_case: &'a MatchCase) {
+        self.create_id(match_case);
+        preorder::walk_match_case(self, match_case);
+    }
+
+    fn visit_type_param(&mut self, type_param: &'a TypeParam) {
+        self.create_id(type_param);
+    }
+}
+
+enum DeferredNode<'a> {
+    FunctionDefinition(&'a StmtFunctionDef),
+    ClassDefinition(&'a StmtClassDef),
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub struct TypedNodeKey<N: AstNode> {
+    /// The type erased node key.
+    inner: NodeKey,
+    _marker: PhantomData<fn() -> N>,
+}
+
+impl<N: AstNode> TypedNodeKey<N> {
+    pub fn from_node(node: &N) -> Self {
+        let inner = NodeKey {
+            kind: node.as_any_node_ref().kind(),
+            range: node.range(),
+        };
+        Self {
+            inner,
+            _marker: PhantomData,
+        }
+    }
+
+    pub fn new(node_key: NodeKey) -> Option<Self> {
+        N::can_cast(node_key.kind).then_some(TypedNodeKey {
+            inner: node_key,
+            _marker: PhantomData,
+        })
+    }
+
+    pub fn resolve<'a>(&self, root: AnyNodeRef<'a>) -> Option<N::Ref<'a>> {
+        let node_ref = self.inner.resolve(root)?;
+
+        Some(N::cast_ref(node_ref).unwrap())
+    }
+
+    pub fn resolve_unwrap<'a>(&self, root: AnyNodeRef<'a>) -> N::Ref<'a> {
+        self.resolve(root).expect("node should resolve")
+    }
+
+    pub fn erased(&self) -> &NodeKey {
+        &self.inner
+    }
+}
+
+struct FindNodeKeyVisitor<'a> {
+    key: NodeKey,
+    result: Option<AnyNodeRef<'a>>,
+}
+
+impl<'a> PreorderVisitor<'a> for FindNodeKeyVisitor<'a> {
+    fn enter_node(&mut self, node: AnyNodeRef<'a>) -> TraversalSignal {
+        if self.result.is_some() {
+            return TraversalSignal::Skip;
+        }
+
+        if node.range() == self.key.range && node.kind() == self.key.kind {
+            self.result = Some(node);
+            TraversalSignal::Skip
+        } else if node.range().contains_range(self.key.range) {
+            TraversalSignal::Traverse
+        } else {
+            TraversalSignal::Skip
+        }
+    }
+
+    fn visit_body(&mut self, body: &'a [Stmt]) {
+        // TODO it would be more efficient to use binary search instead of linear
+        for stmt in body {
+            if stmt.range().start() > self.key.range.end() {
+                break;
+            }
+
+            self.visit_stmt(stmt);
+        }
+    }
+}
+
+// TODO an alternative to this is to have a `NodeId` on each node (in increasing order depending on the position).
+//  This would allow to reduce the size of this to a u32.
+//  What would be nice if we could use an `Arc::weak_ref` here but that only works if we use
+//   `Arc` internally
+// TODO: Implement the logic to resolve a node, given a db (and the correct file).
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub struct NodeKey {
+    kind: NodeKind,
+    range: TextRange,
+}
+
+impl NodeKey {
+    pub fn resolve<'a>(&self, root: AnyNodeRef<'a>) -> Option<AnyNodeRef<'a>> {
+        // We need to do a binary search here. Only traverse into a node if the range is withint the node
+        let mut visitor = FindNodeKeyVisitor {
+            key: *self,
+            result: None,
+        };
+
+        if visitor.enter_node(root) == TraversalSignal::Traverse {
+            root.visit_preorder(&mut visitor);
+        }
+
+        visitor.result
+    }
+}
+
+/// Marker trait implemented by AST nodes for which we extract the `AstId`.
+pub trait HasAstId: AstNode {
+    fn node_key(&self) -> TypedNodeKey<Self>
+    where
+        Self: Sized,
+    {
+        TypedNodeKey {
+            inner: self.syntax_node_key(),
+            _marker: PhantomData,
+        }
+    }
+
+    fn syntax_node_key(&self) -> NodeKey {
+        NodeKey {
+            kind: self.as_any_node_ref().kind(),
+            range: self.range(),
+        }
+    }
+}
+
+impl HasAstId for StmtFunctionDef {}
+impl HasAstId for StmtClassDef {}
+impl HasAstId for StmtAnnAssign {}
+impl HasAstId for StmtAugAssign {}
+impl HasAstId for StmtAssign {}
+impl HasAstId for StmtTypeAlias {}
+
+impl HasAstId for ModModule {}
+
+impl HasAstId for StmtImport {}
+
+impl HasAstId for StmtImportFrom {}
+
+impl HasAstId for Parameter {}
+
+impl HasAstId for TypeParam {}
+impl HasAstId for Stmt {}
+impl HasAstId for TypeParamTypeVar {}
+impl HasAstId for TypeParamTypeVarTuple {}
+impl HasAstId for TypeParamParamSpec {}
+impl HasAstId for StmtGlobal {}
+impl HasAstId for StmtNonlocal {}
+
+impl HasAstId for ExceptHandlerExceptHandler {}
+impl HasAstId for WithItem {}
+impl HasAstId for MatchCase {}

crates/red_knot/src/cache.rs

@@ -0,0 +1,158 @@
+use std::fmt::Formatter;
+use std::hash::Hash;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use dashmap::mapref::entry::Entry;
+
+use crate::FxDashMap;
+
+/// Simple key value cache that locks on a per-key level.
+pub struct KeyValueCache<K, V> {
+    map: FxDashMap<K, V>,
+    statistics: CacheStatistics,
+}
+
+impl<K, V> KeyValueCache<K, V>
+where
+    K: Eq + Hash + Clone,
+    V: Clone,
+{
+    pub fn try_get(&self, key: &K) -> Option<V> {
+        if let Some(existing) = self.map.get(key) {
+            self.statistics.hit();
+            Some(existing.clone())
+        } else {
+            self.statistics.miss();
+            None
+        }
+    }
+
+    pub fn get<F>(&self, key: &K, compute: F) -> V
+    where
+        F: FnOnce(&K) -> V,
+    {
+        match self.map.entry(key.clone()) {
+            Entry::Occupied(cached) => {
+                self.statistics.hit();
+
+                cached.get().clone()
+            }
+            Entry::Vacant(vacant) => {
+                self.statistics.miss();
+
+                let value = compute(key);
+                vacant.insert(value.clone());
+                value
+            }
+        }
+    }
+
+    pub fn set(&mut self, key: K, value: V) {
+        self.map.insert(key, value);
+    }
+
+    pub fn remove(&mut self, key: &K) -> Option<V> {
+        self.map.remove(key).map(|(_, value)| value)
+    }
+
+    pub fn clear(&mut self) {
+        self.map.clear();
+        self.map.shrink_to_fit();
+    }
+
+    pub fn statistics(&self) -> Option<Statistics> {
+        self.statistics.to_statistics()
+    }
+}
+
+impl<K, V> Default for KeyValueCache<K, V>
+where
+    K: Eq + Hash,
+    V: Clone,
+{
+    fn default() -> Self {
+        Self {
+            map: FxDashMap::default(),
+            statistics: CacheStatistics::default(),
+        }
+    }
+}
+
+impl<K, V> std::fmt::Debug for KeyValueCache<K, V>
+where
+    K: std::fmt::Debug + Eq + Hash,
+    V: std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let mut debug = f.debug_map();
+
+        for entry in &self.map {
+            debug.entry(&entry.value(), &entry.key());
+        }
+
+        debug.finish()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Statistics {
+    pub hits: usize,
+    pub misses: usize,
+}
+
+impl Statistics {
+    #[allow(clippy::cast_precision_loss)]
+    pub fn hit_rate(&self) -> Option<f64> {
+        if self.hits + self.misses == 0 {
+            return None;
+        }
+
+        Some((self.hits as f64) / (self.hits + self.misses) as f64)
+    }
+}
+
+#[cfg(debug_assertions)]
+pub type CacheStatistics = DebugStatistics;
+
+#[cfg(not(debug_assertions))]
+pub type CacheStatistics = ReleaseStatistics;
+
+#[derive(Debug, Default)]
+pub struct DebugStatistics {
+    hits: AtomicUsize,
+    misses: AtomicUsize,
+}
+
+impl DebugStatistics {
+    // TODO figure out appropriate Ordering
+    pub fn hit(&self) {
+        self.hits.fetch_add(1, Ordering::SeqCst);
+    }
+
+    pub fn miss(&self) {
+        self.misses.fetch_add(1, Ordering::SeqCst);
+    }
+
+    pub fn to_statistics(&self) -> Option<Statistics> {
+        let hits = self.hits.load(Ordering::SeqCst);
+        let misses = self.misses.load(Ordering::SeqCst);
+
+        Some(Statistics { hits, misses })
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct ReleaseStatistics;
+
+impl ReleaseStatistics {
+    #[inline]
+    pub const fn hit(&self) {}
+
+    #[inline]
+    pub const fn miss(&self) {}
+
+    #[inline]
+    pub const fn to_statistics(&self) -> Option<Statistics> {
+        None
+    }
+}

crates/red_knot/src/cancellation.rs

@@ -0,0 +1,66 @@
+use std::sync::{Arc, Condvar, Mutex};
+
+#[derive(Debug, Default)]
+pub struct CancellationTokenSource {
+    signal: Arc<(Mutex<bool>, Condvar)>,
+}
+
+impl CancellationTokenSource {
+    pub fn new() -> Self {
+        Self {
+            signal: Arc::new((Mutex::new(false), Condvar::default())),
+        }
+    }
+
+    #[tracing::instrument(level = "trace")]
+    pub fn cancel(&self) {
+        let (cancelled, condvar) = &*self.signal;
+
+        let mut cancelled = cancelled.lock().unwrap();
+
+        if *cancelled {
+            return;
+        }
+
+        *cancelled = true;
+        condvar.notify_all();
+    }
+
+    pub fn is_cancelled(&self) -> bool {
+        let (cancelled, _) = &*self.signal;
+
+        *cancelled.lock().unwrap()
+    }
+
+    pub fn token(&self) -> CancellationToken {
+        CancellationToken {
+            signal: self.signal.clone(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct CancellationToken {
+    signal: Arc<(Mutex<bool>, Condvar)>,
+}
+
+impl CancellationToken {
+    /// Returns `true` if cancellation has been requested.
+    pub fn is_cancelled(&self) -> bool {
+        let (cancelled, _) = &*self.signal;
+
+        *cancelled.lock().unwrap()
+    }
+
+    pub fn wait(&self) {
+        let (bool, condvar) = &*self.signal;
+
+        let lock = condvar
+            .wait_while(bool.lock().unwrap(), |bool| !*bool)
+            .unwrap();
+
+        debug_assert!(*lock);
+
+        drop(lock);
+    }
+}

crates/red_knot/src/db.rs

@@ -0,0 +1,178 @@
+use std::path::Path;
+use std::sync::Arc;
+
+use crate::files::FileId;
+use crate::lint::{Diagnostics, LintSyntaxStorage};
+use crate::module::{Module, ModuleData, ModuleName, ModuleResolver, ModuleSearchPath};
+use crate::parse::{Parsed, ParsedStorage};
+use crate::source::{Source, SourceStorage};
+use crate::symbols::{SymbolId, SymbolTable, SymbolTablesStorage};
+use crate::types::{Type, TypeStore};
+
+pub trait SourceDb {
+    // queries
+    fn file_id(&self, path: &std::path::Path) -> FileId;
+
+    fn file_path(&self, file_id: FileId) -> Arc<std::path::Path>;
+
+    fn source(&self, file_id: FileId) -> Source;
+
+    fn parse(&self, file_id: FileId) -> Parsed;
+
+    fn lint_syntax(&self, file_id: FileId) -> Diagnostics;
+}
+
+pub trait SemanticDb: SourceDb {
+    // queries
+    fn resolve_module(&self, name: ModuleName) -> Option<Module>;
+
+    fn file_to_module(&self, file_id: FileId) -> Option<Module>;
+
+    fn path_to_module(&self, path: &Path) -> Option<Module>;
+
+    fn symbol_table(&self, file_id: FileId) -> Arc<SymbolTable>;
+
+    fn infer_symbol_type(&self, file_id: FileId, symbol_id: SymbolId) -> Type;
+
+    // mutations
+
+    fn add_module(&mut self, path: &Path) -> Option<(Module, Vec<Arc<ModuleData>>)>;
+
+    fn set_module_search_paths(&mut self, paths: Vec<ModuleSearchPath>);
+}
+
+pub trait Db: SemanticDb {}
+
+#[derive(Debug, Default)]
+pub struct SourceJar {
+    pub sources: SourceStorage,
+    pub parsed: ParsedStorage,
+    pub lint_syntax: LintSyntaxStorage,
+}
+
+#[derive(Debug, Default)]
+pub struct SemanticJar {
+    pub module_resolver: ModuleResolver,
+    pub symbol_tables: SymbolTablesStorage,
+    pub type_store: TypeStore,
+}
+
+/// Gives access to a specific jar in the database.
+///
+/// Nope, the terminology isn't borrowed from Java but from Salsa <https://salsa-rs.github.io/salsa/>,
+/// which is an analogy to storing the salsa in different jars.
+///
+/// The basic idea is that each crate can define its own jar and the jars can be combined to a single
+/// database in the top level crate. Each crate also defines its own `Database` trait. The combination of
+/// `Database` trait and the jar allows to write queries in isolation without having to know how they get composed at the upper levels.
+///
+/// Salsa further defines a `HasIngredient` trait which slices the jar to a specific storage (e.g. a specific cache).
+/// We don't need this just jet because we write our queries by hand. We may want a similar trait if we decide
+/// to use a macro to generate the queries.
+pub trait HasJar<T> {
+    /// Gives a read-only reference to the jar.
+    fn jar(&self) -> &T;
+
+    /// Gives a mutable reference to the jar.
+    fn jar_mut(&mut self) -> &mut T;
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use crate::db::{HasJar, SourceDb, SourceJar};
+    use crate::files::{FileId, Files};
+    use crate::lint::{lint_syntax, Diagnostics};
+    use crate::module::{
+        add_module, file_to_module, path_to_module, resolve_module, set_module_search_paths,
+        Module, ModuleData, ModuleName, ModuleSearchPath,
+    };
+    use crate::parse::{parse, Parsed};
+    use crate::source::{source_text, Source};
+    use crate::symbols::{symbol_table, SymbolId, SymbolTable};
+    use crate::types::{infer_symbol_type, Type};
+    use std::path::Path;
+    use std::sync::Arc;
+
+    use super::{SemanticDb, SemanticJar};
+
+    // This can be a partial database used in a single crate for testing.
+    // It would hold fewer data than the full database.
+    #[derive(Debug, Default)]
+    pub(crate) struct TestDb {
+        files: Files,
+        source: SourceJar,
+        semantic: SemanticJar,
+    }
+
+    impl HasJar<SourceJar> for TestDb {
+        fn jar(&self) -> &SourceJar {
+            &self.source
+        }
+
+        fn jar_mut(&mut self) -> &mut SourceJar {
+            &mut self.source
+        }
+    }
+
+    impl HasJar<SemanticJar> for TestDb {
+        fn jar(&self) -> &SemanticJar {
+            &self.semantic
+        }
+
+        fn jar_mut(&mut self) -> &mut SemanticJar {
+            &mut self.semantic
+        }
+    }
+
+    impl SourceDb for TestDb {
+        fn file_id(&self, path: &Path) -> FileId {
+            self.files.intern(path)
+        }
+
+        fn file_path(&self, file_id: FileId) -> Arc<Path> {
+            self.files.path(file_id)
+        }
+
+        fn source(&self, file_id: FileId) -> Source {
+            source_text(self, file_id)
+        }
+
+        fn parse(&self, file_id: FileId) -> Parsed {
+            parse(self, file_id)
+        }
+
+        fn lint_syntax(&self, file_id: FileId) -> Diagnostics {
+            lint_syntax(self, file_id)
+        }
+    }
+
+    impl SemanticDb for TestDb {
+        fn resolve_module(&self, name: ModuleName) -> Option<Module> {
+            resolve_module(self, name)
+        }
+
+        fn file_to_module(&self, file_id: FileId) -> Option<Module> {
+            file_to_module(self, file_id)
+        }
+
+        fn path_to_module(&self, path: &Path) -> Option<Module> {
+            path_to_module(self, path)
+        }
+
+        fn infer_symbol_type(&self, file_id: FileId, symbol_id: SymbolId) -> Type {
+            infer_symbol_type(self, file_id, symbol_id)
+        }
+
+        fn symbol_table(&self, file_id: FileId) -> Arc<SymbolTable> {
+            symbol_table(self, file_id)
+        }
+
+        fn add_module(&mut self, path: &Path) -> Option<(Module, Vec<Arc<ModuleData>>)> {
+            add_module(self, path)
+        }
+
+        fn set_module_search_paths(&mut self, paths: Vec<ModuleSearchPath>) {
+            set_module_search_paths(self, paths);
+        }
+    }
+}

crates/red_knot/src/files.rs

@@ -0,0 +1,148 @@
+use std::fmt::{Debug, Formatter};
+use std::hash::{Hash, Hasher};
+use std::path::Path;
+use std::sync::Arc;
+
+use hashbrown::hash_map::RawEntryMut;
+use parking_lot::RwLock;
+use rustc_hash::FxHasher;
+
+use ruff_index::{newtype_index, IndexVec};
+
+type Map<K, V> = hashbrown::HashMap<K, V, ()>;
+
+#[newtype_index]
+pub struct FileId;
+
+// TODO we'll need a higher level virtual file system abstraction that allows testing if a file exists
+// or retrieving its content (ideally lazily and in a way that the memory can be retained later)
+// I suspect that we'll end up with a FileSystem trait and our own Path abstraction.
+#[derive(Clone, Default)]
+pub struct Files {
+    inner: Arc<RwLock<FilesInner>>,
+}
+
+impl Files {
+    #[tracing::instrument(level = "debug", skip(self))]
+    pub fn intern(&self, path: &Path) -> FileId {
+        self.inner.write().intern(path)
+    }
+
+    pub fn try_get(&self, path: &Path) -> Option<FileId> {
+        self.inner.read().try_get(path)
+    }
+
+    #[tracing::instrument(level = "debug", skip(self))]
+    pub fn path(&self, id: FileId) -> Arc<Path> {
+        self.inner.read().path(id)
+    }
+}
+
+impl Debug for Files {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let files = self.inner.read();
+        let mut debug = f.debug_map();
+        for item in files.iter() {
+            debug.entry(&item.0, &item.1);
+        }
+
+        debug.finish()
+    }
+}
+
+impl PartialEq for Files {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner.read().eq(&other.inner.read())
+    }
+}
+
+impl Eq for Files {}
+
+#[derive(Default)]
+struct FilesInner {
+    by_path: Map<FileId, ()>,
+    // TODO should we use a map here to reclaim the space for removed files?
+    // TODO I think we should use our own path abstraction here to avoid having to normalize paths
+    // and dealing with non-utf paths everywhere.
+    by_id: IndexVec<FileId, Arc<Path>>,
+}
+
+impl FilesInner {
+    /// Inserts the path and returns a new id for it or returns the id if it is an existing path.
+    // TODO should this accept Path or PathBuf?
+    pub(crate) fn intern(&mut self, path: &Path) -> FileId {
+        let mut hasher = FxHasher::default();
+        path.hash(&mut hasher);
+        let hash = hasher.finish();
+
+        let entry = self
+            .by_path
+            .raw_entry_mut()
+            .from_hash(hash, |existing_file| &*self.by_id[*existing_file] == path);
+
+        match entry {
+            RawEntryMut::Occupied(entry) => *entry.key(),
+            RawEntryMut::Vacant(entry) => {
+                let id = self.by_id.push(Arc::from(path));
+                entry.insert_with_hasher(hash, id, (), |_| hash);
+                id
+            }
+        }
+    }
+
+    pub(crate) fn try_get(&self, path: &Path) -> Option<FileId> {
+        let mut hasher = FxHasher::default();
+        path.hash(&mut hasher);
+        let hash = hasher.finish();
+
+        Some(
+            *self
+                .by_path
+                .raw_entry()
+                .from_hash(hash, |existing_file| &*self.by_id[*existing_file] == path)?
+                .0,
+        )
+    }
+
+    /// Returns the path for the file with the given id.
+    pub(crate) fn path(&self, id: FileId) -> Arc<Path> {
+        self.by_id[id].clone()
+    }
+
+    pub(crate) fn iter(&self) -> impl Iterator<Item = (FileId, Arc<Path>)> + '_ {
+        self.by_path.keys().map(|id| (*id, self.by_id[*id].clone()))
+    }
+}
+
+impl PartialEq for FilesInner {
+    fn eq(&self, other: &Self) -> bool {
+        self.by_id == other.by_id
+    }
+}
+
+impl Eq for FilesInner {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn insert_path_twice_same_id() {
+        let files = Files::default();
+        let path = PathBuf::from("foo/bar");
+        let id1 = files.intern(&path);
+        let id2 = files.intern(&path);
+        assert_eq!(id1, id2);
+    }
+
+    #[test]
+    fn insert_different_paths_different_ids() {
+        let files = Files::default();
+        let path1 = PathBuf::from("foo/bar");
+        let path2 = PathBuf::from("foo/bar/baz");
+        let id1 = files.intern(&path1);
+        let id2 = files.intern(&path2);
+        assert_ne!(id1, id2);
+    }
+}

crates/red_knot/src/hir.rs

@@ -0,0 +1,67 @@
+//! Key observations
+//!
+//! The HIR avoids allocations to large extends by:
+//! * Using an arena per node type
+//! * using ids and id ranges to reference items.
+//!
+//! Using separate arena per node type has the advantage that the IDs are relatively stable, because
+//! they only change when a node of the same kind has been added or removed. (What's unclear is if that matters or if
+//! it still triggers a re-compute because the AST-id in the node has changed).
+//!
+//! The HIR does not store all details. It mainly stores the *public* interface. There's a reference
+//! back to the AST node to get more details.
+//!
+//!
+
+use crate::ast_ids::{HasAstId, TypedAstId};
+use crate::files::FileId;
+use std::fmt::Formatter;
+use std::hash::{Hash, Hasher};
+
+pub struct HirAstId<N: HasAstId> {
+    file_id: FileId,
+    node_id: TypedAstId<N>,
+}
+
+impl<N: HasAstId> Copy for HirAstId<N> {}
+impl<N: HasAstId> Clone for HirAstId<N> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<N: HasAstId> PartialEq for HirAstId<N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.file_id == other.file_id && self.node_id == other.node_id
+    }
+}
+
+impl<N: HasAstId> Eq for HirAstId<N> {}
+
+impl<N: HasAstId> std::fmt::Debug for HirAstId<N> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("HirAstId")
+            .field("file_id", &self.file_id)
+            .field("node_id", &self.node_id)
+            .finish()
+    }
+}
+
+impl<N: HasAstId> Hash for HirAstId<N> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.file_id.hash(state);
+        self.node_id.hash(state);
+    }
+}
+
+impl<N: HasAstId> HirAstId<N> {
+    pub fn upcast<M: HasAstId>(self) -> HirAstId<M>
+    where
+        N: Into<M>,
+    {
+        HirAstId {
+            file_id: self.file_id,
+            node_id: self.node_id.upcast(),
+        }
+    }
+}

crates/red_knot/src/hir/definition.rs

@@ -0,0 +1,556 @@
+use std::ops::{Index, Range};
+
+use ruff_index::{newtype_index, IndexVec};
+use ruff_python_ast::visitor::preorder;
+use ruff_python_ast::visitor::preorder::PreorderVisitor;
+use ruff_python_ast::{
+    Decorator, ExceptHandler, ExceptHandlerExceptHandler, Expr, MatchCase, ModModule, Stmt,
+    StmtAnnAssign, StmtAssign, StmtClassDef, StmtFunctionDef, StmtGlobal, StmtImport,
+    StmtImportFrom, StmtNonlocal, StmtTypeAlias, TypeParam, TypeParamParamSpec, TypeParamTypeVar,
+    TypeParamTypeVarTuple, WithItem,
+};
+
+use crate::ast_ids::{AstIds, HasAstId};
+use crate::files::FileId;
+use crate::hir::HirAstId;
+use crate::Name;
+
+#[newtype_index]
+pub struct FunctionId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Function {
+    ast_id: HirAstId<StmtFunctionDef>,
+    name: Name,
+    parameters: Range<ParameterId>,
+    type_parameters: Range<TypeParameterId>, // TODO: type_parameters, return expression, decorators
+}
+
+#[newtype_index]
+pub struct ParameterId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Parameter {
+    kind: ParameterKind,
+    name: Name,
+    default: Option<()>, // TODO use expression HIR
+    ast_id: HirAstId<ruff_python_ast::Parameter>,
+}
+
+// TODO or should `Parameter` be an enum?
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum ParameterKind {
+    PositionalOnly,
+    Arguments,
+    Vararg,
+    KeywordOnly,
+    Kwarg,
+}
+
+#[newtype_index]
+pub struct ClassId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Class {
+    name: Name,
+    ast_id: HirAstId<StmtClassDef>,
+    // TODO type parameters, inheritance, decorators, members
+}
+
+#[newtype_index]
+pub struct AssignmentId;
+
+// This can have more than one name...
+// but that means we can't implement `name()` on `ModuleItem`.
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Assignment {
+    // TODO: Handle multiple names  / targets
+    name: Name,
+    ast_id: HirAstId<StmtAssign>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct AnnotatedAssignment {
+    name: Name,
+    ast_id: HirAstId<StmtAnnAssign>,
+}
+
+#[newtype_index]
+pub struct AnnotatedAssignmentId;
+
+#[newtype_index]
+pub struct TypeAliasId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct TypeAlias {
+    name: Name,
+    ast_id: HirAstId<StmtTypeAlias>,
+    parameters: Range<TypeParameterId>,
+}
+
+#[newtype_index]
+pub struct TypeParameterId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum TypeParameter {
+    TypeVar(TypeParameterTypeVar),
+    ParamSpec(TypeParameterParamSpec),
+    TypeVarTuple(TypeParameterTypeVarTuple),
+}
+
+impl TypeParameter {
+    pub fn ast_id(&self) -> HirAstId<TypeParam> {
+        match self {
+            TypeParameter::TypeVar(type_var) => type_var.ast_id.upcast(),
+            TypeParameter::ParamSpec(param_spec) => param_spec.ast_id.upcast(),
+            TypeParameter::TypeVarTuple(type_var_tuple) => type_var_tuple.ast_id.upcast(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct TypeParameterTypeVar {
+    name: Name,
+    ast_id: HirAstId<TypeParamTypeVar>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct TypeParameterParamSpec {
+    name: Name,
+    ast_id: HirAstId<TypeParamParamSpec>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct TypeParameterTypeVarTuple {
+    name: Name,
+    ast_id: HirAstId<TypeParamTypeVarTuple>,
+}
+
+#[newtype_index]
+pub struct GlobalId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Global {
+    // TODO track names
+    ast_id: HirAstId<StmtGlobal>,
+}
+
+#[newtype_index]
+pub struct NonLocalId;
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct NonLocal {
+    // TODO track names
+    ast_id: HirAstId<StmtNonlocal>,
+}
+
+pub enum DefinitionId {
+    Function(FunctionId),
+    Parameter(ParameterId),
+    Class(ClassId),
+    Assignment(AssignmentId),
+    AnnotatedAssignment(AnnotatedAssignmentId),
+    Global(GlobalId),
+    NonLocal(NonLocalId),
+    TypeParameter(TypeParameterId),
+    TypeAlias(TypeAlias),
+}
+
+pub enum DefinitionItem {
+    Function(Function),
+    Parameter(Parameter),
+    Class(Class),
+    Assignment(Assignment),
+    AnnotatedAssignment(AnnotatedAssignment),
+    Global(Global),
+    NonLocal(NonLocal),
+    TypeParameter(TypeParameter),
+    TypeAlias(TypeAlias),
+}
+
+// The closest is rust-analyzers item-tree. It only represents "Items" which make the public interface of a module
+// (it excludes any other statement or expressions). rust-analyzer uses it as the main input to the name resolution
+// algorithm
+// > It is the input to the name resolution algorithm, as well as to the queries defined in `adt.rs`,
+// > `data.rs`, and most things in `attr.rs`.
+//
+// > One important purpose of this layer is to provide an "invalidation barrier" for incremental
+// > computations: when typing inside an item body, the `ItemTree` of the modified file is typically
+// > unaffected, so we don't have to recompute name resolution results or item data (see `data.rs`).
+//
+// I haven't fully figured this out but I think that this composes the "public" interface of a module?
+// But maybe that's too optimistic.
+//
+//
+#[derive(Debug, Clone, Default, Eq, PartialEq)]
+pub struct Definitions {
+    functions: IndexVec<FunctionId, Function>,
+    parameters: IndexVec<ParameterId, Parameter>,
+    classes: IndexVec<ClassId, Class>,
+    assignments: IndexVec<AssignmentId, Assignment>,
+    annotated_assignments: IndexVec<AnnotatedAssignmentId, AnnotatedAssignment>,
+    type_aliases: IndexVec<TypeAliasId, TypeAlias>,
+    type_parameters: IndexVec<TypeParameterId, TypeParameter>,
+    globals: IndexVec<GlobalId, Global>,
+    non_locals: IndexVec<NonLocalId, NonLocal>,
+}
+
+impl Definitions {
+    pub fn from_module(module: &ModModule, ast_ids: &AstIds, file_id: FileId) -> Self {
+        let mut visitor = DefinitionsVisitor {
+            definitions: Definitions::default(),
+            ast_ids,
+            file_id,
+        };
+
+        visitor.visit_body(&module.body);
+
+        visitor.definitions
+    }
+}
+
+impl Index<FunctionId> for Definitions {
+    type Output = Function;
+
+    fn index(&self, index: FunctionId) -> &Self::Output {
+        &self.functions[index]
+    }
+}
+
+impl Index<ParameterId> for Definitions {
+    type Output = Parameter;
+
+    fn index(&self, index: ParameterId) -> &Self::Output {
+        &self.parameters[index]
+    }
+}
+
+impl Index<ClassId> for Definitions {
+    type Output = Class;
+
+    fn index(&self, index: ClassId) -> &Self::Output {
+        &self.classes[index]
+    }
+}
+
+impl Index<AssignmentId> for Definitions {
+    type Output = Assignment;
+
+    fn index(&self, index: AssignmentId) -> &Self::Output {
+        &self.assignments[index]
+    }
+}
+
+impl Index<AnnotatedAssignmentId> for Definitions {
+    type Output = AnnotatedAssignment;
+
+    fn index(&self, index: AnnotatedAssignmentId) -> &Self::Output {
+        &self.annotated_assignments[index]
+    }
+}
+
+impl Index<TypeAliasId> for Definitions {
+    type Output = TypeAlias;
+
+    fn index(&self, index: TypeAliasId) -> &Self::Output {
+        &self.type_aliases[index]
+    }
+}
+
+impl Index<GlobalId> for Definitions {
+    type Output = Global;
+
+    fn index(&self, index: GlobalId) -> &Self::Output {
+        &self.globals[index]
+    }
+}
+
+impl Index<NonLocalId> for Definitions {
+    type Output = NonLocal;
+
+    fn index(&self, index: NonLocalId) -> &Self::Output {
+        &self.non_locals[index]
+    }
+}
+
+impl Index<TypeParameterId> for Definitions {
+    type Output = TypeParameter;
+
+    fn index(&self, index: TypeParameterId) -> &Self::Output {
+        &self.type_parameters[index]
+    }
+}
+
+struct DefinitionsVisitor<'a> {
+    definitions: Definitions,
+    ast_ids: &'a AstIds,
+    file_id: FileId,
+}
+
+impl DefinitionsVisitor<'_> {
+    fn ast_id<N: HasAstId>(&self, node: &N) -> HirAstId<N> {
+        HirAstId {
+            file_id: self.file_id,
+            node_id: self.ast_ids.ast_id(node),
+        }
+    }
+
+    fn lower_function_def(&mut self, function: &StmtFunctionDef) -> FunctionId {
+        let name = Name::new(&function.name);
+
+        let first_type_parameter_id = self.definitions.type_parameters.next_index();
+        let mut last_type_parameter_id = first_type_parameter_id;
+
+        if let Some(type_params) = &function.type_params {
+            for parameter in &type_params.type_params {
+                let id = self.lower_type_parameter(parameter);
+                last_type_parameter_id = id;
+            }
+        }
+
+        let parameters = self.lower_parameters(&function.parameters);
+
+        self.definitions.functions.push(Function {
+            name,
+            ast_id: self.ast_id(function),
+            parameters,
+            type_parameters: first_type_parameter_id..last_type_parameter_id,
+        })
+    }
+
+    fn lower_parameters(&mut self, parameters: &ruff_python_ast::Parameters) -> Range<ParameterId> {
+        let first_parameter_id = self.definitions.parameters.next_index();
+        let mut last_parameter_id = first_parameter_id;
+
+        for parameter in &parameters.posonlyargs {
+            last_parameter_id = self.definitions.parameters.push(Parameter {
+                kind: ParameterKind::PositionalOnly,
+                name: Name::new(&parameter.parameter.name),
+                default: None,
+                ast_id: self.ast_id(&parameter.parameter),
+            });
+        }
+
+        if let Some(vararg) = &parameters.vararg {
+            last_parameter_id = self.definitions.parameters.push(Parameter {
+                kind: ParameterKind::Vararg,
+                name: Name::new(&vararg.name),
+                default: None,
+                ast_id: self.ast_id(vararg),
+            });
+        }
+
+        for parameter in &parameters.kwonlyargs {
+            last_parameter_id = self.definitions.parameters.push(Parameter {
+                kind: ParameterKind::KeywordOnly,
+                name: Name::new(&parameter.parameter.name),
+                default: None,
+                ast_id: self.ast_id(&parameter.parameter),
+            });
+        }
+
+        if let Some(kwarg) = &parameters.kwarg {
+            last_parameter_id = self.definitions.parameters.push(Parameter {
+                kind: ParameterKind::KeywordOnly,
+                name: Name::new(&kwarg.name),
+                default: None,
+                ast_id: self.ast_id(kwarg),
+            });
+        }
+
+        first_parameter_id..last_parameter_id
+    }
+
+    fn lower_class_def(&mut self, class: &StmtClassDef) -> ClassId {
+        let name = Name::new(&class.name);
+
+        self.definitions.classes.push(Class {
+            name,
+            ast_id: self.ast_id(class),
+        })
+    }
+
+    fn lower_assignment(&mut self, assignment: &StmtAssign) {
+        // FIXME handle multiple names
+        if let Some(Expr::Name(name)) = assignment.targets.first() {
+            self.definitions.assignments.push(Assignment {
+                name: Name::new(&name.id),
+                ast_id: self.ast_id(assignment),
+            });
+        }
+    }
+
+    fn lower_annotated_assignment(&mut self, annotated_assignment: &StmtAnnAssign) {
+        if let Expr::Name(name) = &*annotated_assignment.target {
+            self.definitions
+                .annotated_assignments
+                .push(AnnotatedAssignment {
+                    name: Name::new(&name.id),
+                    ast_id: self.ast_id(annotated_assignment),
+                });
+        }
+    }
+
+    fn lower_type_alias(&mut self, type_alias: &StmtTypeAlias) {
+        if let Expr::Name(name) = &*type_alias.name {
+            let name = Name::new(&name.id);
+
+            let lower_parameters_id = self.definitions.type_parameters.next_index();
+            let mut last_parameter_id = lower_parameters_id;
+
+            if let Some(type_params) = &type_alias.type_params {
+                for type_parameter in &type_params.type_params {
+                    let id = self.lower_type_parameter(type_parameter);
+                    last_parameter_id = id;
+                }
+            }
+
+            self.definitions.type_aliases.push(TypeAlias {
+                name,
+                ast_id: self.ast_id(type_alias),
+                parameters: lower_parameters_id..last_parameter_id,
+            });
+        }
+    }
+
+    fn lower_type_parameter(&mut self, type_parameter: &TypeParam) -> TypeParameterId {
+        match type_parameter {
+            TypeParam::TypeVar(type_var) => {
+                self.definitions
+                    .type_parameters
+                    .push(TypeParameter::TypeVar(TypeParameterTypeVar {
+                        name: Name::new(&type_var.name),
+                        ast_id: self.ast_id(type_var),
+                    }))
+            }
+            TypeParam::ParamSpec(param_spec) => {
+                self.definitions
+                    .type_parameters
+                    .push(TypeParameter::ParamSpec(TypeParameterParamSpec {
+                        name: Name::new(&param_spec.name),
+                        ast_id: self.ast_id(param_spec),
+                    }))
+            }
+            TypeParam::TypeVarTuple(type_var_tuple) => {
+                self.definitions
+                    .type_parameters
+                    .push(TypeParameter::TypeVarTuple(TypeParameterTypeVarTuple {
+                        name: Name::new(&type_var_tuple.name),
+                        ast_id: self.ast_id(type_var_tuple),
+                    }))
+            }
+        }
+    }
+
+    fn lower_import(&mut self, _import: &StmtImport) {
+        // TODO
+    }
+
+    fn lower_import_from(&mut self, _import_from: &StmtImportFrom) {
+        // TODO
+    }
+
+    fn lower_global(&mut self, global: &StmtGlobal) -> GlobalId {
+        self.definitions.globals.push(Global {
+            ast_id: self.ast_id(global),
+        })
+    }
+
+    fn lower_non_local(&mut self, non_local: &StmtNonlocal) -> NonLocalId {
+        self.definitions.non_locals.push(NonLocal {
+            ast_id: self.ast_id(non_local),
+        })
+    }
+
+    fn lower_except_handler(&mut self, _except_handler: &ExceptHandlerExceptHandler) {
+        // TODO
+    }
+
+    fn lower_with_item(&mut self, _with_item: &WithItem) {
+        // TODO
+    }
+
+    fn lower_match_case(&mut self, _match_case: &MatchCase) {
+        // TODO
+    }
+}
+
+impl PreorderVisitor<'_> for DefinitionsVisitor<'_> {
+    fn visit_stmt(&mut self, stmt: &Stmt) {
+        match stmt {
+            // Definition statements
+            Stmt::FunctionDef(definition) => {
+                self.lower_function_def(definition);
+                self.visit_body(&definition.body);
+            }
+            Stmt::ClassDef(definition) => {
+                self.lower_class_def(definition);
+                self.visit_body(&definition.body);
+            }
+            Stmt::Assign(assignment) => {
+                self.lower_assignment(assignment);
+            }
+            Stmt::AnnAssign(annotated_assignment) => {
+                self.lower_annotated_assignment(annotated_assignment);
+            }
+            Stmt::TypeAlias(type_alias) => {
+                self.lower_type_alias(type_alias);
+            }
+
+            Stmt::Import(import) => self.lower_import(import),
+            Stmt::ImportFrom(import_from) => self.lower_import_from(import_from),
+            Stmt::Global(global) => {
+                self.lower_global(global);
+            }
+            Stmt::Nonlocal(non_local) => {
+                self.lower_non_local(non_local);
+            }
+
+            // Visit the compound statement bodies because they can contain other definitions.
+            Stmt::For(_)
+            | Stmt::While(_)
+            | Stmt::If(_)
+            | Stmt::With(_)
+            | Stmt::Match(_)
+            | Stmt::Try(_) => {
+                preorder::walk_stmt(self, stmt);
+            }
+
+            // Skip over simple statements because they can't contain any other definitions.
+            Stmt::Return(_)
+            | Stmt::Delete(_)
+            | Stmt::AugAssign(_)
+            | Stmt::Raise(_)
+            | Stmt::Assert(_)
+            | Stmt::Expr(_)
+            | Stmt::Pass(_)
+            | Stmt::Break(_)
+            | Stmt::Continue(_)
+            | Stmt::IpyEscapeCommand(_) => {
+                // No op
+            }
+        }
+    }
+
+    fn visit_expr(&mut self, _: &'_ Expr) {}
+
+    fn visit_decorator(&mut self, _decorator: &'_ Decorator) {}
+
+    fn visit_except_handler(&mut self, except_handler: &'_ ExceptHandler) {
+        match except_handler {
+            ExceptHandler::ExceptHandler(except_handler) => {
+                self.lower_except_handler(except_handler);
+            }
+        }
+    }
+
+    fn visit_with_item(&mut self, with_item: &'_ WithItem) {
+        self.lower_with_item(with_item);
+    }
+
+    fn visit_match_case(&mut self, match_case: &'_ MatchCase) {
+        self.lower_match_case(match_case);
+        self.visit_body(&match_case.body);
+    }
+}

crates/red_knot/src/lib.rs

@@ -0,0 +1,102 @@
+use std::hash::BuildHasherDefault;
+use std::ops::Deref;
+use std::path::{Path, PathBuf};
+
+use rustc_hash::{FxHashSet, FxHasher};
+
+use crate::files::FileId;
+
+pub mod ast_ids;
+pub mod cache;
+pub mod cancellation;
+pub mod db;
+pub mod files;
+pub mod hir;
+pub mod lint;
+pub mod module;
+mod parse;
+pub mod program;
+pub mod source;
+mod symbols;
+mod types;
+pub mod watch;
+
+pub(crate) type FxDashMap<K, V> = dashmap::DashMap<K, V, BuildHasherDefault<FxHasher>>;
+#[allow(unused)]
+pub(crate) type FxDashSet<V> = dashmap::DashSet<V, BuildHasherDefault<FxHasher>>;
+pub(crate) type FxIndexSet<V> = indexmap::set::IndexSet<V, BuildHasherDefault<FxHasher>>;
+
+#[derive(Debug)]
+pub struct Workspace {
+    /// TODO this should be a resolved path. We should probably use a newtype wrapper that guarantees that
+    /// PATH is a UTF-8 path and is normalized.
+    root: PathBuf,
+    /// The files that are open in the workspace.
+    ///
+    /// * Editor: The files that are actively being edited in the editor (the user has a tab open with the file).
+    /// * CLI: The resolved files passed as arguments to the CLI.
+    open_files: FxHashSet<FileId>,
+}
+
+impl Workspace {
+    pub fn new(root: PathBuf) -> Self {
+        Self {
+            root,
+            open_files: FxHashSet::default(),
+        }
+    }
+
+    pub fn root(&self) -> &Path {
+        self.root.as_path()
+    }
+
+    // TODO having the content in workspace feels wrong.
+    pub fn open_file(&mut self, file_id: FileId) {
+        self.open_files.insert(file_id);
+    }
+
+    pub fn close_file(&mut self, file_id: FileId) {
+        self.open_files.remove(&file_id);
+    }
+
+    // TODO introduce an `OpenFile` type instead of using an anonymous tuple.
+    pub fn open_files(&self) -> impl Iterator<Item = FileId> + '_ {
+        self.open_files.iter().copied()
+    }
+
+    pub fn is_file_open(&self, file_id: FileId) -> bool {
+        self.open_files.contains(&file_id)
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct Name(smol_str::SmolStr);
+
+impl Name {
+    #[inline]
+    pub fn new(name: &str) -> Self {
+        Self(smol_str::SmolStr::new(name))
+    }
+
+    pub fn as_str(&self) -> &str {
+        self.0.as_str()
+    }
+}
+
+impl Deref for Name {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.as_str()
+    }
+}
+
+impl<T> From<T> for Name
+where
+    T: Into<smol_str::SmolStr>,
+{
+    fn from(value: T) -> Self {
+        Self(value.into())
+    }
+}

crates/red_knot/src/lint.rs

@@ -0,0 +1,125 @@
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+
+use ruff_python_ast::visitor::Visitor;
+use ruff_python_ast::StringLiteral;
+
+use crate::cache::KeyValueCache;
+use crate::db::{HasJar, SourceDb, SourceJar};
+use crate::files::FileId;
+
+#[tracing::instrument(level = "debug", skip(db))]
+pub(crate) fn lint_syntax<Db>(db: &Db, file_id: FileId) -> Diagnostics
+where
+    Db: SourceDb + HasJar<SourceJar>,
+{
+    let storage = &db.jar().lint_syntax;
+
+    storage.get(&file_id, |file_id| {
+        let mut diagnostics = Vec::new();
+
+        let source = db.source(*file_id);
+        lint_lines(source.text(), &mut diagnostics);
+
+        let parsed = db.parse(*file_id);
+
+        if parsed.errors().is_empty() {
+            let ast = parsed.ast();
+
+            let mut visitor = SyntaxLintVisitor {
+                diagnostics,
+                source: source.text(),
+            };
+            visitor.visit_body(&ast.body);
+            diagnostics = visitor.diagnostics;
+        } else {
+            diagnostics.extend(parsed.errors().iter().map(std::string::ToString::to_string));
+        }
+
+        Diagnostics::from(diagnostics)
+    })
+}
+
+pub(crate) fn lint_lines(source: &str, diagnostics: &mut Vec<String>) {
+    for (line_number, line) in source.lines().enumerate() {
+        if line.len() < 88 {
+            continue;
+        }
+
+        let char_count = line.chars().count();
+        if char_count > 88 {
+            diagnostics.push(format!(
+                "Line {} is too long ({} characters)",
+                line_number + 1,
+                char_count
+            ));
+        }
+    }
+}
+
+#[derive(Debug)]
+struct SyntaxLintVisitor<'a> {
+    diagnostics: Vec<String>,
+    source: &'a str,
+}
+
+impl Visitor<'_> for SyntaxLintVisitor<'_> {
+    fn visit_string_literal(&mut self, string_literal: &'_ StringLiteral) {
+        // A very naive implementation of use double quotes
+        let text = &self.source[string_literal.range];
+
+        if text.starts_with('\'') {
+            self.diagnostics
+                .push("Use double quotes for strings".to_string());
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Diagnostics {
+    Empty,
+    List(Arc<Vec<String>>),
+}
+
+impl Diagnostics {
+    pub fn as_slice(&self) -> &[String] {
+        match self {
+            Diagnostics::Empty => &[],
+            Diagnostics::List(list) => list.as_slice(),
+        }
+    }
+}
+
+impl Deref for Diagnostics {
+    type Target = [String];
+    fn deref(&self) -> &Self::Target {
+        self.as_slice()
+    }
+}
+
+impl From<Vec<String>> for Diagnostics {
+    fn from(value: Vec<String>) -> Self {
+        if value.is_empty() {
+            Diagnostics::Empty
+        } else {
+            Diagnostics::List(Arc::new(value))
+        }
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct LintSyntaxStorage(KeyValueCache<FileId, Diagnostics>);
+
+impl Deref for LintSyntaxStorage {
+    type Target = KeyValueCache<FileId, Diagnostics>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for LintSyntaxStorage {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}

crates/red_knot/src/main.rs

@@ -0,0 +1,469 @@
+#![allow(clippy::dbg_macro)]
+
+use std::collections::hash_map::Entry;
+use std::path::Path;
+use std::sync::Mutex;
+
+use rustc_hash::FxHashMap;
+use tracing::subscriber::Interest;
+use tracing::{Level, Metadata};
+use tracing_subscriber::filter::LevelFilter;
+use tracing_subscriber::layer::{Context, Filter, SubscriberExt};
+use tracing_subscriber::{Layer, Registry};
+use tracing_tree::time::Uptime;
+
+use red_knot::cancellation::CancellationTokenSource;
+use red_knot::db::{HasJar, SourceDb, SourceJar};
+use red_knot::files::FileId;
+use red_knot::module::{ModuleSearchPath, ModuleSearchPathKind};
+use red_knot::program::check::{CheckError, RayonCheckScheduler};
+use red_knot::program::{FileChange, FileChangeKind, Program};
+use red_knot::watch::FileWatcher;
+use red_knot::Workspace;
+
+#[allow(clippy::print_stdout, clippy::unnecessary_wraps, clippy::print_stderr)]
+fn main() -> anyhow::Result<()> {
+    setup_tracing();
+
+    let arguments: Vec<_> = std::env::args().collect();
+
+    if arguments.len() < 2 {
+        eprintln!("Usage: red_knot <path>");
+        return Err(anyhow::anyhow!("Invalid arguments"));
+    }
+
+    let entry_point = Path::new(&arguments[1]);
+
+    if !entry_point.exists() {
+        eprintln!("The entry point does not exist.");
+        return Err(anyhow::anyhow!("Invalid arguments"));
+    }
+
+    if !entry_point.is_file() {
+        eprintln!("The entry point is not a file.");
+        return Err(anyhow::anyhow!("Invalid arguments"));
+    }
+
+    let workspace_folder = entry_point.parent().unwrap();
+    let workspace = Workspace::new(workspace_folder.to_path_buf());
+
+    let workspace_search_path = ModuleSearchPath::new(
+        workspace.root().to_path_buf(),
+        ModuleSearchPathKind::FirstParty,
+    );
+    let mut program = Program::new(workspace, vec![workspace_search_path]);
+
+    let entry_id = program.file_id(entry_point);
+    program.workspace_mut().open_file(entry_id);
+
+    let (main_loop, main_loop_cancellation_token) = MainLoop::new();
+
+    // Listen to Ctrl+C and abort the watch mode.
+    let main_loop_cancellation_token = Mutex::new(Some(main_loop_cancellation_token));
+    ctrlc::set_handler(move || {
+        let mut lock = main_loop_cancellation_token.lock().unwrap();
+
+        if let Some(token) = lock.take() {
+            token.stop();
+        }
+    })?;
+
+    let file_changes_notifier = main_loop.file_changes_notifier();
+
+    // Watch for file changes and re-trigger the analysis.
+    let mut file_watcher = FileWatcher::new(
+        move |changes| {
+            file_changes_notifier.notify(changes);
+        },
+        program.files().clone(),
+    )?;
+
+    file_watcher.watch_folder(workspace_folder)?;
+
+    main_loop.run(&mut program);
+
+    let source_jar: &SourceJar = program.jar();
+
+    dbg!(source_jar.parsed.statistics());
+    dbg!(source_jar.sources.statistics());
+
+    Ok(())
+}
+
+struct MainLoop {
+    orchestrator_sender: crossbeam_channel::Sender<OrchestratorMessage>,
+    main_loop_receiver: crossbeam_channel::Receiver<MainLoopMessage>,
+}
+
+impl MainLoop {
+    fn new() -> (Self, MainLoopCancellationToken) {
+        let (orchestrator_sender, orchestrator_receiver) = crossbeam_channel::bounded(1);
+        let (main_loop_sender, main_loop_receiver) = crossbeam_channel::bounded(1);
+
+        let mut orchestrator = Orchestrator {
+            pending_analysis: None,
+            receiver: orchestrator_receiver,
+            sender: main_loop_sender.clone(),
+            aggregated_changes: AggregatedChanges::default(),
+        };
+
+        std::thread::spawn(move || {
+            orchestrator.run();
+        });
+
+        (
+            Self {
+                orchestrator_sender,
+                main_loop_receiver,
+            },
+            MainLoopCancellationToken {
+                sender: main_loop_sender,
+            },
+        )
+    }
+
+    fn file_changes_notifier(&self) -> FileChangesNotifier {
+        FileChangesNotifier {
+            sender: self.orchestrator_sender.clone(),
+        }
+    }
+
+    fn run(self, program: &mut Program) {
+        self.orchestrator_sender
+            .send(OrchestratorMessage::Run)
+            .unwrap();
+
+        for message in &self.main_loop_receiver {
+            tracing::trace!("Main Loop: Tick");
+
+            match message {
+                MainLoopMessage::CheckProgram => {
+                    // Remove mutability from program.
+                    let program = &*program;
+                    let run_cancellation_token_source = CancellationTokenSource::new();
+                    let run_cancellation_token = run_cancellation_token_source.token();
+                    let sender = &self.orchestrator_sender;
+
+                    sender
+                        .send(OrchestratorMessage::CheckProgramStarted {
+                            cancellation_token: run_cancellation_token_source,
+                        })
+                        .unwrap();
+
+                    rayon::in_place_scope(|scope| {
+                        let scheduler = RayonCheckScheduler::new(program, scope);
+
+                        let result = program.check(&scheduler, run_cancellation_token);
+                        match result {
+                            Ok(result) => sender
+                                .send(OrchestratorMessage::CheckProgramCompleted(result))
+                                .unwrap(),
+                            Err(CheckError::Cancelled) => sender
+                                .send(OrchestratorMessage::CheckProgramCancelled)
+                                .unwrap(),
+                        }
+                    });
+                }
+                MainLoopMessage::ApplyChanges(changes) => {
+                    program.apply_changes(changes.iter());
+                }
+                MainLoopMessage::CheckCompleted(diagnostics) => {
+                    dbg!(diagnostics);
+                }
+                MainLoopMessage::Exit => {
+                    return;
+                }
+            }
+        }
+    }
+}
+
+impl Drop for MainLoop {
+    fn drop(&mut self) {
+        self.orchestrator_sender
+            .send(OrchestratorMessage::Shutdown)
+            .unwrap();
+    }
+}
+
+#[derive(Debug, Clone)]
+struct FileChangesNotifier {
+    sender: crossbeam_channel::Sender<OrchestratorMessage>,
+}
+
+impl FileChangesNotifier {
+    fn notify(&self, changes: Vec<FileChange>) {
+        self.sender
+            .send(OrchestratorMessage::FileChanges(changes))
+            .unwrap();
+    }
+}
+
+#[derive(Debug)]
+struct MainLoopCancellationToken {
+    sender: crossbeam_channel::Sender<MainLoopMessage>,
+}
+
+impl MainLoopCancellationToken {
+    fn stop(self) {
+        self.sender.send(MainLoopMessage::Exit).unwrap();
+    }
+}
+
+struct Orchestrator {
+    aggregated_changes: AggregatedChanges,
+    pending_analysis: Option<PendingAnalysisState>,
+
+    /// Sends messages to the main loop.
+    sender: crossbeam_channel::Sender<MainLoopMessage>,
+    /// Receives messages from the main loop.
+    receiver: crossbeam_channel::Receiver<OrchestratorMessage>,
+}
+
+impl Orchestrator {
+    fn run(&mut self) {
+        while let Ok(message) = self.receiver.recv() {
+            match message {
+                OrchestratorMessage::Run => {
+                    self.pending_analysis = None;
+                    self.sender.send(MainLoopMessage::CheckProgram).unwrap();
+                }
+
+                OrchestratorMessage::CheckProgramStarted { cancellation_token } => {
+                    debug_assert!(self.pending_analysis.is_none());
+
+                    self.pending_analysis = Some(PendingAnalysisState { cancellation_token });
+                }
+
+                OrchestratorMessage::CheckProgramCompleted(diagnostics) => {
+                    self.pending_analysis
+                        .take()
+                        .expect("Expected a pending analysis.");
+
+                    self.sender
+                        .send(MainLoopMessage::CheckCompleted(diagnostics))
+                        .unwrap();
+                }
+
+                OrchestratorMessage::CheckProgramCancelled => {
+                    self.pending_analysis
+                        .take()
+                        .expect("Expected a pending analysis.");
+
+                    self.debounce_changes();
+                }
+
+                OrchestratorMessage::FileChanges(changes) => {
+                    // Request cancellation, but wait until all analysis tasks have completed to
+                    // avoid stale messages in the next main loop.
+                    let pending = if let Some(pending_state) = self.pending_analysis.as_ref() {
+                        pending_state.cancellation_token.cancel();
+                        true
+                    } else {
+                        false
+                    };
+
+                    self.aggregated_changes.extend(changes);
+
+                    // If there are no pending analysis tasks, apply the file changes. Otherwise
+                    // keep running until all file checks have completed.
+                    if !pending {
+                        self.debounce_changes();
+                    }
+                }
+                OrchestratorMessage::Shutdown => {
+                    return self.shutdown();
+                }
+            }
+        }
+    }
+
+    fn debounce_changes(&mut self) {
+        debug_assert!(self.pending_analysis.is_none());
+
+        loop {
+            // Consume possibly incoming file change messages before running a new analysis, but don't wait for more than 100ms.
+            crossbeam_channel::select! {
+                recv(self.receiver) -> message => {
+                    match message {
+                        Ok(OrchestratorMessage::Shutdown) => {
+                            return self.shutdown();
+                        }
+                        Ok(OrchestratorMessage::FileChanges(file_changes)) => {
+                            self.aggregated_changes.extend(file_changes);
+                        }
+
+                        Ok(OrchestratorMessage::CheckProgramStarted {..}| OrchestratorMessage::CheckProgramCompleted(_) | OrchestratorMessage::CheckProgramCancelled) => unreachable!("No program check should be running while debouncing changes."),
+                        Ok(OrchestratorMessage::Run) => unreachable!("The orchestrator is already running."),
+
+                        Err(_) => {
+                            // There are no more senders, no point in waiting for more messages
+                            return;
+                        }
+                    }
+                },
+                default(std::time::Duration::from_millis(100)) => {
+                    // No more file changes after 100 ms, send the changes and schedule a new analysis
+                    self.sender.send(MainLoopMessage::ApplyChanges(std::mem::take(&mut self.aggregated_changes))).unwrap();
+                    self.sender.send(MainLoopMessage::CheckProgram).unwrap();
+                    return;
+                }
+            }
+        }
+    }
+
+    #[allow(clippy::unused_self)]
+    fn shutdown(&self) {
+        tracing::trace!("Shutting down orchestrator.");
+    }
+}
+
+#[derive(Debug)]
+struct PendingAnalysisState {
+    cancellation_token: CancellationTokenSource,
+}
+
+/// Message sent from the orchestrator to the main loop.
+#[derive(Debug)]
+enum MainLoopMessage {
+    CheckProgram,
+    CheckCompleted(Vec<String>),
+    ApplyChanges(AggregatedChanges),
+    Exit,
+}
+
+#[derive(Debug)]
+enum OrchestratorMessage {
+    Run,
+    Shutdown,
+
+    CheckProgramStarted {
+        cancellation_token: CancellationTokenSource,
+    },
+    CheckProgramCompleted(Vec<String>),
+    CheckProgramCancelled,
+
+    FileChanges(Vec<FileChange>),
+}
+
+#[derive(Default, Debug)]
+struct AggregatedChanges {
+    changes: FxHashMap<FileId, FileChangeKind>,
+}
+
+impl AggregatedChanges {
+    fn add(&mut self, change: FileChange) {
+        match self.changes.entry(change.file_id()) {
+            Entry::Occupied(mut entry) => {
+                let merged = entry.get_mut();
+
+                match (merged, change.kind()) {
+                    (FileChangeKind::Created, FileChangeKind::Deleted) => {
+                        // Deletion after creations means that ruff never saw the file.
+                        entry.remove();
+                    }
+                    (FileChangeKind::Created, FileChangeKind::Modified) => {
+                        // No-op, for ruff, modifying a file that it doesn't yet know that it exists is still considered a creation.
+                    }
+
+                    (FileChangeKind::Modified, FileChangeKind::Created) => {
+                        // Uhh, that should probably not happen. Continue considering it a modification.
+                    }
+
+                    (FileChangeKind::Modified, FileChangeKind::Deleted) => {
+                        *entry.get_mut() = FileChangeKind::Deleted;
+                    }
+
+                    (FileChangeKind::Deleted, FileChangeKind::Created) => {
+                        *entry.get_mut() = FileChangeKind::Modified;
+                    }
+
+                    (FileChangeKind::Deleted, FileChangeKind::Modified) => {
+                        // That's weird, but let's consider it a modification.
+                        *entry.get_mut() = FileChangeKind::Modified;
+                    }
+
+                    (FileChangeKind::Created, FileChangeKind::Created)
+                    | (FileChangeKind::Modified, FileChangeKind::Modified)
+                    | (FileChangeKind::Deleted, FileChangeKind::Deleted) => {
+                        // No-op transitions. Some of them should be impossible but we handle them anyway.
+                    }
+                }
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(change.kind());
+            }
+        }
+    }
+
+    fn extend<I>(&mut self, changes: I)
+    where
+        I: IntoIterator<Item = FileChange>,
+        I::IntoIter: ExactSizeIterator,
+    {
+        let iter = changes.into_iter();
+        self.changes.reserve(iter.len());
+
+        for change in iter {
+            self.add(change);
+        }
+    }
+
+    fn iter(&self) -> impl Iterator<Item = FileChange> + '_ {
+        self.changes
+            .iter()
+            .map(|(id, kind)| FileChange::new(*id, *kind))
+    }
+}
+
+fn setup_tracing() {
+    let subscriber = Registry::default().with(
+        tracing_tree::HierarchicalLayer::default()
+            .with_indent_lines(true)
+            .with_indent_amount(2)
+            .with_bracketed_fields(true)
+            .with_thread_ids(true)
+            .with_targets(true)
+            .with_writer(|| Box::new(std::io::stderr()))
+            .with_timer(Uptime::default())
+            .with_filter(LoggingFilter {
+                trace_level: Level::TRACE,
+            }),
+    );
+
+    tracing::subscriber::set_global_default(subscriber).unwrap();
+}
+
+struct LoggingFilter {
+    trace_level: Level,
+}
+
+impl LoggingFilter {
+    fn is_enabled(&self, meta: &Metadata<'_>) -> bool {
+        let filter = if meta.target().starts_with("red_knot") || meta.target().starts_with("ruff") {
+            self.trace_level
+        } else {
+            Level::INFO
+        };
+
+        meta.level() <= &filter
+    }
+}
+
+impl<S> Filter<S> for LoggingFilter {
+    fn enabled(&self, meta: &Metadata<'_>, _cx: &Context<'_, S>) -> bool {
+        self.is_enabled(meta)
+    }
+
+    fn callsite_enabled(&self, meta: &'static Metadata<'static>) -> Interest {
+        if self.is_enabled(meta) {
+            Interest::always()
+        } else {
+            Interest::never()
+        }
+    }
+
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        Some(LevelFilter::from_level(self.trace_level))
+    }
+}

crates/red_knot/src/parse.rs

@@ -0,0 +1,95 @@
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+
+use ruff_python_ast as ast;
+use ruff_python_parser::{Mode, ParseError};
+use ruff_text_size::{Ranged, TextRange};
+
+use crate::cache::KeyValueCache;
+use crate::db::{HasJar, SourceDb, SourceJar};
+use crate::files::FileId;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Parsed {
+    inner: Arc<ParsedInner>,
+}
+
+#[derive(Debug, PartialEq)]
+struct ParsedInner {
+    ast: ast::ModModule,
+    errors: Vec<ParseError>,
+}
+
+impl Parsed {
+    fn new(ast: ast::ModModule, errors: Vec<ParseError>) -> Self {
+        Self {
+            inner: Arc::new(ParsedInner { ast, errors }),
+        }
+    }
+
+    pub(crate) fn from_text(text: &str) -> Self {
+        let result = ruff_python_parser::parse(text, Mode::Module);
+
+        let (module, errors) = match result {
+            Ok(ast::Mod::Module(module)) => (module, vec![]),
+            Ok(ast::Mod::Expression(expression)) => (
+                ast::ModModule {
+                    range: expression.range(),
+                    body: vec![ast::Stmt::Expr(ast::StmtExpr {
+                        range: expression.range(),
+                        value: expression.body,
+                    })],
+                },
+                vec![],
+            ),
+            Err(errors) => (
+                ast::ModModule {
+                    range: TextRange::default(),
+                    body: Vec::new(),
+                },
+                vec![errors],
+            ),
+        };
+
+        Parsed::new(module, errors)
+    }
+
+    pub fn ast(&self) -> &ast::ModModule {
+        &self.inner.ast
+    }
+
+    pub fn errors(&self) -> &[ParseError] {
+        &self.inner.errors
+    }
+}
+
+#[tracing::instrument(level = "debug", skip(db))]
+pub(crate) fn parse<Db>(db: &Db, file_id: FileId) -> Parsed
+where
+    Db: SourceDb + HasJar<SourceJar>,
+{
+    let parsed = db.jar();
+
+    parsed.parsed.get(&file_id, |file_id| {
+        let source = db.source(*file_id);
+
+        Parsed::from_text(source.text())
+    })
+}
+
+#[derive(Debug, Default)]
+pub struct ParsedStorage(KeyValueCache<FileId, Parsed>);
+
+impl Deref for ParsedStorage {
+    type Target = KeyValueCache<FileId, Parsed>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for ParsedStorage {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}

crates/red_knot/src/program/check.rs

@@ -0,0 +1,306 @@
+use crate::cancellation::CancellationToken;
+use crate::db::{SemanticDb, SourceDb};
+use crate::files::FileId;
+use crate::lint::Diagnostics;
+use crate::program::Program;
+use rayon::max_num_threads;
+use rustc_hash::FxHashSet;
+use std::num::NonZeroUsize;
+
+impl Program {
+    /// Checks all open files in the workspace and its dependencies.
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub fn check(
+        &self,
+        scheduler: &dyn CheckScheduler,
+        cancellation_token: CancellationToken,
+    ) -> Result<Vec<String>, CheckError> {
+        let check_loop = CheckFilesLoop::new(scheduler, cancellation_token);
+
+        check_loop.run(self.workspace().open_files.iter().copied())
+    }
+
+    /// Checks a single file and its dependencies.
+    #[tracing::instrument(level = "debug", skip(self, scheduler, cancellation_token))]
+    pub fn check_file(
+        &self,
+        file: FileId,
+        scheduler: &dyn CheckScheduler,
+        cancellation_token: CancellationToken,
+    ) -> Result<Vec<String>, CheckError> {
+        let check_loop = CheckFilesLoop::new(scheduler, cancellation_token);
+
+        check_loop.run([file].into_iter())
+    }
+
+    #[tracing::instrument(level = "debug", skip(self, context))]
+    fn do_check_file(
+        &self,
+        file: FileId,
+        context: &CheckContext,
+    ) -> Result<Diagnostics, CheckError> {
+        context.cancelled_ok()?;
+
+        let symbol_table = self.symbol_table(file);
+        let dependencies = symbol_table.dependencies();
+
+        if !dependencies.is_empty() {
+            let module = self.file_to_module(file);
+
+            // TODO scheduling all dependencies here is wasteful if we don't infer any types on them
+            //  but I think that's unlikely, so it is okay?
+            //  Anyway, we need to figure out a way to retrieve the dependencies of a module
+            //  from the persistent cache. So maybe it should be a separate query after all.
+            for dependency in dependencies {
+                let dependency_name = dependency.module_name(self, module);
+
+                if let Some(dependency_name) = dependency_name {
+                    // TODO We may want to have a different check functions for non-first-party
+                    //   files because we only need to index them and not check them.
+                    //   Supporting non-first-party code also requires supporting typing stubs.
+                    if let Some(dependency) = self.resolve_module(dependency_name) {
+                        if dependency.path(self).root().kind().is_first_party() {
+                            context.schedule_check_file(dependency.path(self).file());
+                        }
+                    }
+                }
+            }
+        }
+
+        let mut diagnostics = Vec::new();
+
+        if self.workspace().is_file_open(file) {
+            diagnostics.extend_from_slice(&self.lint_syntax(file));
+        }
+
+        Ok(Diagnostics::from(diagnostics))
+    }
+}
+
+/// Schedules checks for files.
+pub trait CheckScheduler {
+    /// Schedules a check for a file.
+    ///
+    /// The check can either be run immediately on the current thread or the check can be queued
+    /// in a thread pool and ran asynchronously.
+    ///
+    /// The order in which scheduled checks are executed is not guaranteed.
+    ///
+    /// The implementation should call [`CheckFileTask::run`] to execute the check.
+    fn check_file(&self, file_task: CheckFileTask);
+
+    /// The maximum number of checks that can be run concurrently.
+    ///
+    /// Returns `None` if the checks run on the current thread (no concurrency).
+    fn max_concurrency(&self) -> Option<NonZeroUsize>;
+}
+
+/// Scheduler that runs checks on a rayon thread pool.
+pub struct RayonCheckScheduler<'program, 'scope_ref, 'scope> {
+    program: &'program Program,
+    scope: &'scope_ref rayon::Scope<'scope>,
+}
+
+impl<'program, 'scope_ref, 'scope> RayonCheckScheduler<'program, 'scope_ref, 'scope> {
+    pub fn new(program: &'program Program, scope: &'scope_ref rayon::Scope<'scope>) -> Self {
+        Self { program, scope }
+    }
+}
+
+impl<'program, 'scope_ref, 'scope> CheckScheduler
+    for RayonCheckScheduler<'program, 'scope_ref, 'scope>
+where
+    'program: 'scope,
+{
+    fn check_file(&self, check_file_task: CheckFileTask) {
+        let child_span =
+            tracing::trace_span!("check_file", file_id = check_file_task.file_id.as_u32());
+        let program = self.program;
+
+        self.scope
+            .spawn(move |_| child_span.in_scope(|| check_file_task.run(program)));
+    }
+
+    fn max_concurrency(&self) -> Option<NonZeroUsize> {
+        Some(NonZeroUsize::new(max_num_threads()).unwrap_or(NonZeroUsize::MIN))
+    }
+}
+
+/// Scheduler that runs all checks on the current thread.
+pub struct SameThreadCheckScheduler<'a> {
+    program: &'a Program,
+}
+
+impl<'a> SameThreadCheckScheduler<'a> {
+    pub fn new(program: &'a Program) -> Self {
+        Self { program }
+    }
+}
+
+impl CheckScheduler for SameThreadCheckScheduler<'_> {
+    fn check_file(&self, task: CheckFileTask) {
+        task.run(self.program);
+    }
+
+    fn max_concurrency(&self) -> Option<NonZeroUsize> {
+        None
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum CheckError {
+    Cancelled,
+}
+
+#[derive(Debug)]
+pub struct CheckFileTask {
+    file_id: FileId,
+    context: CheckContext,
+}
+
+impl CheckFileTask {
+    /// Runs the check and communicates the result to the orchestrator.
+    pub fn run(self, program: &Program) {
+        match program.do_check_file(self.file_id, &self.context) {
+            Ok(diagnostics) => self
+                .context
+                .sender
+                .send(CheckFileMessage::Completed(diagnostics))
+                .unwrap(),
+            Err(CheckError::Cancelled) => self
+                .context
+                .sender
+                .send(CheckFileMessage::Cancelled)
+                .unwrap(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+struct CheckContext {
+    cancellation_token: CancellationToken,
+    sender: crossbeam_channel::Sender<CheckFileMessage>,
+}
+
+impl CheckContext {
+    fn new(
+        cancellation_token: CancellationToken,
+        sender: crossbeam_channel::Sender<CheckFileMessage>,
+    ) -> Self {
+        Self {
+            cancellation_token,
+            sender,
+        }
+    }
+
+    /// Queues a new file for checking using the [`CheckScheduler`].
+    #[allow(unused)]
+    fn schedule_check_file(&self, file_id: FileId) {
+        self.sender.send(CheckFileMessage::Queue(file_id)).unwrap();
+    }
+
+    /// Returns `true` if the check has been cancelled.
+    fn is_cancelled(&self) -> bool {
+        self.cancellation_token.is_cancelled()
+    }
+
+    fn cancelled_ok(&self) -> Result<(), CheckError> {
+        if self.is_cancelled() {
+            Err(CheckError::Cancelled)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+struct CheckFilesLoop<'a> {
+    scheduler: &'a dyn CheckScheduler,
+    cancellation_token: CancellationToken,
+    pending: usize,
+    queued_files: FxHashSet<FileId>,
+}
+
+impl<'a> CheckFilesLoop<'a> {
+    fn new(scheduler: &'a dyn CheckScheduler, cancellation_token: CancellationToken) -> Self {
+        Self {
+            scheduler,
+            cancellation_token,
+
+            queued_files: FxHashSet::default(),
+            pending: 0,
+        }
+    }
+
+    fn run(mut self, files: impl Iterator<Item = FileId>) -> Result<Vec<String>, CheckError> {
+        let (sender, receiver) = if let Some(max_concurrency) = self.scheduler.max_concurrency() {
+            crossbeam_channel::bounded(max_concurrency.get())
+        } else {
+            // The checks run on the current thread. That means it is necessary to store all messages
+            // or we risk deadlocking when the main loop never gets a chance to read the messages.
+            crossbeam_channel::unbounded()
+        };
+
+        let context = CheckContext::new(self.cancellation_token.clone(), sender.clone());
+
+        for file in files {
+            self.queue_file(file, context.clone())?;
+        }
+
+        self.run_impl(receiver, &context)
+    }
+
+    fn run_impl(
+        mut self,
+        receiver: crossbeam_channel::Receiver<CheckFileMessage>,
+        context: &CheckContext,
+    ) -> Result<Vec<String>, CheckError> {
+        if self.cancellation_token.is_cancelled() {
+            return Err(CheckError::Cancelled);
+        }
+
+        let mut result = Vec::default();
+
+        for message in receiver {
+            match message {
+                CheckFileMessage::Completed(diagnostics) => {
+                    result.extend_from_slice(&diagnostics);
+
+                    self.pending -= 1;
+
+                    if self.pending == 0 {
+                        break;
+                    }
+                }
+                CheckFileMessage::Queue(id) => {
+                    self.queue_file(id, context.clone())?;
+                }
+                CheckFileMessage::Cancelled => {
+                    return Err(CheckError::Cancelled);
+                }
+            }
+        }
+
+        Ok(result)
+    }
+
+    fn queue_file(&mut self, file_id: FileId, context: CheckContext) -> Result<(), CheckError> {
+        if context.is_cancelled() {
+            return Err(CheckError::Cancelled);
+        }
+
+        if self.queued_files.insert(file_id) {
+            self.pending += 1;
+
+            self.scheduler
+                .check_file(CheckFileTask { file_id, context });
+        }
+
+        Ok(())
+    }
+}
+
+enum CheckFileMessage {
+    Completed(Diagnostics),
+    Queue(FileId),
+    Cancelled,
+}

crates/red_knot/src/program/mod.rs

@@ -0,0 +1,176 @@
+pub mod check;
+
+use std::path::Path;
+use std::sync::Arc;
+
+use crate::db::{Db, HasJar, SemanticDb, SemanticJar, SourceDb, SourceJar};
+use crate::files::{FileId, Files};
+use crate::lint::{lint_syntax, Diagnostics, LintSyntaxStorage};
+use crate::module::{
+    add_module, file_to_module, path_to_module, resolve_module, set_module_search_paths, Module,
+    ModuleData, ModuleName, ModuleResolver, ModuleSearchPath,
+};
+use crate::parse::{parse, Parsed, ParsedStorage};
+use crate::source::{source_text, Source, SourceStorage};
+use crate::symbols::{symbol_table, SymbolId, SymbolTable, SymbolTablesStorage};
+use crate::types::{infer_symbol_type, Type, TypeStore};
+use crate::Workspace;
+
+#[derive(Debug)]
+pub struct Program {
+    files: Files,
+    source: SourceJar,
+    semantic: SemanticJar,
+    workspace: Workspace,
+}
+
+impl Program {
+    pub fn new(workspace: Workspace, module_search_paths: Vec<ModuleSearchPath>) -> Self {
+        Self {
+            source: SourceJar {
+                sources: SourceStorage::default(),
+                parsed: ParsedStorage::default(),
+                lint_syntax: LintSyntaxStorage::default(),
+            },
+            semantic: SemanticJar {
+                module_resolver: ModuleResolver::new(module_search_paths),
+                symbol_tables: SymbolTablesStorage::default(),
+                type_store: TypeStore::default(),
+            },
+            files: Files::default(),
+            workspace,
+        }
+    }
+
+    pub fn apply_changes<I>(&mut self, changes: I)
+    where
+        I: IntoIterator<Item = FileChange>,
+    {
+        for change in changes {
+            self.semantic
+                .module_resolver
+                .remove_module(&self.file_path(change.id));
+            self.semantic.symbol_tables.remove(&change.id);
+            self.source.sources.remove(&change.id);
+            self.source.parsed.remove(&change.id);
+            self.source.lint_syntax.remove(&change.id);
+            // TODO: remove all dependent modules as well
+            self.semantic.type_store.remove_module(change.id);
+        }
+    }
+
+    pub fn files(&self) -> &Files {
+        &self.files
+    }
+
+    pub fn workspace(&self) -> &Workspace {
+        &self.workspace
+    }
+
+    pub fn workspace_mut(&mut self) -> &mut Workspace {
+        &mut self.workspace
+    }
+}
+
+impl SourceDb for Program {
+    fn file_id(&self, path: &Path) -> FileId {
+        self.files.intern(path)
+    }
+
+    fn file_path(&self, file_id: FileId) -> Arc<Path> {
+        self.files.path(file_id)
+    }
+
+    fn source(&self, file_id: FileId) -> Source {
+        source_text(self, file_id)
+    }
+
+    fn parse(&self, file_id: FileId) -> Parsed {
+        parse(self, file_id)
+    }
+
+    fn lint_syntax(&self, file_id: FileId) -> Diagnostics {
+        lint_syntax(self, file_id)
+    }
+}
+
+impl SemanticDb for Program {
+    fn resolve_module(&self, name: ModuleName) -> Option<Module> {
+        resolve_module(self, name)
+    }
+
+    fn file_to_module(&self, file_id: FileId) -> Option<Module> {
+        file_to_module(self, file_id)
+    }
+
+    fn path_to_module(&self, path: &Path) -> Option<Module> {
+        path_to_module(self, path)
+    }
+
+    fn symbol_table(&self, file_id: FileId) -> Arc<SymbolTable> {
+        symbol_table(self, file_id)
+    }
+
+    fn infer_symbol_type(&self, file_id: FileId, symbol_id: SymbolId) -> Type {
+        infer_symbol_type(self, file_id, symbol_id)
+    }
+
+    // Mutations
+
+    fn add_module(&mut self, path: &Path) -> Option<(Module, Vec<Arc<ModuleData>>)> {
+        add_module(self, path)
+    }
+
+    fn set_module_search_paths(&mut self, paths: Vec<ModuleSearchPath>) {
+        set_module_search_paths(self, paths);
+    }
+}
+
+impl Db for Program {}
+
+impl HasJar<SourceJar> for Program {
+    fn jar(&self) -> &SourceJar {
+        &self.source
+    }
+
+    fn jar_mut(&mut self) -> &mut SourceJar {
+        &mut self.source
+    }
+}
+
+impl HasJar<SemanticJar> for Program {
+    fn jar(&self) -> &SemanticJar {
+        &self.semantic
+    }
+
+    fn jar_mut(&mut self) -> &mut SemanticJar {
+        &mut self.semantic
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct FileChange {
+    id: FileId,
+    kind: FileChangeKind,
+}
+
+impl FileChange {
+    pub fn new(file_id: FileId, kind: FileChangeKind) -> Self {
+        Self { id: file_id, kind }
+    }
+
+    pub fn file_id(&self) -> FileId {
+        self.id
+    }
+
+    pub fn kind(&self) -> FileChangeKind {
+        self.kind
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum FileChangeKind {
+    Created,
+    Modified,
+    Deleted,
+}

crates/red_knot/src/source.rs

@@ -0,0 +1,96 @@
+use crate::cache::KeyValueCache;
+use crate::db::{HasJar, SourceDb, SourceJar};
+use ruff_notebook::Notebook;
+use ruff_python_ast::PySourceType;
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+
+use crate::files::FileId;
+
+#[tracing::instrument(level = "debug", skip(db))]
+pub(crate) fn source_text<Db>(db: &Db, file_id: FileId) -> Source
+where
+    Db: SourceDb + HasJar<SourceJar>,
+{
+    let sources = &db.jar().sources;
+
+    sources.get(&file_id, |file_id| {
+        let path = db.file_path(*file_id);
+
+        let source_text = std::fs::read_to_string(&path).unwrap_or_else(|err| {
+            tracing::error!("Failed to read file '{path:?}: {err}'. Falling back to empty text");
+            String::new()
+        });
+
+        let python_ty = PySourceType::from(&path);
+
+        let kind = match python_ty {
+            PySourceType::Python => {
+                SourceKind::Python(Arc::from(source_text))
+            }
+            PySourceType::Stub => SourceKind::Stub(Arc::from(source_text)),
+            PySourceType::Ipynb => {
+                let notebook = Notebook::from_source_code(&source_text).unwrap_or_else(|err| {
+                    // TODO should this be changed to never fail?
+                    // or should we instead add a diagnostic somewhere? But what would we return in this case?
+                    tracing::error!(
+                        "Failed to parse notebook '{path:?}: {err}'. Falling back to an empty notebook"
+                    );
+                    Notebook::from_source_code("").unwrap()
+                });
+
+                SourceKind::IpyNotebook(Arc::new(notebook))
+            }
+        };
+
+        Source { kind }
+    })
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum SourceKind {
+    Python(Arc<str>),
+    Stub(Arc<str>),
+    IpyNotebook(Arc<Notebook>),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Source {
+    kind: SourceKind,
+}
+
+impl Source {
+    pub fn python<T: Into<Arc<str>>>(source: T) -> Self {
+        Self {
+            kind: SourceKind::Python(source.into()),
+        }
+    }
+    pub fn kind(&self) -> &SourceKind {
+        &self.kind
+    }
+
+    pub fn text(&self) -> &str {
+        match &self.kind {
+            SourceKind::Python(text) => text,
+            SourceKind::Stub(text) => text,
+            SourceKind::IpyNotebook(notebook) => notebook.source_code(),
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct SourceStorage(pub(crate) KeyValueCache<FileId, Source>);
+
+impl Deref for SourceStorage {
+    type Target = KeyValueCache<FileId, Source>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for SourceStorage {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}

crates/red_knot/src/symbols.rs

@@ -0,0 +1,816 @@
+#![allow(dead_code)]
+
+use std::hash::{Hash, Hasher};
+use std::iter::{Copied, DoubleEndedIterator, FusedIterator};
+use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
+
+use hashbrown::hash_map::{Keys, RawEntryMut};
+use rustc_hash::{FxHashMap, FxHasher};
+
+use ruff_index::{newtype_index, IndexVec};
+use ruff_python_ast as ast;
+use ruff_python_ast::visitor::preorder::PreorderVisitor;
+
+use crate::ast_ids::TypedNodeKey;
+use crate::cache::KeyValueCache;
+use crate::db::{HasJar, SemanticDb, SemanticJar};
+use crate::files::FileId;
+use crate::module::{Module, ModuleName};
+use crate::Name;
+
+#[allow(unreachable_pub)]
+#[tracing::instrument(level = "debug", skip(db))]
+pub fn symbol_table<Db>(db: &Db, file_id: FileId) -> Arc<SymbolTable>
+where
+    Db: SemanticDb + HasJar<SemanticJar>,
+{
+    let jar = db.jar();
+
+    jar.symbol_tables.get(&file_id, |_| {
+        let parsed = db.parse(file_id);
+        Arc::from(SymbolTable::from_ast(parsed.ast()))
+    })
+}
+
+type Map<K, V> = hashbrown::HashMap<K, V, ()>;
+
+#[newtype_index]
+pub(crate) struct ScopeId;
+
+impl ScopeId {
+    pub(crate) fn scope(self, table: &SymbolTable) -> &Scope {
+        &table.scopes_by_id[self]
+    }
+}
+
+#[newtype_index]
+pub struct SymbolId;
+
+impl SymbolId {
+    pub(crate) fn symbol(self, table: &SymbolTable) -> &Symbol {
+        &table.symbols_by_id[self]
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub(crate) enum ScopeKind {
+    Module,
+    Annotation,
+    Class,
+    Function,
+}
+
+#[derive(Debug)]
+pub(crate) struct Scope {
+    name: Name,
+    kind: ScopeKind,
+    child_scopes: Vec<ScopeId>,
+    // symbol IDs, hashed by symbol name
+    symbols_by_name: Map<SymbolId, ()>,
+}
+
+impl Scope {
+    pub(crate) fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    pub(crate) fn kind(&self) -> ScopeKind {
+        self.kind
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Symbol {
+    name: Name,
+}
+
+impl Symbol {
+    pub(crate) fn name(&self) -> &str {
+        self.name.as_str()
+    }
+}
+
+// TODO storing TypedNodeKey for definitions means we have to search to find them again in the AST;
+// this is at best O(log n). If looking up definitions is a bottleneck we should look for
+// alternatives here.
+#[derive(Debug)]
+pub(crate) enum Definition {
+    // For the import cases, we don't need reference to any arbitrary AST subtrees (annotations,
+    // RHS), and referencing just the import statement node is imprecise (a single import statement
+    // can assign many symbols, we'd have to re-search for the one we care about), so we just copy
+    // the small amount of information we need from the AST.
+    Import(ImportDefinition),
+    ImportFrom(ImportFromDefinition),
+    ClassDef(TypedNodeKey<ast::StmtClassDef>),
+    FunctionDef(TypedNodeKey<ast::StmtFunctionDef>),
+    Assignment(TypedNodeKey<ast::StmtAssign>),
+    AnnotatedAssignment(TypedNodeKey<ast::StmtAnnAssign>),
+    // TODO with statements, except handlers, function args...
+}
+
+#[derive(Debug)]
+pub(crate) struct ImportDefinition {
+    pub(crate) module: Name,
+}
+
+#[derive(Debug)]
+pub(crate) struct ImportFromDefinition {
+    pub(crate) module: Option<Name>,
+    pub(crate) name: Name,
+    pub(crate) level: u32,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum Dependency {
+    Module(Name),
+    Relative { level: u32, module: Option<Name> },
+}
+
+impl Dependency {
+    pub(crate) fn module_name<Db>(&self, db: &Db, relative_to: Option<Module>) -> Option<ModuleName>
+    where
+        Db: SemanticDb + HasJar<SemanticJar>,
+    {
+        match self {
+            Dependency::Module(name) => Some(ModuleName::new(name.as_str())),
+            Dependency::Relative { level, module } => {
+                relative_to?.relative_name(db, *level, module.as_deref())
+            }
+        }
+    }
+}
+
+/// Table of all symbols in all scopes for a module.
+#[derive(Debug)]
+pub struct SymbolTable {
+    scopes_by_id: IndexVec<ScopeId, Scope>,
+    symbols_by_id: IndexVec<SymbolId, Symbol>,
+    defs: FxHashMap<SymbolId, Vec<Definition>>,
+    dependencies: Vec<Dependency>,
+}
+
+impl SymbolTable {
+    pub(crate) fn from_ast(module: &ast::ModModule) -> Self {
+        let root_scope_id = SymbolTable::root_scope_id();
+        let mut builder = SymbolTableBuilder {
+            table: SymbolTable::new(),
+            scopes: vec![root_scope_id],
+        };
+        builder.visit_body(&module.body);
+        builder.table
+    }
+
+    pub(crate) fn new() -> Self {
+        let mut table = SymbolTable {
+            scopes_by_id: IndexVec::new(),
+            symbols_by_id: IndexVec::new(),
+            defs: FxHashMap::default(),
+            dependencies: Vec::new(),
+        };
+        table.scopes_by_id.push(Scope {
+            name: Name::new("<module>"),
+            kind: ScopeKind::Module,
+            child_scopes: Vec::new(),
+            symbols_by_name: Map::default(),
+        });
+        table
+    }
+
+    pub(crate) fn dependencies(&self) -> &[Dependency] {
+        &self.dependencies
+    }
+
+    pub(crate) const fn root_scope_id() -> ScopeId {
+        ScopeId::from_usize(0)
+    }
+
+    pub(crate) fn root_scope(&self) -> &Scope {
+        &self.scopes_by_id[SymbolTable::root_scope_id()]
+    }
+
+    pub(crate) fn symbol_ids_for_scope(&self, scope_id: ScopeId) -> Copied<Keys<SymbolId, ()>> {
+        self.scopes_by_id[scope_id].symbols_by_name.keys().copied()
+    }
+
+    pub(crate) fn symbols_for_scope(
+        &self,
+        scope_id: ScopeId,
+    ) -> SymbolIterator<Copied<Keys<SymbolId, ()>>> {
+        SymbolIterator {
+            table: self,
+            ids: self.symbol_ids_for_scope(scope_id),
+        }
+    }
+
+    pub(crate) fn root_symbol_ids(&self) -> Copied<Keys<SymbolId, ()>> {
+        self.symbol_ids_for_scope(SymbolTable::root_scope_id())
+    }
+
+    pub(crate) fn root_symbols(&self) -> SymbolIterator<Copied<Keys<SymbolId, ()>>> {
+        self.symbols_for_scope(SymbolTable::root_scope_id())
+    }
+
+    pub(crate) fn child_scope_ids_of(&self, scope_id: ScopeId) -> &[ScopeId] {
+        &self.scopes_by_id[scope_id].child_scopes
+    }
+
+    pub(crate) fn child_scopes_of(&self, scope_id: ScopeId) -> ScopeIterator<&[ScopeId]> {
+        ScopeIterator {
+            table: self,
+            ids: self.child_scope_ids_of(scope_id),
+        }
+    }
+
+    pub(crate) fn root_child_scope_ids(&self) -> &[ScopeId] {
+        self.child_scope_ids_of(SymbolTable::root_scope_id())
+    }
+
+    pub(crate) fn root_child_scopes(&self) -> ScopeIterator<&[ScopeId]> {
+        self.child_scopes_of(SymbolTable::root_scope_id())
+    }
+
+    pub(crate) fn symbol_id_by_name(&self, scope_id: ScopeId, name: &str) -> Option<SymbolId> {
+        let scope = &self.scopes_by_id[scope_id];
+        let hash = SymbolTable::hash_name(name);
+        let name = Name::new(name);
+        scope
+            .symbols_by_name
+            .raw_entry()
+            .from_hash(hash, |symid| self.symbols_by_id[*symid].name == name)
+            .map(|(symbol_id, ())| *symbol_id)
+    }
+
+    pub(crate) fn symbol_by_name(&self, scope_id: ScopeId, name: &str) -> Option<&Symbol> {
+        Some(&self.symbols_by_id[self.symbol_id_by_name(scope_id, name)?])
+    }
+
+    pub(crate) fn root_symbol_id_by_name(&self, name: &str) -> Option<SymbolId> {
+        self.symbol_id_by_name(SymbolTable::root_scope_id(), name)
+    }
+
+    pub(crate) fn root_symbol_by_name(&self, name: &str) -> Option<&Symbol> {
+        self.symbol_by_name(SymbolTable::root_scope_id(), name)
+    }
+
+    pub(crate) fn defs(&self, symbol_id: SymbolId) -> &[Definition] {
+        self.defs
+            .get(&symbol_id)
+            .map(std::vec::Vec::as_slice)
+            .unwrap_or_default()
+    }
+
+    fn add_symbol_to_scope(&mut self, scope_id: ScopeId, name: &str) -> SymbolId {
+        let hash = SymbolTable::hash_name(name);
+        let scope = &mut self.scopes_by_id[scope_id];
+        let name = Name::new(name);
+
+        let entry = scope
+            .symbols_by_name
+            .raw_entry_mut()
+            .from_hash(hash, |existing| self.symbols_by_id[*existing].name == name);
+
+        match entry {
+            RawEntryMut::Occupied(entry) => *entry.key(),
+            RawEntryMut::Vacant(entry) => {
+                let id = self.symbols_by_id.push(Symbol { name });
+                entry.insert_with_hasher(hash, id, (), |_| hash);
+                id
+            }
+        }
+    }
+
+    fn add_child_scope(
+        &mut self,
+        parent_scope_id: ScopeId,
+        name: &str,
+        kind: ScopeKind,
+    ) -> ScopeId {
+        let new_scope_id = self.scopes_by_id.push(Scope {
+            name: Name::new(name),
+            kind,
+            child_scopes: Vec::new(),
+            symbols_by_name: Map::default(),
+        });
+        let parent_scope = &mut self.scopes_by_id[parent_scope_id];
+        parent_scope.child_scopes.push(new_scope_id);
+        new_scope_id
+    }
+
+    fn hash_name(name: &str) -> u64 {
+        let mut hasher = FxHasher::default();
+        name.hash(&mut hasher);
+        hasher.finish()
+    }
+}
+
+pub(crate) struct SymbolIterator<'a, I> {
+    table: &'a SymbolTable,
+    ids: I,
+}
+
+impl<'a, I> Iterator for SymbolIterator<'a, I>
+where
+    I: Iterator<Item = SymbolId>,
+{
+    type Item = &'a Symbol;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let id = self.ids.next()?;
+        Some(&self.table.symbols_by_id[id])
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.ids.size_hint()
+    }
+}
+
+impl<'a, I> FusedIterator for SymbolIterator<'a, I> where
+    I: Iterator<Item = SymbolId> + FusedIterator
+{
+}
+
+impl<'a, I> DoubleEndedIterator for SymbolIterator<'a, I>
+where
+    I: Iterator<Item = SymbolId> + DoubleEndedIterator,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let id = self.ids.next_back()?;
+        Some(&self.table.symbols_by_id[id])
+    }
+}
+
+pub(crate) struct ScopeIterator<'a, I> {
+    table: &'a SymbolTable,
+    ids: I,
+}
+
+impl<'a, I> Iterator for ScopeIterator<'a, I>
+where
+    I: Iterator<Item = ScopeId>,
+{
+    type Item = &'a Scope;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let id = self.ids.next()?;
+        Some(&self.table.scopes_by_id[id])
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.ids.size_hint()
+    }
+}
+
+impl<'a, I> FusedIterator for ScopeIterator<'a, I> where I: Iterator<Item = ScopeId> + FusedIterator {}
+
+impl<'a, I> DoubleEndedIterator for ScopeIterator<'a, I>
+where
+    I: Iterator<Item = ScopeId> + DoubleEndedIterator,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let id = self.ids.next_back()?;
+        Some(&self.table.scopes_by_id[id])
+    }
+}
+
+struct SymbolTableBuilder {
+    table: SymbolTable,
+    scopes: Vec<ScopeId>,
+}
+
+impl SymbolTableBuilder {
+    fn add_symbol(&mut self, identifier: &str) -> SymbolId {
+        self.table.add_symbol_to_scope(self.cur_scope(), identifier)
+    }
+
+    fn add_symbol_with_def(&mut self, identifier: &str, definition: Definition) -> SymbolId {
+        let symbol_id = self.add_symbol(identifier);
+        self.table
+            .defs
+            .entry(symbol_id)
+            .or_default()
+            .push(definition);
+        symbol_id
+    }
+
+    fn push_scope(&mut self, child_of: ScopeId, name: &str, kind: ScopeKind) -> ScopeId {
+        let scope_id = self.table.add_child_scope(child_of, name, kind);
+        self.scopes.push(scope_id);
+        scope_id
+    }
+
+    fn pop_scope(&mut self) -> ScopeId {
+        self.scopes
+            .pop()
+            .expect("Scope stack should never be empty")
+    }
+
+    fn cur_scope(&self) -> ScopeId {
+        *self
+            .scopes
+            .last()
+            .expect("Scope stack should never be empty")
+    }
+
+    fn with_type_params(
+        &mut self,
+        name: &str,
+        params: &Option<Box<ast::TypeParams>>,
+        nested: impl FnOnce(&mut Self),
+    ) {
+        if let Some(type_params) = params {
+            self.push_scope(self.cur_scope(), name, ScopeKind::Annotation);
+            for type_param in &type_params.type_params {
+                let name = match type_param {
+                    ast::TypeParam::TypeVar(ast::TypeParamTypeVar { name, .. }) => name,
+                    ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, .. }) => name,
+                    ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple { name, .. }) => name,
+                };
+                self.add_symbol(name);
+            }
+        }
+        nested(self);
+        if params.is_some() {
+            self.pop_scope();
+        }
+    }
+}
+
+impl PreorderVisitor<'_> for SymbolTableBuilder {
+    fn visit_expr(&mut self, expr: &ast::Expr) {
+        if let ast::Expr::Name(ast::ExprName { id, .. }) = expr {
+            self.add_symbol(id);
+        }
+        ast::visitor::preorder::walk_expr(self, expr);
+    }
+
+    fn visit_stmt(&mut self, stmt: &ast::Stmt) {
+        // TODO need to capture more definition statements here
+        match stmt {
+            ast::Stmt::ClassDef(node) => {
+                let def = Definition::ClassDef(TypedNodeKey::from_node(node));
+                self.add_symbol_with_def(&node.name, def);
+                self.with_type_params(&node.name, &node.type_params, |builder| {
+                    builder.push_scope(builder.cur_scope(), &node.name, ScopeKind::Class);
+                    ast::visitor::preorder::walk_stmt(builder, stmt);
+                    builder.pop_scope();
+                });
+            }
+            ast::Stmt::FunctionDef(node) => {
+                let def = Definition::FunctionDef(TypedNodeKey::from_node(node));
+                self.add_symbol_with_def(&node.name, def);
+                self.with_type_params(&node.name, &node.type_params, |builder| {
+                    builder.push_scope(builder.cur_scope(), &node.name, ScopeKind::Function);
+                    ast::visitor::preorder::walk_stmt(builder, stmt);
+                    builder.pop_scope();
+                });
+            }
+            ast::Stmt::Import(ast::StmtImport { names, .. }) => {
+                for alias in names {
+                    let symbol_name = if let Some(asname) = &alias.asname {
+                        asname.id.as_str()
+                    } else {
+                        alias.name.id.split('.').next().unwrap()
+                    };
+
+                    let module = Name::new(&alias.name.id);
+
+                    let def = Definition::Import(ImportDefinition {
+                        module: module.clone(),
+                    });
+                    self.add_symbol_with_def(symbol_name, def);
+                    self.table.dependencies.push(Dependency::Module(module));
+                }
+            }
+            ast::Stmt::ImportFrom(ast::StmtImportFrom {
+                module,
+                names,
+                level,
+                ..
+            }) => {
+                let module = module.as_ref().map(|m| Name::new(&m.id));
+
+                for alias in names {
+                    let symbol_name = if let Some(asname) = &alias.asname {
+                        asname.id.as_str()
+                    } else {
+                        alias.name.id.as_str()
+                    };
+                    let def = Definition::ImportFrom(ImportFromDefinition {
+                        module: module.clone(),
+                        name: Name::new(&alias.name.id),
+                        level: *level,
+                    });
+                    self.add_symbol_with_def(symbol_name, def);
+                }
+
+                let dependency = if let Some(module) = module {
+                    if *level == 0 {
+                        Dependency::Module(module)
+                    } else {
+                        Dependency::Relative {
+                            level: *level,
+                            module: Some(module),
+                        }
+                    }
+                } else {
+                    Dependency::Relative {
+                        level: *level,
+                        module,
+                    }
+                };
+
+                self.table.dependencies.push(dependency);
+            }
+            _ => {
+                ast::visitor::preorder::walk_stmt(self, stmt);
+            }
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct SymbolTablesStorage(KeyValueCache<FileId, Arc<SymbolTable>>);
+
+impl Deref for SymbolTablesStorage {
+    type Target = KeyValueCache<FileId, Arc<SymbolTable>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for SymbolTablesStorage {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use textwrap::dedent;
+
+    use crate::parse::Parsed;
+    use crate::symbols::ScopeKind;
+
+    use super::{SymbolId, SymbolIterator, SymbolTable};
+
+    mod from_ast {
+        use super::*;
+
+        fn parse(code: &str) -> Parsed {
+            Parsed::from_text(&dedent(code))
+        }
+
+        fn names<I>(it: SymbolIterator<I>) -> Vec<&str>
+        where
+            I: Iterator<Item = SymbolId>,
+        {
+            let mut symbols: Vec<_> = it.map(|sym| sym.name.as_str()).collect();
+            symbols.sort_unstable();
+            symbols
+        }
+
+        #[test]
+        fn empty() {
+            let parsed = parse("");
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()).len(), 0);
+        }
+
+        #[test]
+        fn simple() {
+            let parsed = parse("x");
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()), vec!["x"]);
+            assert_eq!(
+                table.defs(table.root_symbol_id_by_name("x").unwrap()).len(),
+                0
+            );
+        }
+
+        #[test]
+        fn annotation_only() {
+            let parsed = parse("x: int");
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()), vec!["int", "x"]);
+            // TODO record definition
+        }
+
+        #[test]
+        fn import() {
+            let parsed = parse("import foo");
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()), vec!["foo"]);
+            assert_eq!(
+                table
+                    .defs(table.root_symbol_id_by_name("foo").unwrap())
+                    .len(),
+                1
+            );
+        }
+
+        #[test]
+        fn import_sub() {
+            let parsed = parse("import foo.bar");
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()), vec!["foo"]);
+        }
+
+        #[test]
+        fn import_as() {
+            let parsed = parse("import foo.bar as baz");
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()), vec!["baz"]);
+        }
+
+        #[test]
+        fn import_from() {
+            let parsed = parse("from bar import foo");
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()), vec!["foo"]);
+            assert_eq!(
+                table
+                    .defs(table.root_symbol_id_by_name("foo").unwrap())
+                    .len(),
+                1
+            );
+        }
+
+        #[test]
+        fn class_scope() {
+            let parsed = parse(
+                "
+                class C:
+                    x = 1
+                y = 2
+                ",
+            );
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()), vec!["C", "y"]);
+            let scopes = table.root_child_scope_ids();
+            assert_eq!(scopes.len(), 1);
+            let c_scope = scopes[0].scope(&table);
+            assert_eq!(c_scope.kind(), ScopeKind::Class);
+            assert_eq!(c_scope.name(), "C");
+            assert_eq!(names(table.symbols_for_scope(scopes[0])), vec!["x"]);
+            assert_eq!(
+                table.defs(table.root_symbol_id_by_name("C").unwrap()).len(),
+                1
+            );
+        }
+
+        #[test]
+        fn func_scope() {
+            let parsed = parse(
+                "
+                def func():
+                    x = 1
+                y = 2
+                ",
+            );
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()), vec!["func", "y"]);
+            let scopes = table.root_child_scope_ids();
+            assert_eq!(scopes.len(), 1);
+            let func_scope = scopes[0].scope(&table);
+            assert_eq!(func_scope.kind(), ScopeKind::Function);
+            assert_eq!(func_scope.name(), "func");
+            assert_eq!(names(table.symbols_for_scope(scopes[0])), vec!["x"]);
+            assert_eq!(
+                table
+                    .defs(table.root_symbol_id_by_name("func").unwrap())
+                    .len(),
+                1
+            );
+        }
+
+        #[test]
+        fn dupes() {
+            let parsed = parse(
+                "
+                def func():
+                    x = 1
+                def func():
+                    y = 2
+                ",
+            );
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()), vec!["func"]);
+            let scopes = table.root_child_scope_ids();
+            assert_eq!(scopes.len(), 2);
+            let func_scope_1 = scopes[0].scope(&table);
+            let func_scope_2 = scopes[1].scope(&table);
+            assert_eq!(func_scope_1.kind(), ScopeKind::Function);
+            assert_eq!(func_scope_1.name(), "func");
+            assert_eq!(func_scope_2.kind(), ScopeKind::Function);
+            assert_eq!(func_scope_2.name(), "func");
+            assert_eq!(names(table.symbols_for_scope(scopes[0])), vec!["x"]);
+            assert_eq!(names(table.symbols_for_scope(scopes[1])), vec!["y"]);
+            assert_eq!(
+                table
+                    .defs(table.root_symbol_id_by_name("func").unwrap())
+                    .len(),
+                2
+            );
+        }
+
+        #[test]
+        fn generic_func() {
+            let parsed = parse(
+                "
+                def func[T]():
+                    x = 1
+                ",
+            );
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()), vec!["func"]);
+            let scopes = table.root_child_scope_ids();
+            assert_eq!(scopes.len(), 1);
+            let ann_scope_id = scopes[0];
+            let ann_scope = ann_scope_id.scope(&table);
+            assert_eq!(ann_scope.kind(), ScopeKind::Annotation);
+            assert_eq!(ann_scope.name(), "func");
+            assert_eq!(names(table.symbols_for_scope(ann_scope_id)), vec!["T"]);
+            let scopes = table.child_scope_ids_of(ann_scope_id);
+            assert_eq!(scopes.len(), 1);
+            let func_scope_id = scopes[0];
+            let func_scope = func_scope_id.scope(&table);
+            assert_eq!(func_scope.kind(), ScopeKind::Function);
+            assert_eq!(func_scope.name(), "func");
+            assert_eq!(names(table.symbols_for_scope(func_scope_id)), vec!["x"]);
+        }
+
+        #[test]
+        fn generic_class() {
+            let parsed = parse(
+                "
+                class C[T]:
+                    x = 1
+                ",
+            );
+            let table = SymbolTable::from_ast(parsed.ast());
+            assert_eq!(names(table.root_symbols()), vec!["C"]);
+            let scopes = table.root_child_scope_ids();
+            assert_eq!(scopes.len(), 1);
+            let ann_scope_id = scopes[0];
+            let ann_scope = ann_scope_id.scope(&table);
+            assert_eq!(ann_scope.kind(), ScopeKind::Annotation);
+            assert_eq!(ann_scope.name(), "C");
+            assert_eq!(names(table.symbols_for_scope(ann_scope_id)), vec!["T"]);
+            let scopes = table.child_scope_ids_of(ann_scope_id);
+            assert_eq!(scopes.len(), 1);
+            let func_scope_id = scopes[0];
+            let func_scope = func_scope_id.scope(&table);
+            assert_eq!(func_scope.kind(), ScopeKind::Class);
+            assert_eq!(func_scope.name(), "C");
+            assert_eq!(names(table.symbols_for_scope(func_scope_id)), vec!["x"]);
+        }
+    }
+
+    #[test]
+    fn insert_same_name_symbol_twice() {
+        let mut table = SymbolTable::new();
+        let root_scope_id = SymbolTable::root_scope_id();
+        let symbol_id_1 = table.add_symbol_to_scope(root_scope_id, "foo");
+        let symbol_id_2 = table.add_symbol_to_scope(root_scope_id, "foo");
+        assert_eq!(symbol_id_1, symbol_id_2);
+    }
+
+    #[test]
+    fn insert_different_named_symbols() {
+        let mut table = SymbolTable::new();
+        let root_scope_id = SymbolTable::root_scope_id();
+        let symbol_id_1 = table.add_symbol_to_scope(root_scope_id, "foo");
+        let symbol_id_2 = table.add_symbol_to_scope(root_scope_id, "bar");
+        assert_ne!(symbol_id_1, symbol_id_2);
+    }
+
+    #[test]
+    fn add_child_scope_with_symbol() {
+        let mut table = SymbolTable::new();
+        let root_scope_id = SymbolTable::root_scope_id();
+        let foo_symbol_top = table.add_symbol_to_scope(root_scope_id, "foo");
+        let c_scope = table.add_child_scope(root_scope_id, "C", ScopeKind::Class);
+        let foo_symbol_inner = table.add_symbol_to_scope(c_scope, "foo");
+        assert_ne!(foo_symbol_top, foo_symbol_inner);
+    }
+
+    #[test]
+    fn scope_from_id() {
+        let table = SymbolTable::new();
+        let root_scope_id = SymbolTable::root_scope_id();
+        let scope = root_scope_id.scope(&table);
+        assert_eq!(scope.name.as_str(), "<module>");
+        assert_eq!(scope.kind, ScopeKind::Module);
+    }
+
+    #[test]
+    fn symbol_from_id() {
+        let mut table = SymbolTable::new();
+        let root_scope_id = SymbolTable::root_scope_id();
+        let foo_symbol_id = table.add_symbol_to_scope(root_scope_id, "foo");
+        let symbol = foo_symbol_id.symbol(&table);
+        assert_eq!(symbol.name.as_str(), "foo");
+    }
+}

crates/red_knot/src/types.rs

@@ -0,0 +1,554 @@
+#![allow(dead_code)]
+use crate::ast_ids::NodeKey;
+use crate::files::FileId;
+use crate::module::ModuleName;
+use crate::symbols::SymbolId;
+use crate::{FxDashMap, FxHashSet, FxIndexSet, Name};
+use ruff_index::{newtype_index, IndexVec};
+use rustc_hash::FxHashMap;
+
+pub(crate) mod infer;
+
+pub(crate) use infer::infer_symbol_type;
+
+/// unique ID for a type
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum Type {
+    /// the dynamic or gradual type: a statically-unknown set of values
+    Any,
+    /// the empty set of values
+    Never,
+    /// unknown type (no annotation)
+    /// equivalent to Any, or to object in strict mode
+    Unknown,
+    /// name is not bound to any value
+    Unbound,
+    /// a specific function object
+    Function(FunctionTypeId),
+    /// a specific class object
+    Class(ClassTypeId),
+    /// the set of Python objects with the given class in their __class__'s method resolution order
+    Instance(ClassTypeId),
+    Union(UnionTypeId),
+    Intersection(IntersectionTypeId),
+    // TODO protocols, callable types, overloads, generics, type vars
+}
+
+impl Type {
+    fn display<'a>(&'a self, store: &'a TypeStore) -> DisplayType<'a> {
+        DisplayType { ty: self, store }
+    }
+}
+
+// TODO: currently calling `get_function` et al and holding on to the `FunctionTypeRef` will lock a
+// shard of this dashmap, for as long as you hold the reference. This may be a problem. We could
+// switch to having all the arenas hold Arc, or we could see if we can split up ModuleTypeStore,
+// and/or give it inner mutability and finer-grained internal locking.
+#[derive(Debug, Default)]
+pub struct TypeStore {
+    modules: FxDashMap<FileId, ModuleTypeStore>,
+}
+
+impl TypeStore {
+    pub fn remove_module(&self, file_id: FileId) {
+        self.modules.remove(&file_id);
+    }
+
+    pub fn cache_symbol_type(&self, file_id: FileId, symbol_id: SymbolId, ty: Type) {
+        self.add_or_get_module(file_id)
+            .symbol_types
+            .insert(symbol_id, ty);
+    }
+
+    pub fn cache_node_type(&self, file_id: FileId, node_key: NodeKey, ty: Type) {
+        self.add_or_get_module(file_id)
+            .node_types
+            .insert(node_key, ty);
+    }
+
+    pub fn get_cached_symbol_type(&self, file_id: FileId, symbol_id: SymbolId) -> Option<Type> {
+        self.try_get_module(file_id)?
+            .symbol_types
+            .get(&symbol_id)
+            .copied()
+    }
+
+    pub fn get_cached_node_type(&self, file_id: FileId, node_key: &NodeKey) -> Option<Type> {
+        self.try_get_module(file_id)?
+            .node_types
+            .get(node_key)
+            .copied()
+    }
+
+    fn add_or_get_module(&self, file_id: FileId) -> ModuleStoreRefMut {
+        self.modules
+            .entry(file_id)
+            .or_insert_with(|| ModuleTypeStore::new(file_id))
+    }
+
+    fn get_module(&self, file_id: FileId) -> ModuleStoreRef {
+        self.try_get_module(file_id).expect("module should exist")
+    }
+
+    fn try_get_module(&self, file_id: FileId) -> Option<ModuleStoreRef> {
+        self.modules.get(&file_id)
+    }
+
+    fn add_function(&self, file_id: FileId, name: &str) -> FunctionTypeId {
+        self.add_or_get_module(file_id).add_function(name)
+    }
+
+    fn add_class(&self, file_id: FileId, name: &str) -> ClassTypeId {
+        self.add_or_get_module(file_id).add_class(name)
+    }
+
+    fn add_union(&self, file_id: FileId, elems: &[Type]) -> UnionTypeId {
+        self.add_or_get_module(file_id).add_union(elems)
+    }
+
+    fn add_intersection(
+        &self,
+        file_id: FileId,
+        positive: &[Type],
+        negative: &[Type],
+    ) -> IntersectionTypeId {
+        self.add_or_get_module(file_id)
+            .add_intersection(positive, negative)
+    }
+
+    fn get_function(&self, id: FunctionTypeId) -> FunctionTypeRef {
+        FunctionTypeRef {
+            module_store: self.get_module(id.file_id),
+            function_id: id.func_id,
+        }
+    }
+
+    fn get_class(&self, id: ClassTypeId) -> ClassTypeRef {
+        ClassTypeRef {
+            module_store: self.get_module(id.file_id),
+            class_id: id.class_id,
+        }
+    }
+
+    fn get_union(&self, id: UnionTypeId) -> UnionTypeRef {
+        UnionTypeRef {
+            module_store: self.get_module(id.file_id),
+            union_id: id.union_id,
+        }
+    }
+
+    fn get_intersection(&self, id: IntersectionTypeId) -> IntersectionTypeRef {
+        IntersectionTypeRef {
+            module_store: self.get_module(id.file_id),
+            intersection_id: id.intersection_id,
+        }
+    }
+
+    fn record_symbol_dependency(&self, from: (FileId, SymbolId), to: (FileId, SymbolId)) {
+        let (from_file_id, from_symbol_id) = from;
+        self.add_or_get_module(from_file_id)
+            .symbol_dependencies
+            .entry(from_symbol_id)
+            .or_default()
+            .insert(to);
+    }
+
+    fn record_module_dependency(&self, from: (FileId, SymbolId), to: ModuleName) {
+        let (from_file_id, from_symbol_id) = from;
+        self.add_or_get_module(from_file_id)
+            .module_dependencies
+            .entry(from_symbol_id)
+            .or_default()
+            .insert(to);
+    }
+}
+
+type ModuleStoreRef<'a> = dashmap::mapref::one::Ref<
+    'a,
+    FileId,
+    ModuleTypeStore,
+    std::hash::BuildHasherDefault<rustc_hash::FxHasher>,
+>;
+
+type ModuleStoreRefMut<'a> = dashmap::mapref::one::RefMut<
+    'a,
+    FileId,
+    ModuleTypeStore,
+    std::hash::BuildHasherDefault<rustc_hash::FxHasher>,
+>;
+
+#[derive(Debug)]
+pub(crate) struct FunctionTypeRef<'a> {
+    module_store: ModuleStoreRef<'a>,
+    function_id: ModuleFunctionTypeId,
+}
+
+impl<'a> std::ops::Deref for FunctionTypeRef<'a> {
+    type Target = FunctionType;
+
+    fn deref(&self) -> &Self::Target {
+        self.module_store.get_function(self.function_id)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ClassTypeRef<'a> {
+    module_store: ModuleStoreRef<'a>,
+    class_id: ModuleClassTypeId,
+}
+
+impl<'a> std::ops::Deref for ClassTypeRef<'a> {
+    type Target = ClassType;
+
+    fn deref(&self) -> &Self::Target {
+        self.module_store.get_class(self.class_id)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct UnionTypeRef<'a> {
+    module_store: ModuleStoreRef<'a>,
+    union_id: ModuleUnionTypeId,
+}
+
+impl<'a> std::ops::Deref for UnionTypeRef<'a> {
+    type Target = UnionType;
+
+    fn deref(&self) -> &Self::Target {
+        self.module_store.get_union(self.union_id)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct IntersectionTypeRef<'a> {
+    module_store: ModuleStoreRef<'a>,
+    intersection_id: ModuleIntersectionTypeId,
+}
+
+impl<'a> std::ops::Deref for IntersectionTypeRef<'a> {
+    type Target = IntersectionType;
+
+    fn deref(&self) -> &Self::Target {
+        self.module_store.get_intersection(self.intersection_id)
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub struct FunctionTypeId {
+    file_id: FileId,
+    func_id: ModuleFunctionTypeId,
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub struct ClassTypeId {
+    file_id: FileId,
+    class_id: ModuleClassTypeId,
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub struct UnionTypeId {
+    file_id: FileId,
+    union_id: ModuleUnionTypeId,
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub struct IntersectionTypeId {
+    file_id: FileId,
+    intersection_id: ModuleIntersectionTypeId,
+}
+
+#[newtype_index]
+struct ModuleFunctionTypeId;
+
+#[newtype_index]
+struct ModuleClassTypeId;
+
+#[newtype_index]
+struct ModuleUnionTypeId;
+
+#[newtype_index]
+struct ModuleIntersectionTypeId;
+
+#[derive(Debug)]
+struct ModuleTypeStore {
+    file_id: FileId,
+    /// arena of all function types defined in this module
+    functions: IndexVec<ModuleFunctionTypeId, FunctionType>,
+    /// arena of all class types defined in this module
+    classes: IndexVec<ModuleClassTypeId, ClassType>,
+    /// arenda of all union types created in this module
+    unions: IndexVec<ModuleUnionTypeId, UnionType>,
+    /// arena of all intersection types created in this module
+    intersections: IndexVec<ModuleIntersectionTypeId, IntersectionType>,
+    /// cached types of symbols in this module
+    symbol_types: FxHashMap<SymbolId, Type>,
+    /// cached types of AST nodes in this module
+    node_types: FxHashMap<NodeKey, Type>,
+    // the inferred type for symbol K depends on the type of symbols in V
+    symbol_dependencies: FxHashMap<SymbolId, FxHashSet<(FileId, SymbolId)>>,
+    // the inferred type for symbol K depends on the modules in V; this type of dependency is
+    // recorded when e.g. the target symbol doesn't exist in the module, so we can't record a
+    // dependency on a symbol, but if the module changes it could still change our resolution)
+    module_dependencies: FxHashMap<SymbolId, FxHashSet<ModuleName>>,
+}
+
+impl ModuleTypeStore {
+    fn new(file_id: FileId) -> Self {
+        Self {
+            file_id,
+            functions: IndexVec::default(),
+            classes: IndexVec::default(),
+            unions: IndexVec::default(),
+            intersections: IndexVec::default(),
+            symbol_types: FxHashMap::default(),
+            node_types: FxHashMap::default(),
+            symbol_dependencies: FxHashMap::default(),
+            module_dependencies: FxHashMap::default(),
+        }
+    }
+
+    fn add_function(&mut self, name: &str) -> FunctionTypeId {
+        let func_id = self.functions.push(FunctionType {
+            name: Name::new(name),
+        });
+        FunctionTypeId {
+            file_id: self.file_id,
+            func_id,
+        }
+    }
+
+    fn add_class(&mut self, name: &str) -> ClassTypeId {
+        let class_id = self.classes.push(ClassType {
+            name: Name::new(name),
+        });
+        ClassTypeId {
+            file_id: self.file_id,
+            class_id,
+        }
+    }
+
+    fn add_union(&mut self, elems: &[Type]) -> UnionTypeId {
+        let union_id = self.unions.push(UnionType {
+            elements: elems.iter().copied().collect(),
+        });
+        UnionTypeId {
+            file_id: self.file_id,
+            union_id,
+        }
+    }
+
+    fn add_intersection(&mut self, positive: &[Type], negative: &[Type]) -> IntersectionTypeId {
+        let intersection_id = self.intersections.push(IntersectionType {
+            positive: positive.iter().copied().collect(),
+            negative: negative.iter().copied().collect(),
+        });
+        IntersectionTypeId {
+            file_id: self.file_id,
+            intersection_id,
+        }
+    }
+
+    fn get_function(&self, func_id: ModuleFunctionTypeId) -> &FunctionType {
+        &self.functions[func_id]
+    }
+
+    fn get_class(&self, class_id: ModuleClassTypeId) -> &ClassType {
+        &self.classes[class_id]
+    }
+
+    fn get_union(&self, union_id: ModuleUnionTypeId) -> &UnionType {
+        &self.unions[union_id]
+    }
+
+    fn get_intersection(&self, intersection_id: ModuleIntersectionTypeId) -> &IntersectionType {
+        &self.intersections[intersection_id]
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+struct DisplayType<'a> {
+    ty: &'a Type,
+    store: &'a TypeStore,
+}
+
+impl std::fmt::Display for DisplayType<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.ty {
+            Type::Any => f.write_str("Any"),
+            Type::Never => f.write_str("Never"),
+            Type::Unknown => f.write_str("Unknown"),
+            Type::Unbound => f.write_str("Unbound"),
+            // TODO functions and classes should display using a fully qualified name
+            Type::Class(class_id) => {
+                f.write_str("Literal[")?;
+                f.write_str(self.store.get_class(*class_id).name())?;
+                f.write_str("]")
+            }
+            Type::Instance(class_id) => f.write_str(self.store.get_class(*class_id).name()),
+            Type::Function(func_id) => f.write_str(self.store.get_function(*func_id).name()),
+            Type::Union(union_id) => self
+                .store
+                .get_module(union_id.file_id)
+                .get_union(union_id.union_id)
+                .display(f, self.store),
+            Type::Intersection(int_id) => self
+                .store
+                .get_module(int_id.file_id)
+                .get_intersection(int_id.intersection_id)
+                .display(f, self.store),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct ClassType {
+    name: Name,
+}
+
+impl ClassType {
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct FunctionType {
+    name: Name,
+}
+
+impl FunctionType {
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct UnionType {
+    // the union type includes values in any of these types
+    elements: FxIndexSet<Type>,
+}
+
+impl UnionType {
+    fn display(&self, f: &mut std::fmt::Formatter<'_>, store: &TypeStore) -> std::fmt::Result {
+        f.write_str("(")?;
+        let mut first = true;
+        for ty in &self.elements {
+            if !first {
+                f.write_str(" | ")?;
+            };
+            first = false;
+            write!(f, "{}", ty.display(store))?;
+        }
+        f.write_str(")")
+    }
+}
+
+// Negation types aren't expressible in annotations, and are most likely to arise from type
+// narrowing along with intersections (e.g. `if not isinstance(...)`), so we represent them
+// directly in intersections rather than as a separate type. This sacrifices some efficiency in the
+// case where a Not appears outside an intersection (unclear when that could even happen, but we'd
+// have to represent it as a single-element intersection if it did) in exchange for better
+// efficiency in the not-within-intersection case.
+#[derive(Debug)]
+pub(crate) struct IntersectionType {
+    // the intersection type includes only values in all of these types
+    positive: FxIndexSet<Type>,
+    // negated elements of the intersection, e.g.
+    negative: FxIndexSet<Type>,
+}
+
+impl IntersectionType {
+    fn display(&self, f: &mut std::fmt::Formatter<'_>, store: &TypeStore) -> std::fmt::Result {
+        f.write_str("(")?;
+        let mut first = true;
+        for (neg, ty) in self
+            .positive
+            .iter()
+            .map(|ty| (false, ty))
+            .chain(self.negative.iter().map(|ty| (true, ty)))
+        {
+            if !first {
+                f.write_str(" & ")?;
+            };
+            first = false;
+            if neg {
+                f.write_str("~")?;
+            };
+            write!(f, "{}", ty.display(store))?;
+        }
+        f.write_str(")")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::files::Files;
+    use crate::types::{Type, TypeStore};
+    use crate::FxIndexSet;
+    use std::path::Path;
+
+    #[test]
+    fn add_class() {
+        let store = TypeStore::default();
+        let files = Files::default();
+        let file_id = files.intern(Path::new("/foo"));
+        let id = store.add_class(file_id, "C");
+        assert_eq!(store.get_class(id).name(), "C");
+        let inst = Type::Instance(id);
+        assert_eq!(format!("{}", inst.display(&store)), "C");
+    }
+
+    #[test]
+    fn add_function() {
+        let store = TypeStore::default();
+        let files = Files::default();
+        let file_id = files.intern(Path::new("/foo"));
+        let id = store.add_function(file_id, "func");
+        assert_eq!(store.get_function(id).name(), "func");
+        let func = Type::Function(id);
+        assert_eq!(format!("{}", func.display(&store)), "func");
+    }
+
+    #[test]
+    fn add_union() {
+        let store = TypeStore::default();
+        let files = Files::default();
+        let file_id = files.intern(Path::new("/foo"));
+        let c1 = store.add_class(file_id, "C1");
+        let c2 = store.add_class(file_id, "C2");
+        let elems = vec![Type::Instance(c1), Type::Instance(c2)];
+        let id = store.add_union(file_id, &elems);
+        assert_eq!(
+            store.get_union(id).elements,
+            elems.into_iter().collect::<FxIndexSet<_>>()
+        );
+        let union = Type::Union(id);
+        assert_eq!(format!("{}", union.display(&store)), "(C1 | C2)");
+    }
+
+    #[test]
+    fn add_intersection() {
+        let store = TypeStore::default();
+        let files = Files::default();
+        let file_id = files.intern(Path::new("/foo"));
+        let c1 = store.add_class(file_id, "C1");
+        let c2 = store.add_class(file_id, "C2");
+        let c3 = store.add_class(file_id, "C3");
+        let pos = vec![Type::Instance(c1), Type::Instance(c2)];
+        let neg = vec![Type::Instance(c3)];
+        let id = store.add_intersection(file_id, &pos, &neg);
+        assert_eq!(
+            store.get_intersection(id).positive,
+            pos.into_iter().collect::<FxIndexSet<_>>()
+        );
+        assert_eq!(
+            store.get_intersection(id).negative,
+            neg.into_iter().collect::<FxIndexSet<_>>()
+        );
+        let intersection = Type::Intersection(id);
+        assert_eq!(
+            format!("{}", intersection.display(&store)),
+            "(C1 & C2 & ~C3)"
+        );
+    }
+}

crates/red_knot/src/types/infer.rs

@@ -0,0 +1,164 @@
+#![allow(dead_code)]
+use crate::db::{HasJar, SemanticDb, SemanticJar};
+use crate::module::ModuleName;
+use crate::symbols::{Definition, ImportFromDefinition, SymbolId};
+use crate::types::Type;
+use crate::FileId;
+use ruff_python_ast::AstNode;
+
+#[tracing::instrument(level = "trace", skip(db))]
+pub fn infer_symbol_type<Db>(db: &Db, file_id: FileId, symbol_id: SymbolId) -> Type
+where
+    Db: SemanticDb + HasJar<SemanticJar>,
+{
+    let symbols = db.symbol_table(file_id);
+    let defs = symbols.defs(symbol_id);
+
+    if let Some(ty) = db
+        .jar()
+        .type_store
+        .get_cached_symbol_type(file_id, symbol_id)
+    {
+        return ty;
+    }
+
+    // TODO handle multiple defs, conditional defs...
+    assert_eq!(defs.len(), 1);
+
+    let ty = match &defs[0] {
+        Definition::ImportFrom(ImportFromDefinition {
+            module,
+            name,
+            level,
+        }) => {
+            // TODO relative imports
+            assert!(matches!(level, 0));
+            let module_name = ModuleName::new(module.as_ref().expect("TODO relative imports"));
+            if let Some(module) = db.resolve_module(module_name.clone()) {
+                let remote_file_id = module.path(db).file();
+                let remote_symbols = db.symbol_table(remote_file_id);
+                if let Some(remote_symbol_id) = remote_symbols.root_symbol_id_by_name(name) {
+                    // TODO integrate this into module and symbol-resolution APIs (requiring a
+                    // "requester" argument) so that it doesn't have to be remembered
+                    db.jar().type_store.record_symbol_dependency(
+                        (file_id, symbol_id),
+                        (remote_file_id, remote_symbol_id),
+                    );
+                    db.infer_symbol_type(remote_file_id, remote_symbol_id)
+                } else {
+                    db.jar()
+                        .type_store
+                        .record_module_dependency((file_id, symbol_id), module_name);
+                    Type::Unknown
+                }
+            } else {
+                db.jar()
+                    .type_store
+                    .record_module_dependency((file_id, symbol_id), module_name);
+                Type::Unknown
+            }
+        }
+        Definition::ClassDef(node_key) => {
+            if let Some(ty) = db
+                .jar()
+                .type_store
+                .get_cached_node_type(file_id, node_key.erased())
+            {
+                ty
+            } else {
+                let parsed = db.parse(file_id);
+                let ast = parsed.ast();
+                let node = node_key.resolve_unwrap(ast.as_any_node_ref());
+
+                let store = &db.jar().type_store;
+                let ty = Type::Class(store.add_class(file_id, &node.name.id));
+                store.cache_node_type(file_id, *node_key.erased(), ty);
+                ty
+            }
+        }
+        _ => todo!("other kinds of definitions"),
+    };
+
+    db.jar()
+        .type_store
+        .cache_symbol_type(file_id, symbol_id, ty);
+    ty
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::db::tests::TestDb;
+    use crate::db::{HasJar, SemanticDb, SemanticJar};
+    use crate::module::{ModuleName, ModuleSearchPath, ModuleSearchPathKind};
+    use crate::types::Type;
+
+    // TODO with virtual filesystem we shouldn't have to write files to disk for these
+    // tests
+
+    struct TestCase {
+        temp_dir: tempfile::TempDir,
+        db: TestDb,
+
+        src: ModuleSearchPath,
+    }
+
+    fn create_test() -> std::io::Result<TestCase> {
+        let temp_dir = tempfile::tempdir()?;
+
+        let src = temp_dir.path().join("src");
+        std::fs::create_dir(&src)?;
+        let src = ModuleSearchPath::new(src.canonicalize()?, ModuleSearchPathKind::FirstParty);
+
+        let roots = vec![src.clone()];
+
+        let mut db = TestDb::default();
+        db.set_module_search_paths(roots);
+
+        Ok(TestCase { temp_dir, db, src })
+    }
+
+    #[test]
+    fn follow_import_to_class() -> std::io::Result<()> {
+        let TestCase {
+            src,
+            db,
+            temp_dir: _temp_dir,
+        } = create_test()?;
+
+        let a_path = src.path().join("a.py");
+        let b_path = src.path().join("b.py");
+        std::fs::write(a_path, "from b import C as D")?;
+        std::fs::write(b_path, "class C: pass")?;
+        let a_file = db
+            .resolve_module(ModuleName::new("a"))
+            .expect("module should be found")
+            .path(&db)
+            .file();
+        let a_syms = db.symbol_table(a_file);
+        let d_sym = a_syms
+            .root_symbol_id_by_name("D")
+            .expect("D symbol should be found");
+
+        let ty = db.infer_symbol_type(a_file, d_sym);
+
+        let b_file = db
+            .resolve_module(ModuleName::new("b"))
+            .expect("module should be found")
+            .path(&db)
+            .file();
+        let b_syms = db.symbol_table(b_file);
+        let c_sym = b_syms
+            .root_symbol_id_by_name("C")
+            .expect("C symbol should be found");
+
+        let jar = HasJar::<SemanticJar>::jar(&db);
+
+        assert!(matches!(ty, Type::Class(_)));
+        assert_eq!(format!("{}", ty.display(&jar.type_store)), "Literal[C]");
+        assert_eq!(
+            jar.type_store.get_module(a_file).symbol_dependencies[&d_sym],
+            [(b_file, c_sym)].iter().copied().collect()
+        );
+        Ok(())
+    }
+}

crates/red_knot/src/watch.rs

@@ -0,0 +1,78 @@
+use anyhow::Context;
+use std::path::Path;
+
+use crate::files::Files;
+use crate::program::{FileChange, FileChangeKind};
+use notify::event::{CreateKind, RemoveKind};
+use notify::{recommended_watcher, Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
+
+pub struct FileWatcher {
+    watcher: RecommendedWatcher,
+}
+
+pub trait EventHandler: Send + 'static {
+    fn handle(&self, changes: Vec<FileChange>);
+}
+
+impl<F> EventHandler for F
+where
+    F: Fn(Vec<FileChange>) + Send + 'static,
+{
+    fn handle(&self, changes: Vec<FileChange>) {
+        let f = self;
+        f(changes);
+    }
+}
+
+impl FileWatcher {
+    pub fn new<E>(handler: E, files: Files) -> anyhow::Result<Self>
+    where
+        E: EventHandler,
+    {
+        Self::from_handler(Box::new(handler), files)
+    }
+
+    fn from_handler(handler: Box<dyn EventHandler>, files: Files) -> anyhow::Result<Self> {
+        let watcher = recommended_watcher(move |changes: notify::Result<Event>| {
+            match changes {
+                Ok(event) => {
+                    // TODO verify that this handles all events correctly
+                    let change_kind = match event.kind {
+                        EventKind::Create(CreateKind::File) => FileChangeKind::Created,
+                        EventKind::Modify(_) => FileChangeKind::Modified,
+                        EventKind::Remove(RemoveKind::File) => FileChangeKind::Deleted,
+                        _ => {
+                            return;
+                        }
+                    };
+
+                    let mut changes = Vec::new();
+
+                    for path in event.paths {
+                        if path.is_file() {
+                            let id = files.intern(&path);
+                            changes.push(FileChange::new(id, change_kind));
+                        }
+                    }
+
+                    if !changes.is_empty() {
+                        handler.handle(changes);
+                    }
+                }
+                // TODO proper error handling
+                Err(err) => {
+                    panic!("Error: {err}");
+                }
+            }
+        })
+        .context("Failed to create file watcher.")?;
+
+        Ok(Self { watcher })
+    }
+
+    pub fn watch_folder(&mut self, path: &Path) -> anyhow::Result<()> {
+        self.watcher.watch(path, RecursiveMode::Recursive)?;
+
+        Ok(())
+    }
+}

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.1.15"
+version = "0.4.2"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -20,6 +20,7 @@ ruff_macros = { path = "../ruff_macros" }
 ruff_notebook = { path = "../ruff_notebook" }
 ruff_python_ast = { path = "../ruff_python_ast" }
 ruff_python_formatter = { path = "../ruff_python_formatter" }
+ruff_server = { path = "../ruff_server" }
 ruff_source_file = { path = "../ruff_source_file" }
 ruff_text_size = { path = "../ruff_text_size" }
 ruff_workspace = { path = "../ruff_workspace" }
@@ -40,6 +41,7 @@ is-macro = { workspace = true }
 itertools = { workspace = true }
 log = { workspace = true }
 notify = { workspace = true }
+num_cpus = { workspace = true }
 path-absolutize = { workspace = true, features = ["once_cell_cache"] }
 rayon = { workspace = true }
 regex = { workspace = true }
@@ -48,17 +50,20 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 shellexpand = { workspace = true }
 strum = { workspace = true, features = [] }
+tempfile = { workspace = true }
 thiserror = { workspace = true }
+toml = { workspace = true }
 tracing = { workspace = true, features = ["log"] }
+tracing-subscriber = { workspace = true, features = ["registry"] }
+tracing-tree = { workspace = true }
 walkdir = { workspace = true }
 wild = { workspace = true }
 
 [dev-dependencies]
 # Enable test rules during development
 ruff_linter = { path = "../ruff_linter", features = ["clap", "test-rules"] }
-assert_cmd = { workspace = true }
 # Avoid writing colored snapshots when running tests from the terminal
-colored = { workspace = true, features = ["no-color"]}
+colored = { workspace = true, features = ["no-color"] }
 insta = { workspace = true, features = ["filters", "json"] }
 insta-cmd = { workspace = true }
 tempfile = { workspace = true }

crates/ruff/src/args.rs

@@ -1,8 +1,18 @@
-use std::path::PathBuf;
+use std::cmp::Ordering;
+use std::fmt::Formatter;
+use std::ops::Deref;
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
+use std::sync::Arc;
 
+use anyhow::bail;
+use clap::builder::{TypedValueParser, ValueParserFactory};
 use clap::{command, Parser};
+use colored::Colorize;
+use path_absolutize::path_dedot;
 use regex::Regex;
 use rustc_hash::FxHashMap;
+use toml;
 
 use ruff_linter::line_width::LineLength;
 use ruff_linter::logging::LogLevel;
@@ -11,11 +21,59 @@ use ruff_linter::settings::types::{
     ExtensionPair, FilePattern, PatternPrefixPair, PerFileIgnore, PreviewMode, PythonVersion,
     SerializationFormat, UnsafeFixes,
 };
-use ruff_linter::{RuleParser, RuleSelector, RuleSelectorParser};
+use ruff_linter::{warn_user, RuleParser, RuleSelector, RuleSelectorParser};
+use ruff_source_file::{LineIndex, OneIndexed};
+use ruff_text_size::TextRange;
 use ruff_workspace::configuration::{Configuration, RuleSelection};
-use ruff_workspace::options::PycodestyleOptions;
+use ruff_workspace::options::{Options, PycodestyleOptions};
 use ruff_workspace::resolver::ConfigurationTransformer;
 
+/// All configuration options that can be passed "globally",
+/// i.e., can be passed to all subcommands
+#[derive(Debug, Default, Clone, clap::Args)]
+pub struct GlobalConfigArgs {
+    #[clap(flatten)]
+    log_level_args: LogLevelArgs,
+    /// Either a path to a TOML configuration file (`pyproject.toml` or `ruff.toml`),
+    /// or a TOML `<KEY> = <VALUE>` pair
+    /// (such as you might find in a `ruff.toml` configuration file)
+    /// overriding a specific configuration option.
+    /// Overrides of individual settings using this option always take precedence
+    /// over all configuration files, including configuration files that were also
+    /// specified using `--config`.
+    #[arg(
+        long,
+        action = clap::ArgAction::Append,
+        value_name = "CONFIG_OPTION",
+        value_parser = ConfigArgumentParser,
+        global = true,
+        help_heading = "Global options",
+    )]
+    pub config: Vec<SingleConfigArgument>,
+    /// Ignore all configuration files.
+    //
+    // Note: We can't mark this as conflicting with `--config` here
+    // as `--config` can be used for specifying configuration overrides
+    // as well as configuration files.
+    // Specifying a configuration file conflicts with `--isolated`;
+    // specifying a configuration override does not.
+    // If a user specifies `ruff check --isolated --config=ruff.toml`,
+    // we emit an error later on, after the initial parsing by clap.
+    #[arg(long, help_heading = "Global options", global = true)]
+    pub isolated: bool,
+}
+
+impl GlobalConfigArgs {
+    pub fn log_level(&self) -> LogLevel {
+        LogLevel::from(&self.log_level_args)
+    }
+
+    #[must_use]
+    fn partition(self) -> (LogLevel, Vec<SingleConfigArgument>, bool) {
+        (self.log_level(), self.config, self.isolated)
+    }
+}
+
 #[derive(Debug, Parser)]
 #[command(
     author,
@@ -26,9 +84,9 @@ use ruff_workspace::resolver::ConfigurationTransformer;
 #[command(version)]
 pub struct Args {
     #[command(subcommand)]
-    pub command: Command,
+    pub(crate) command: Command,
     #[clap(flatten)]
-    pub log_level_args: LogLevelArgs,
+    pub(crate) global_options: GlobalConfigArgs,
 }
 
 #[allow(clippy::large_enum_variant)]
@@ -51,10 +109,6 @@ pub enum Command {
         /// Output format
         #[arg(long, value_enum, default_value = "text")]
         output_format: HelpFormat,
-
-        /// Output format (Deprecated: Use `--output-format` instead).
-        #[arg(long, value_enum, conflicts_with = "output_format", hide = true)]
-        format: Option<HelpFormat>,
     },
     /// List or describe the available configuration options.
     Config { option: Option<String> },
@@ -63,10 +117,6 @@ pub enum Command {
         /// Output format
         #[arg(long, value_enum, default_value = "text")]
         output_format: HelpFormat,
-
-        /// Output format (Deprecated: Use `--output-format` instead).
-        #[arg(long, value_enum, conflicts_with = "output_format", hide = true)]
-        format: Option<HelpFormat>,
     },
     /// Clear any caches in the current directory and any subdirectories.
     #[clap(alias = "--clean")]
@@ -76,6 +126,8 @@ pub enum Command {
     GenerateShellCompletion { shell: clap_complete_command::Shell },
     /// Run the Ruff formatter on the given files or directories.
     Format(FormatCommand),
+    /// Run the language server.
+    Server(ServerCommand),
     /// Display Ruff's version
     Version {
         #[arg(long, value_enum, default_value = "text")]
@@ -104,6 +156,7 @@ pub struct CheckCommand {
     no_unsafe_fixes: bool,
     /// Show violations with source code.
     /// Use `--no-show-source` to disable.
+    /// (Deprecated: use `--output-format=full` or `--output-format=concise` instead of `--show-source` and `--no-show-source`, respectively)
     #[arg(long, overrides_with("no_show_source"))]
     show_source: bool,
     #[clap(long, overrides_with("show_source"), hide = true)]
@@ -131,11 +184,13 @@ pub struct CheckCommand {
     ignore_noqa: bool,
 
     /// Output serialization format for violations.
+    /// The default serialization format is "concise".
+    /// In preview mode, the default serialization format is "full".
     #[arg(long, value_enum, env = "RUFF_OUTPUT_FORMAT")]
     pub output_format: Option<SerializationFormat>,
 
     /// Specify file to write the linter output to (default: stdout).
-    #[arg(short, long)]
+    #[arg(short, long, env = "RUFF_OUTPUT_FILE")]
     pub output_file: Option<PathBuf>,
     /// The minimum Python version that should be supported.
     #[arg(long, value_enum)]
@@ -146,10 +201,6 @@ pub struct CheckCommand {
     preview: bool,
     #[clap(long, overrides_with("preview"), hide = true)]
     no_preview: bool,
-    /// Path to the `pyproject.toml` or `ruff.toml` file to use for
-    /// configuration.
-    #[arg(long, conflicts_with = "isolated")]
-    pub config: Option<PathBuf>,
     /// Comma-separated list of rule codes to enable (or ALL, to enable all rules).
     #[arg(
         long,
@@ -281,9 +332,6 @@ pub struct CheckCommand {
     /// Disable cache reads.
     #[arg(short, long, env = "RUFF_NO_CACHE", help_heading = "Miscellaneous")]
     pub no_cache: bool,
-    /// Ignore all configuration files.
-    #[arg(long, conflicts_with = "config", help_heading = "Miscellaneous")]
-    pub isolated: bool,
     /// Path to the cache directory.
     #[arg(long, env = "RUFF_CACHE_DIR", help_heading = "Miscellaneous")]
     pub cache_dir: Option<PathBuf>,
@@ -375,9 +423,6 @@ pub struct FormatCommand {
     /// difference between the current file and how the formatted file would look like.
     #[arg(long)]
     pub diff: bool,
-    /// Path to the `pyproject.toml` or `ruff.toml` file to use for configuration.
-    #[arg(long, conflicts_with = "isolated")]
-    pub config: Option<PathBuf>,
 
     /// Disable cache reads.
     #[arg(short, long, env = "RUFF_NO_CACHE", help_heading = "Miscellaneous")]
@@ -418,9 +463,6 @@ pub struct FormatCommand {
     /// Set the line-length.
     #[arg(long, help_heading = "Format configuration")]
     pub line_length: Option<LineLength>,
-    /// Ignore all configuration files.
-    #[arg(long, conflicts_with = "config", help_heading = "Miscellaneous")]
-    pub isolated: bool,
     /// The name of the file when passing it through stdin.
     #[arg(long, help_heading = "Miscellaneous")]
     pub stdin_filename: Option<PathBuf>,
@@ -437,6 +479,28 @@ pub struct FormatCommand {
     preview: bool,
     #[clap(long, overrides_with("preview"), hide = true)]
     no_preview: bool,
+
+    /// When specified, Ruff will try to only format the code in the given range.
+    /// It might be necessary to extend the start backwards or the end forwards, to fully enclose a logical line.
+    /// The `<RANGE>` uses the format `<start_line>:<start_column>-<end_line>:<end_column>`.
+    ///
+    /// - The line and column numbers are 1 based.
+    /// - The column specifies the nth-unicode codepoint on that line.
+    /// - The end offset is exclusive.
+    /// - The column numbers are optional. You can write `--range=1-2` instead of `--range=1:1-2:1`.
+    /// - The end position is optional. You can write `--range=2` to format the entire document starting from the second line.
+    /// - The start position is optional. You can write `--range=-3` to format the first three lines of the document.
+    ///
+    /// The option can only be used when formatting a single file. Range formatting of notebooks is unsupported.
+    #[clap(long, help_heading = "Editor options", verbatim_doc_comment)]
+    pub range: Option<FormatRange>,
+}
+
+#[derive(Copy, Clone, Debug, clap::Parser)]
+pub struct ServerCommand {
+    /// Enable preview mode; required for regular operation
+    #[arg(long)]
+    pub(crate) preview: bool,
 }
 
 #[derive(Debug, Clone, Copy, clap::ValueEnum)]
@@ -446,7 +510,7 @@ pub enum HelpFormat {
 }
 
 #[allow(clippy::module_name_repetitions)]
-#[derive(Debug, clap::Args)]
+#[derive(Debug, Default, Clone, clap::Args)]
 pub struct LogLevelArgs {
     /// Enable verbose logging.
     #[arg(
@@ -491,97 +555,191 @@ impl From<&LogLevelArgs> for LogLevel {
     }
 }
 
+/// Configuration-related arguments passed via the CLI.
+#[derive(Default)]
+pub struct ConfigArguments {
+    /// Whether the user specified --isolated on the command line
+    pub(crate) isolated: bool,
+    /// The logging level to be used, derived from command-line arguments passed
+    pub(crate) log_level: LogLevel,
+    /// Path to a pyproject.toml or ruff.toml configuration file (etc.).
+    /// Either 0 or 1 configuration file paths may be provided on the command line.
+    config_file: Option<PathBuf>,
+    /// Overrides provided via the `--config "KEY=VALUE"` option.
+    /// An arbitrary number of these overrides may be provided on the command line.
+    /// These overrides take precedence over all configuration files,
+    /// even configuration files that were also specified using `--config`.
+    overrides: Configuration,
+    /// Overrides provided via dedicated flags such as `--line-length` etc.
+    /// These overrides take precedence over all configuration files,
+    /// and also over all overrides specified using any `--config "KEY=VALUE"` flags.
+    per_flag_overrides: ExplicitConfigOverrides,
+}
+
+impl ConfigArguments {
+    pub fn config_file(&self) -> Option<&Path> {
+        self.config_file.as_deref()
+    }
+
+    fn from_cli_arguments(
+        global_options: GlobalConfigArgs,
+        per_flag_overrides: ExplicitConfigOverrides,
+    ) -> anyhow::Result<Self> {
+        let (log_level, config_options, isolated) = global_options.partition();
+        let mut config_file: Option<PathBuf> = None;
+        let mut overrides = Configuration::default();
+
+        for option in config_options {
+            match option {
+                SingleConfigArgument::SettingsOverride(overridden_option) => {
+                    let overridden_option = Arc::try_unwrap(overridden_option)
+                        .unwrap_or_else(|option| option.deref().clone());
+                    overrides = overrides.combine(Configuration::from_options(
+                        overridden_option,
+                        None,
+                        &path_dedot::CWD,
+                    )?);
+                }
+                SingleConfigArgument::FilePath(path) => {
+                    if isolated {
+                        bail!(
+                            "\
+The argument `--config={}` cannot be used with `--isolated`
+
+  tip: You cannot specify a configuration file and also specify `--isolated`,
+       as `--isolated` causes ruff to ignore all configuration files.
+       For more information, try `--help`.
+",
+                            path.display()
+                        );
+                    }
+                    if let Some(ref config_file) = config_file {
+                        let (first, second) = (config_file.display(), path.display());
+                        bail!(
+                            "\
+You cannot specify more than one configuration file on the command line.
+
+  tip: remove either `--config={first}` or `--config={second}`.
+       For more information, try `--help`.
+"
+                        );
+                    }
+                    config_file = Some(path);
+                }
+            }
+        }
+        Ok(Self {
+            isolated,
+            log_level,
+            config_file,
+            overrides,
+            per_flag_overrides,
+        })
+    }
+}
+
+impl ConfigurationTransformer for ConfigArguments {
+    fn transform(&self, config: Configuration) -> Configuration {
+        let with_config_overrides = self.overrides.clone().combine(config);
+        self.per_flag_overrides.transform(with_config_overrides)
+    }
+}
+
 impl CheckCommand {
     /// Partition the CLI into command-line arguments and configuration
     /// overrides.
-    pub fn partition(self) -> (CheckArguments, CliOverrides) {
-        (
-            CheckArguments {
-                add_noqa: self.add_noqa,
-                config: self.config,
-                diff: self.diff,
-                ecosystem_ci: self.ecosystem_ci,
-                exit_non_zero_on_fix: self.exit_non_zero_on_fix,
-                exit_zero: self.exit_zero,
-                files: self.files,
-                ignore_noqa: self.ignore_noqa,
-                isolated: self.isolated,
-                no_cache: self.no_cache,
-                output_file: self.output_file,
-                show_files: self.show_files,
-                show_settings: self.show_settings,
-                statistics: self.statistics,
-                stdin_filename: self.stdin_filename,
-                watch: self.watch,
-            },
-            CliOverrides {
-                dummy_variable_rgx: self.dummy_variable_rgx,
-                exclude: self.exclude,
-                extend_exclude: self.extend_exclude,
-                extend_fixable: self.extend_fixable,
-                extend_ignore: self.extend_ignore,
-                extend_per_file_ignores: self.extend_per_file_ignores,
-                extend_select: self.extend_select,
-                extend_unfixable: self.extend_unfixable,
-                fixable: self.fixable,
-                ignore: self.ignore,
-                line_length: self.line_length,
-                per_file_ignores: self.per_file_ignores,
-                preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
-                respect_gitignore: resolve_bool_arg(
-                    self.respect_gitignore,
-                    self.no_respect_gitignore,
-                ),
-                select: self.select,
-                show_source: resolve_bool_arg(self.show_source, self.no_show_source),
-                target_version: self.target_version,
-                unfixable: self.unfixable,
-                // TODO(charlie): Included in `pyproject.toml`, but not inherited.
-                cache_dir: self.cache_dir,
-                fix: resolve_bool_arg(self.fix, self.no_fix),
-                fix_only: resolve_bool_arg(self.fix_only, self.no_fix_only),
-                unsafe_fixes: resolve_bool_arg(self.unsafe_fixes, self.no_unsafe_fixes)
-                    .map(UnsafeFixes::from),
-                force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
-                output_format: self.output_format,
-                show_fixes: resolve_bool_arg(self.show_fixes, self.no_show_fixes),
-                extension: self.extension,
-            },
-        )
+    pub fn partition(
+        self,
+        global_options: GlobalConfigArgs,
+    ) -> anyhow::Result<(CheckArguments, ConfigArguments)> {
+        let check_arguments = CheckArguments {
+            add_noqa: self.add_noqa,
+            diff: self.diff,
+            ecosystem_ci: self.ecosystem_ci,
+            exit_non_zero_on_fix: self.exit_non_zero_on_fix,
+            exit_zero: self.exit_zero,
+            files: self.files,
+            ignore_noqa: self.ignore_noqa,
+            no_cache: self.no_cache,
+            output_file: self.output_file,
+            show_files: self.show_files,
+            show_settings: self.show_settings,
+            statistics: self.statistics,
+            stdin_filename: self.stdin_filename,
+            watch: self.watch,
+        };
+
+        let cli_overrides = ExplicitConfigOverrides {
+            dummy_variable_rgx: self.dummy_variable_rgx,
+            exclude: self.exclude,
+            extend_exclude: self.extend_exclude,
+            extend_fixable: self.extend_fixable,
+            extend_ignore: self.extend_ignore,
+            extend_per_file_ignores: self.extend_per_file_ignores,
+            extend_select: self.extend_select,
+            extend_unfixable: self.extend_unfixable,
+            fixable: self.fixable,
+            ignore: self.ignore,
+            line_length: self.line_length,
+            per_file_ignores: self.per_file_ignores,
+            preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
+            respect_gitignore: resolve_bool_arg(self.respect_gitignore, self.no_respect_gitignore),
+            select: self.select,
+            target_version: self.target_version,
+            unfixable: self.unfixable,
+            // TODO(charlie): Included in `pyproject.toml`, but not inherited.
+            cache_dir: self.cache_dir,
+            fix: resolve_bool_arg(self.fix, self.no_fix),
+            fix_only: resolve_bool_arg(self.fix_only, self.no_fix_only),
+            unsafe_fixes: resolve_bool_arg(self.unsafe_fixes, self.no_unsafe_fixes)
+                .map(UnsafeFixes::from),
+            force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
+            output_format: resolve_output_format(
+                self.output_format,
+                resolve_bool_arg(self.show_source, self.no_show_source),
+                resolve_bool_arg(self.preview, self.no_preview).unwrap_or_default(),
+            ),
+            show_fixes: resolve_bool_arg(self.show_fixes, self.no_show_fixes),
+            extension: self.extension,
+        };
+
+        let config_args = ConfigArguments::from_cli_arguments(global_options, cli_overrides)?;
+        Ok((check_arguments, config_args))
     }
 }
 
 impl FormatCommand {
     /// Partition the CLI into command-line arguments and configuration
     /// overrides.
-    pub fn partition(self) -> (FormatArguments, CliOverrides) {
-        (
-            FormatArguments {
-                check: self.check,
-                diff: self.diff,
-                config: self.config,
-                files: self.files,
-                isolated: self.isolated,
-                no_cache: self.no_cache,
-                stdin_filename: self.stdin_filename,
-            },
-            CliOverrides {
-                line_length: self.line_length,
-                respect_gitignore: resolve_bool_arg(
-                    self.respect_gitignore,
-                    self.no_respect_gitignore,
-                ),
-                exclude: self.exclude,
-                preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
-                force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
-                target_version: self.target_version,
-                cache_dir: self.cache_dir,
-                extension: self.extension,
+    pub fn partition(
+        self,
+        global_options: GlobalConfigArgs,
+    ) -> anyhow::Result<(FormatArguments, ConfigArguments)> {
+        let format_arguments = FormatArguments {
+            check: self.check,
+            diff: self.diff,
+            files: self.files,
+            no_cache: self.no_cache,
+            stdin_filename: self.stdin_filename,
+            range: self.range,
+        };
 
-                // Unsupported on the formatter CLI, but required on `Overrides`.
-                ..CliOverrides::default()
-            },
-        )
+        let cli_overrides = ExplicitConfigOverrides {
+            line_length: self.line_length,
+            respect_gitignore: resolve_bool_arg(self.respect_gitignore, self.no_respect_gitignore),
+            exclude: self.exclude,
+            preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
+            force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
+            target_version: self.target_version,
+            cache_dir: self.cache_dir,
+            extension: self.extension,
+
+            // Unsupported on the formatter CLI, but required on `Overrides`.
+            ..ExplicitConfigOverrides::default()
+        };
+
+        let config_args = ConfigArguments::from_cli_arguments(global_options, cli_overrides)?;
+        Ok((format_arguments, config_args))
     }
 }
 
@@ -594,19 +752,228 @@ fn resolve_bool_arg(yes: bool, no: bool) -> Option<bool> {
     }
 }
 
+/// Enumeration of various ways in which a --config CLI flag
+/// could be invalid
+#[derive(Debug)]
+enum InvalidConfigFlagReason {
+    InvalidToml(toml::de::Error),
+    /// It was valid TOML, but not a valid ruff config file.
+    /// E.g. the user tried to select a rule that doesn't exist,
+    /// or tried to enable a setting that doesn't exist
+    ValidTomlButInvalidRuffSchema(toml::de::Error),
+    /// It was a valid ruff config file, but the user tried to pass a
+    /// value for `extend` as part of the config override.
+    // `extend` is special, because it affects which config files we look at
+    /// in the first place. We currently only parse --config overrides *after*
+    /// we've combined them with all the arguments from the various config files
+    /// that we found, so trying to override `extend` as part of a --config
+    /// override is forbidden.
+    ExtendPassedViaConfigFlag,
+}
+
+impl InvalidConfigFlagReason {
+    const fn description(&self) -> &'static str {
+        match self {
+            Self::InvalidToml(_) => "The supplied argument is not valid TOML",
+            Self::ValidTomlButInvalidRuffSchema(_) => {
+                "Could not parse the supplied argument as a `ruff.toml` configuration option"
+            }
+            Self::ExtendPassedViaConfigFlag => "Cannot include `extend` in a --config flag value",
+        }
+    }
+}
+
+/// Enumeration to represent a single `--config` argument
+/// passed via the CLI.
+///
+/// Using the `--config` flag, users may pass 0 or 1 paths
+/// to configuration files and an arbitrary number of
+/// "inline TOML" overrides for specific settings.
+///
+/// For example:
+///
+/// ```sh
+/// ruff check --config "path/to/ruff.toml" --config "extend-select=['E501', 'F841']" --config "lint.per-file-ignores = {'some_file.py' = ['F841']}"
+/// ```
+#[derive(Clone, Debug)]
+pub enum SingleConfigArgument {
+    FilePath(PathBuf),
+    SettingsOverride(Arc<Options>),
+}
+
+#[derive(Clone)]
+pub struct ConfigArgumentParser;
+
+impl ValueParserFactory for SingleConfigArgument {
+    type Parser = ConfigArgumentParser;
+
+    fn value_parser() -> Self::Parser {
+        ConfigArgumentParser
+    }
+}
+
+impl TypedValueParser for ConfigArgumentParser {
+    type Value = SingleConfigArgument;
+
+    fn parse_ref(
+        &self,
+        cmd: &clap::Command,
+        arg: Option<&clap::Arg>,
+        value: &std::ffi::OsStr,
+    ) -> Result<Self::Value, clap::Error> {
+        // Convert to UTF-8.
+        let Some(value) = value.to_str() else {
+            // But respect non-UTF-8 paths.
+            let path_to_config_file = PathBuf::from(value);
+            if path_to_config_file.is_file() {
+                return Ok(SingleConfigArgument::FilePath(path_to_config_file));
+            }
+            return Err(clap::Error::new(clap::error::ErrorKind::InvalidUtf8));
+        };
+
+        // Expand environment variables and tildes.
+        if let Ok(path_to_config_file) =
+            shellexpand::full(value).map(|config| PathBuf::from(&*config))
+        {
+            if path_to_config_file.is_file() {
+                return Ok(SingleConfigArgument::FilePath(path_to_config_file));
+            }
+        }
+
+        let config_parse_error = match toml::Table::from_str(value) {
+            Ok(table) => match table.try_into::<Options>() {
+                Ok(option) => {
+                    if option.extend.is_none() {
+                        return Ok(SingleConfigArgument::SettingsOverride(Arc::new(option)));
+                    }
+                    InvalidConfigFlagReason::ExtendPassedViaConfigFlag
+                }
+                Err(underlying_error) => {
+                    InvalidConfigFlagReason::ValidTomlButInvalidRuffSchema(underlying_error)
+                }
+            },
+            Err(underlying_error) => InvalidConfigFlagReason::InvalidToml(underlying_error),
+        };
+
+        let mut new_error = clap::Error::new(clap::error::ErrorKind::ValueValidation).with_cmd(cmd);
+        if let Some(arg) = arg {
+            new_error.insert(
+                clap::error::ContextKind::InvalidArg,
+                clap::error::ContextValue::String(arg.to_string()),
+            );
+        }
+        new_error.insert(
+            clap::error::ContextKind::InvalidValue,
+            clap::error::ContextValue::String(value.to_string()),
+        );
+
+        let underlying_error = match &config_parse_error {
+            InvalidConfigFlagReason::ExtendPassedViaConfigFlag => {
+                let tip = config_parse_error.description().into();
+                new_error.insert(
+                    clap::error::ContextKind::Suggested,
+                    clap::error::ContextValue::StyledStrs(vec![tip]),
+                );
+                return Err(new_error);
+            }
+            InvalidConfigFlagReason::InvalidToml(underlying_error)
+            | InvalidConfigFlagReason::ValidTomlButInvalidRuffSchema(underlying_error) => {
+                underlying_error
+            }
+        };
+
+        // small hack so that multiline tips
+        // have the same indent on the left-hand side:
+        let tip_indent = " ".repeat("  tip: ".len());
+
+        let mut tip = format!(
+            "\
+A `--config` flag must either be a path to a `.toml` configuration file
+{tip_indent}or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+{tip_indent}option"
+        );
+
+        // Here we do some heuristics to try to figure out whether
+        // the user was trying to pass in a path to a configuration file
+        // or some inline TOML.
+        // We want to display the most helpful error to the user as possible.
+        if std::path::Path::new(value)
+            .extension()
+            .map_or(false, |ext| ext.eq_ignore_ascii_case("toml"))
+        {
+            if !value.contains('=') {
+                tip.push_str(&format!(
+                    "
+
+It looks like you were trying to pass a path to a configuration file.
+The path `{value}` does not point to a configuration file"
+                ));
+            }
+        } else if value.contains('=') {
+            tip.push_str(&format!(
+                "\n\n{}:\n\n{underlying_error}",
+                config_parse_error.description()
+            ));
+        }
+        let tip = tip.trim_end().to_owned().into();
+
+        new_error.insert(
+            clap::error::ContextKind::Suggested,
+            clap::error::ContextValue::StyledStrs(vec![tip]),
+        );
+
+        Err(new_error)
+    }
+}
+
+fn resolve_output_format(
+    output_format: Option<SerializationFormat>,
+    show_sources: Option<bool>,
+    preview: bool,
+) -> Option<SerializationFormat> {
+    Some(match (output_format, show_sources) {
+        (Some(o), None) => o,
+        (Some(SerializationFormat::Grouped), Some(true)) => {
+            warn_user!("`--show-source` with `--output-format=grouped` is deprecated, and will not show source files. Use `--output-format=full` to show source information.");
+            SerializationFormat::Grouped
+        }
+        (Some(fmt), Some(true)) => {
+            warn_user!("The `--show-source` argument is deprecated and has been ignored in favor of `--output-format={fmt}`.");
+            fmt
+        }
+        (Some(fmt), Some(false)) => {
+            warn_user!("The `--no-show-source` argument is deprecated and has been ignored in favor of `--output-format={fmt}`.");
+            fmt
+        }
+        (None, Some(true)) => {
+            warn_user!("The `--show-source` argument is deprecated. Use `--output-format=full` instead.");
+            SerializationFormat::Full
+        }
+        (None, Some(false)) => {
+            warn_user!("The `--no-show-source` argument is deprecated. Use `--output-format=concise` instead.");
+            SerializationFormat::Concise
+        }
+        (None, None) => return None
+    }).map(|format| match format {
+        SerializationFormat::Text => {
+            warn_user!("`--output-format=text` is deprecated. Use `--output-format=full` or `--output-format=concise` instead. `text` will be treated as `{}`.", SerializationFormat::default(preview));
+            SerializationFormat::default(preview)
+        },
+        other => other
+    })
+}
+
 /// CLI settings that are distinct from configuration (commands, lists of files,
 /// etc.).
 #[allow(clippy::struct_excessive_bools)]
 pub struct CheckArguments {
     pub add_noqa: bool,
-    pub config: Option<PathBuf>,
     pub diff: bool,
     pub ecosystem_ci: bool,
     pub exit_non_zero_on_fix: bool,
     pub exit_zero: bool,
     pub files: Vec<PathBuf>,
     pub ignore_noqa: bool,
-    pub isolated: bool,
     pub no_cache: bool,
     pub output_file: Option<PathBuf>,
     pub show_files: bool,
@@ -623,46 +990,234 @@ pub struct FormatArguments {
     pub check: bool,
     pub no_cache: bool,
     pub diff: bool,
-    pub config: Option<PathBuf>,
     pub files: Vec<PathBuf>,
-    pub isolated: bool,
     pub stdin_filename: Option<PathBuf>,
+    pub range: Option<FormatRange>,
 }
 
-/// CLI settings that function as configuration overrides.
+/// A text range specified by line and column numbers.
+#[derive(Copy, Clone, Debug)]
+pub struct FormatRange {
+    start: LineColumn,
+    end: LineColumn,
+}
+
+impl FormatRange {
+    /// Converts the line:column range to a byte offset range specific for `source`.
+    ///
+    /// Returns an empty range if the start range is past the end of `source`.
+    pub(super) fn to_text_range(self, source: &str, line_index: &LineIndex) -> TextRange {
+        let start_byte_offset = line_index.offset(self.start.line, self.start.column, source);
+        let end_byte_offset = line_index.offset(self.end.line, self.end.column, source);
+
+        TextRange::new(start_byte_offset, end_byte_offset)
+    }
+}
+
+impl FromStr for FormatRange {
+    type Err = FormatRangeParseError;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        let (start, end) = value.split_once('-').unwrap_or((value, ""));
+
+        let start = if start.is_empty() {
+            LineColumn::default()
+        } else {
+            start.parse().map_err(FormatRangeParseError::InvalidStart)?
+        };
+
+        let end = if end.is_empty() {
+            LineColumn {
+                line: OneIndexed::MAX,
+                column: OneIndexed::MAX,
+            }
+        } else {
+            end.parse().map_err(FormatRangeParseError::InvalidEnd)?
+        };
+
+        if start > end {
+            return Err(FormatRangeParseError::StartGreaterThanEnd(start, end));
+        }
+
+        Ok(FormatRange { start, end })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum FormatRangeParseError {
+    InvalidStart(LineColumnParseError),
+    InvalidEnd(LineColumnParseError),
+
+    StartGreaterThanEnd(LineColumn, LineColumn),
+}
+
+impl std::fmt::Display for FormatRangeParseError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let tip = "  tip:".bold().green();
+        match self {
+            FormatRangeParseError::StartGreaterThanEnd(start, end) => {
+                write!(
+                    f,
+                    "the start position '{start_invalid}' is greater than the end position '{end_invalid}'.\n  {tip} Try switching start and end: '{end}-{start}'",
+                    start_invalid=start.to_string().bold().yellow(),
+                    end_invalid=end.to_string().bold().yellow(),
+                    start=start.to_string().green().bold(),
+                    end=end.to_string().green().bold()
+                )
+            }
+            FormatRangeParseError::InvalidStart(inner) => inner.write(f, true),
+            FormatRangeParseError::InvalidEnd(inner) => inner.write(f, false),
+        }
+    }
+}
+
+impl std::error::Error for FormatRangeParseError {}
+
+#[derive(Copy, Clone, Debug)]
+pub struct LineColumn {
+    pub line: OneIndexed,
+    pub column: OneIndexed,
+}
+
+impl std::fmt::Display for LineColumn {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{line}:{column}", line = self.line, column = self.column)
+    }
+}
+
+impl Default for LineColumn {
+    fn default() -> Self {
+        LineColumn {
+            line: OneIndexed::MIN,
+            column: OneIndexed::MIN,
+        }
+    }
+}
+
+impl PartialOrd for LineColumn {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for LineColumn {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.line
+            .cmp(&other.line)
+            .then(self.column.cmp(&other.column))
+    }
+}
+
+impl PartialEq for LineColumn {
+    fn eq(&self, other: &Self) -> bool {
+        self.cmp(other) == Ordering::Equal
+    }
+}
+
+impl Eq for LineColumn {}
+
+impl FromStr for LineColumn {
+    type Err = LineColumnParseError;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        let (line, column) = value.split_once(':').unwrap_or((value, "1"));
+
+        let line: usize = line.parse().map_err(LineColumnParseError::LineParseError)?;
+        let column: usize = column
+            .parse()
+            .map_err(LineColumnParseError::ColumnParseError)?;
+
+        match (OneIndexed::new(line), OneIndexed::new(column)) {
+            (Some(line), Some(column)) => Ok(LineColumn { line, column }),
+            (Some(line), None) => Err(LineColumnParseError::ZeroColumnIndex { line }),
+            (None, Some(column)) => Err(LineColumnParseError::ZeroLineIndex { column }),
+            (None, None) => Err(LineColumnParseError::ZeroLineAndColumnIndex),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum LineColumnParseError {
+    ZeroLineIndex { column: OneIndexed },
+    ZeroColumnIndex { line: OneIndexed },
+    ZeroLineAndColumnIndex,
+    LineParseError(std::num::ParseIntError),
+    ColumnParseError(std::num::ParseIntError),
+}
+
+impl LineColumnParseError {
+    fn write(&self, f: &mut std::fmt::Formatter, start_range: bool) -> std::fmt::Result {
+        let tip = "tip:".bold().green();
+
+        let range = if start_range { "start" } else { "end" };
+
+        match self {
+            LineColumnParseError::ColumnParseError(inner) => {
+                write!(f, "the {range}s column is not a valid number ({inner})'\n  {tip} The format is 'line:column'.")
+            }
+            LineColumnParseError::LineParseError(inner) => {
+                write!(f, "the {range} line is not a valid number ({inner})\n  {tip} The format is 'line:column'.")
+            }
+            LineColumnParseError::ZeroColumnIndex { line } => {
+                write!(
+                    f,
+                    "the {range} column is 0, but it should be 1 or greater.\n  {tip} The column numbers start at 1.\n  {tip} Try {suggestion} instead.",
+                    suggestion=format!("{line}:1").green().bold()
+                )
+            }
+            LineColumnParseError::ZeroLineIndex { column } => {
+                write!(
+                    f,
+                    "the {range} line is 0, but it should be 1 or greater.\n  {tip} The line numbers start at 1.\n  {tip} Try {suggestion} instead.",
+                    suggestion=format!("1:{column}").green().bold()
+                )
+            }
+            LineColumnParseError::ZeroLineAndColumnIndex => {
+                write!(
+                    f,
+                    "the {range} line and column are both 0, but they should be 1 or greater.\n  {tip} The line and column numbers start at 1.\n  {tip} Try {suggestion} instead.",
+                    suggestion="1:1".to_string().green().bold()
+                )
+            }
+        }
+    }
+}
+
+/// Configuration overrides provided via dedicated CLI flags:
+/// `--line-length`, `--respect-gitignore`, etc.
 #[derive(Clone, Default)]
 #[allow(clippy::struct_excessive_bools)]
-pub struct CliOverrides {
-    pub dummy_variable_rgx: Option<Regex>,
-    pub exclude: Option<Vec<FilePattern>>,
-    pub extend_exclude: Option<Vec<FilePattern>>,
-    pub extend_fixable: Option<Vec<RuleSelector>>,
-    pub extend_ignore: Option<Vec<RuleSelector>>,
-    pub extend_select: Option<Vec<RuleSelector>>,
-    pub extend_unfixable: Option<Vec<RuleSelector>>,
-    pub fixable: Option<Vec<RuleSelector>>,
-    pub ignore: Option<Vec<RuleSelector>>,
-    pub line_length: Option<LineLength>,
-    pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
-    pub extend_per_file_ignores: Option<Vec<PatternPrefixPair>>,
-    pub preview: Option<PreviewMode>,
-    pub respect_gitignore: Option<bool>,
-    pub select: Option<Vec<RuleSelector>>,
-    pub show_source: Option<bool>,
-    pub target_version: Option<PythonVersion>,
-    pub unfixable: Option<Vec<RuleSelector>>,
+struct ExplicitConfigOverrides {
+    dummy_variable_rgx: Option<Regex>,
+    exclude: Option<Vec<FilePattern>>,
+    extend_exclude: Option<Vec<FilePattern>>,
+    extend_fixable: Option<Vec<RuleSelector>>,
+    extend_ignore: Option<Vec<RuleSelector>>,
+    extend_select: Option<Vec<RuleSelector>>,
+    extend_unfixable: Option<Vec<RuleSelector>>,
+    fixable: Option<Vec<RuleSelector>>,
+    ignore: Option<Vec<RuleSelector>>,
+    line_length: Option<LineLength>,
+    per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    extend_per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    preview: Option<PreviewMode>,
+    respect_gitignore: Option<bool>,
+    select: Option<Vec<RuleSelector>>,
+    target_version: Option<PythonVersion>,
+    unfixable: Option<Vec<RuleSelector>>,
     // TODO(charlie): Captured in pyproject.toml as a default, but not part of `Settings`.
-    pub cache_dir: Option<PathBuf>,
-    pub fix: Option<bool>,
-    pub fix_only: Option<bool>,
-    pub unsafe_fixes: Option<UnsafeFixes>,
-    pub force_exclude: Option<bool>,
-    pub output_format: Option<SerializationFormat>,
-    pub show_fixes: Option<bool>,
-    pub extension: Option<Vec<ExtensionPair>>,
+    cache_dir: Option<PathBuf>,
+    fix: Option<bool>,
+    fix_only: Option<bool>,
+    unsafe_fixes: Option<UnsafeFixes>,
+    force_exclude: Option<bool>,
+    output_format: Option<SerializationFormat>,
+    show_fixes: Option<bool>,
+    extension: Option<Vec<ExtensionPair>>,
 }
 
-impl ConfigurationTransformer for CliOverrides {
+impl ConfigurationTransformer for ExplicitConfigOverrides {
     fn transform(&self, mut config: Configuration) -> Configuration {
         if let Some(cache_dir) = &self.cache_dir {
             config.cache_dir = Some(cache_dir.clone());
@@ -735,9 +1290,6 @@ impl ConfigurationTransformer for CliOverrides {
         if let Some(respect_gitignore) = &self.respect_gitignore {
             config.respect_gitignore = Some(*respect_gitignore);
         }
-        if let Some(show_source) = &self.show_source {
-            config.show_source = Some(*show_source);
-        }
         if let Some(show_fixes) = &self.show_fixes {
             config.show_fixes = Some(*show_fixes);
         }

crates/ruff/src/cache.rs

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

crates/ruff/src/commands/add_noqa.rs

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

crates/ruff/src/commands/check.rs

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

crates/ruff/src/commands/check_stdin.rs

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

crates/ruff/src/commands/format.rs

@@ -23,12 +23,13 @@ use ruff_linter::rules::flake8_quotes::settings::Quote;
 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, format_range, FormatModuleError, QuoteStyle};
+use ruff_source_file::LineIndex;
 use ruff_text_size::{TextLen, TextRange, TextSize};
 use ruff_workspace::resolver::{match_exclusion, python_files_in_path, ResolvedFile, Resolver};
 use ruff_workspace::FormatterSettings;
 
-use crate::args::{CliOverrides, FormatArguments};
+use crate::args::{ConfigArguments, FormatArguments, FormatRange};
 use crate::cache::{Cache, FileCacheKey, PackageCacheMap, PackageCaches};
 use crate::panic::{catch_unwind, PanicError};
 use crate::resolve::resolve;
@@ -59,24 +60,25 @@ impl FormatMode {
 /// Format a set of files, and return the exit status.
 pub(crate) fn format(
     cli: FormatArguments,
-    overrides: &CliOverrides,
-    log_level: LogLevel,
+    config_arguments: &ConfigArguments,
 ) -> Result<ExitStatus> {
-    let pyproject_config = resolve(
-        cli.isolated,
-        cli.config.as_deref(),
-        overrides,
-        cli.stdin_filename.as_deref(),
-    )?;
+    let pyproject_config = resolve(config_arguments, cli.stdin_filename.as_deref())?;
     let mode = FormatMode::from_cli(&cli);
     let files = resolve_default_files(cli.files, false);
-    let (paths, resolver) = python_files_in_path(&files, &pyproject_config, overrides)?;
+    let (paths, resolver) = python_files_in_path(&files, &pyproject_config, config_arguments)?;
 
     if paths.is_empty() {
         warn_user_once!("No Python files found under the given path(s)");
         return Ok(ExitStatus::Success);
     }
 
+    if cli.range.is_some() && paths.len() > 1 {
+        return Err(anyhow::anyhow!(
+            "The `--range` option is only supported when formatting a single file but the specified paths resolve to {} files.",
+            paths.len()
+        ));
+    }
+
     warn_incompatible_formatter_settings(&resolver);
 
     // Discover the package root for each Python file.
@@ -139,7 +141,14 @@ pub(crate) fn format(
 
                     Some(
                         match catch_unwind(|| {
-                            format_path(path, &settings.formatter, source_type, mode, cache)
+                            format_path(
+                                path,
+                                &settings.formatter,
+                                source_type,
+                                mode,
+                                cli.range,
+                                cache,
+                            )
                         }) {
                             Ok(inner) => inner.map(|result| FormatPathResult {
                                 path: resolved_file.path().to_path_buf(),
@@ -188,7 +197,7 @@ pub(crate) fn format(
     }
 
     // Report on the formatting changes.
-    if log_level >= LogLevel::Default {
+    if config_arguments.log_level >= LogLevel::Default {
         if mode.is_diff() {
             // Allow piping the diff to e.g. a file by writing the summary to stderr
             results.write_summary(&mut stderr().lock())?;
@@ -226,6 +235,7 @@ pub(crate) fn format_path(
     settings: &FormatterSettings,
     source_type: PySourceType,
     mode: FormatMode,
+    range: Option<FormatRange>,
     cache: Option<&Cache>,
 ) -> Result<FormatResult, FormatCommandError> {
     if let Some(cache) = cache {
@@ -250,8 +260,12 @@ pub(crate) fn format_path(
         }
     };
 
+    // Don't write back to the cache if formatting a range.
+    let cache = cache.filter(|_| range.is_none());
+
     // Format the source.
-    let format_result = match format_source(&unformatted, source_type, Some(path), settings)? {
+    let format_result = match format_source(&unformatted, source_type, Some(path), settings, range)?
+    {
         FormattedSource::Formatted(formatted) => match mode {
             FormatMode::Write => {
                 let mut writer = File::create(path).map_err(|err| {
@@ -319,12 +333,31 @@ pub(crate) fn format_source(
     source_type: PySourceType,
     path: Option<&Path>,
     settings: &FormatterSettings,
+    range: Option<FormatRange>,
 ) -> Result<FormattedSource, FormatCommandError> {
     match &source_kind {
         SourceKind::Python(unformatted) => {
             let options = settings.to_format_options(source_type, unformatted);
 
-            let formatted = format_module_source(unformatted, options).map_err(|err| {
+            let formatted = if let Some(range) = range {
+                let line_index = LineIndex::from_source_text(unformatted);
+                let byte_range = range.to_text_range(unformatted, &line_index);
+                format_range(unformatted, byte_range, options).map(|formatted_range| {
+                    let mut formatted = unformatted.to_string();
+                    formatted.replace_range(
+                        std::ops::Range::<usize>::from(formatted_range.source_range()),
+                        formatted_range.as_code(),
+                    );
+
+                    formatted
+                })
+            } else {
+                // Using `Printed::into_code` requires adding `ruff_formatter` as a direct dependency, and I suspect that Rust can optimize the closure away regardless.
+                #[allow(clippy::redundant_closure_for_method_calls)]
+                format_module_source(unformatted, options).map(|formatted| formatted.into_code())
+            };
+
+            let formatted = formatted.map_err(|err| {
                 if let FormatModuleError::ParseError(err) = err {
                     DisplayParseError::from_source_kind(
                         err,
@@ -337,7 +370,6 @@ pub(crate) fn format_source(
                 }
             })?;
 
-            let formatted = formatted.into_code();
             if formatted.len() == unformatted.len() && formatted == *unformatted {
                 Ok(FormattedSource::Unchanged)
             } else {
@@ -349,6 +381,12 @@ pub(crate) fn format_source(
                 return Ok(FormattedSource::Unchanged);
             }
 
+            if range.is_some() {
+                return Err(FormatCommandError::RangeFormatNotebook(
+                    path.map(Path::to_path_buf),
+                ));
+            }
+
             let options = settings.to_format_options(source_type, notebook.source_code());
 
             let mut output: Option<String> = None;
@@ -489,7 +527,7 @@ impl<'a> FormatResults<'a> {
             })
             .sorted_unstable_by_key(|(path, _, _)| *path)
         {
-            unformatted.diff(formatted, Some(path), f)?;
+            write!(f, "{}", unformatted.diff(formatted, Some(path)).unwrap())?;
         }
 
         Ok(())
@@ -589,6 +627,7 @@ pub(crate) enum FormatCommandError {
     Format(Option<PathBuf>, FormatModuleError),
     Write(Option<PathBuf>, SourceError),
     Diff(Option<PathBuf>, io::Error),
+    RangeFormatNotebook(Option<PathBuf>),
 }
 
 impl FormatCommandError {
@@ -606,7 +645,8 @@ impl FormatCommandError {
             | Self::Read(path, _)
             | Self::Format(path, _)
             | Self::Write(path, _)
-            | Self::Diff(path, _) => path.as_deref(),
+            | Self::Diff(path, _)
+            | Self::RangeFormatNotebook(path) => path.as_deref(),
         }
     }
 }
@@ -628,9 +668,10 @@ impl Display for FormatCommandError {
                 } else {
                     write!(
                         f,
-                        "{} {}",
-                        "Encountered error:".bold(),
-                        err.io_error()
+                        "{header} {error}",
+                        header = "Encountered error:".bold(),
+                        error = err
+                            .io_error()
                             .map_or_else(|| err.to_string(), std::string::ToString::to_string)
                     )
                 }
@@ -648,7 +689,7 @@ impl Display for FormatCommandError {
                         ":".bold()
                     )
                 } else {
-                    write!(f, "{}{} {err}", "Failed to read".bold(), ":".bold())
+                    write!(f, "{header} {err}", header = "Failed to read:".bold())
                 }
             }
             Self::Write(path, err) => {
@@ -661,7 +702,7 @@ impl Display for FormatCommandError {
                         ":".bold()
                     )
                 } else {
-                    write!(f, "{}{} {err}", "Failed to write".bold(), ":".bold())
+                    write!(f, "{header} {err}", header = "Failed to write:".bold())
                 }
             }
             Self::Format(path, err) => {
@@ -674,7 +715,7 @@ impl Display for FormatCommandError {
                         ":".bold()
                     )
                 } else {
-                    write!(f, "{}{} {err}", "Failed to format".bold(), ":".bold())
+                    write!(f, "{header} {err}", header = "Failed to format:".bold())
                 }
             }
             Self::Diff(path, err) => {
@@ -689,9 +730,25 @@ impl Display for FormatCommandError {
                 } else {
                     write!(
                         f,
-                        "{}{} {err}",
-                        "Failed to generate diff".bold(),
-                        ":".bold()
+                        "{header} {err}",
+                        header = "Failed to generate diff:".bold(),
+                    )
+                }
+            }
+            Self::RangeFormatNotebook(path) => {
+                if let Some(path) = path {
+                    write!(
+                        f,
+                        "{header}{path}{colon} Range formatting isn't supported for notebooks.",
+                        header = "Failed to format ".bold(),
+                        path = fs::relativize_path(path).bold(),
+                        colon = ":".bold()
+                    )
+                } else {
+                    write!(
+                        f,
+                        "{header} Range formatting isn't supported for notebooks",
+                        header = "Failed to format:".bold()
                     )
                 }
             }

crates/ruff/src/commands/format_stdin.rs

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

crates/ruff/src/commands/mod.rs

@@ -7,6 +7,7 @@ pub(crate) mod format;
 pub(crate) mod format_stdin;
 pub(crate) mod linter;
 pub(crate) mod rule;
+pub(crate) mod server;
 pub(crate) mod show_files;
 pub(crate) mod show_settings;
 pub(crate) mod version;

crates/ruff/src/commands/server.rs

@@ -0,0 +1,79 @@
+use std::num::NonZeroUsize;
+
+use crate::ExitStatus;
+use anyhow::Result;
+use ruff_linter::logging::LogLevel;
+use ruff_server::Server;
+use tracing::{level_filters::LevelFilter, metadata::Level, subscriber::Interest, Metadata};
+use tracing_subscriber::{
+    layer::{Context, Filter, SubscriberExt},
+    Layer, Registry,
+};
+use tracing_tree::time::Uptime;
+
+pub(crate) fn run_server(
+    preview: bool,
+    worker_threads: NonZeroUsize,
+    log_level: LogLevel,
+) -> Result<ExitStatus> {
+    if !preview {
+        tracing::error!("--preview needs to be provided as a command line argument while the server is still unstable.\nFor example: `ruff server --preview`");
+        return Ok(ExitStatus::Error);
+    }
+    let trace_level = if log_level == LogLevel::Verbose {
+        Level::TRACE
+    } else {
+        Level::DEBUG
+    };
+
+    let subscriber = Registry::default().with(
+        tracing_tree::HierarchicalLayer::default()
+            .with_indent_lines(true)
+            .with_indent_amount(2)
+            .with_bracketed_fields(true)
+            .with_targets(true)
+            .with_writer(|| Box::new(std::io::stderr()))
+            .with_timer(Uptime::default())
+            .with_filter(LoggingFilter { trace_level }),
+    );
+
+    tracing::subscriber::set_global_default(subscriber)?;
+
+    let server = Server::new(worker_threads)?;
+
+    server.run().map(|()| ExitStatus::Success)
+}
+
+struct LoggingFilter {
+    trace_level: Level,
+}
+
+impl LoggingFilter {
+    fn is_enabled(&self, meta: &Metadata<'_>) -> bool {
+        let filter = if meta.target().starts_with("ruff") {
+            self.trace_level
+        } else {
+            Level::INFO
+        };
+
+        meta.level() <= &filter
+    }
+}
+
+impl<S> Filter<S> for LoggingFilter {
+    fn enabled(&self, meta: &Metadata<'_>, _cx: &Context<'_, S>) -> bool {
+        self.is_enabled(meta)
+    }
+
+    fn callsite_enabled(&self, meta: &'static Metadata<'static>) -> Interest {
+        if self.is_enabled(meta) {
+            Interest::always()
+        } else {
+            Interest::never()
+        }
+    }
+
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        Some(LevelFilter::from_level(self.trace_level))
+    }
+}

crates/ruff/src/commands/show_files.rs

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

crates/ruff/src/commands/show_settings.rs

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

crates/ruff/src/diagnostics.rs

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

crates/ruff/src/lib.rs

@@ -2,11 +2,13 @@
 
 use std::fs::File;
 use std::io::{self, stdout, BufWriter, Write};
+use std::num::NonZeroUsize;
 use std::path::{Path, PathBuf};
 use std::process::ExitCode;
 use std::sync::mpsc::channel;
 
 use anyhow::Result;
+use args::{GlobalConfigArgs, ServerCommand};
 use clap::CommandFactory;
 use colored::Colorize;
 use log::warn;
@@ -18,7 +20,7 @@ use ruff_linter::settings::types::SerializationFormat;
 use ruff_linter::{fs, warn_user, warn_user_once};
 use ruff_workspace::Settings;
 
-use crate::args::{Args, CheckCommand, Command, FormatCommand, HelpFormat};
+use crate::args::{Args, CheckCommand, Command, FormatCommand};
 use crate::printer::{Flags as PrinterFlags, Printer};
 
 pub mod args;
@@ -114,20 +116,12 @@ fn resolve_default_files(files: Vec<PathBuf>, is_stdin: bool) -> Vec<PathBuf> {
     }
 }
 
-/// Get the actual value of the `format` desired from either `output_format`
-/// or `format`, and warn the user if they're using the deprecated form.
-fn resolve_help_output_format(output_format: HelpFormat, format: Option<HelpFormat>) -> HelpFormat {
-    if format.is_some() {
-        warn_user!("The `--format` argument is deprecated. Use `--output-format` instead.");
-    }
-    format.unwrap_or(output_format)
-}
-
 pub fn run(
     Args {
         command,
-        log_level_args,
+        global_options,
     }: Args,
+    deprecated_alias_warning: Option<&'static str>,
 ) -> Result<ExitStatus> {
     {
         let default_panic_hook = std::panic::take_hook();
@@ -155,8 +149,18 @@ pub fn run(
     #[cfg(windows)]
     assert!(colored::control::set_virtual_terminal(true).is_ok());
 
-    let log_level = LogLevel::from(&log_level_args);
-    set_up_logging(&log_level)?;
+    // support FORCE_COLOR env var
+    if let Some(force_color) = std::env::var_os("FORCE_COLOR") {
+        if force_color.len() > 0 {
+            colored::control::set_override(true);
+        }
+    }
+
+    set_up_logging(global_options.log_level())?;
+
+    if let Some(deprecated_alias_warning) = deprecated_alias_warning {
+        warn_user!("{}", deprecated_alias_warning);
+    }
 
     match command {
         Command::Version { output_format } => {
@@ -166,10 +170,8 @@ pub fn run(
         Command::Rule {
             rule,
             all,
-            format,
-            mut output_format,
+            output_format,
         } => {
-            output_format = resolve_help_output_format(output_format, format);
             if all {
                 commands::rule::rules(output_format)?;
             }
@@ -182,48 +184,51 @@ pub fn run(
             commands::config::config(option.as_deref())?;
             Ok(ExitStatus::Success)
         }
-        Command::Linter {
-            format,
-            mut output_format,
-        } => {
-            output_format = resolve_help_output_format(output_format, format);
+        Command::Linter { output_format } => {
             commands::linter::linter(output_format)?;
             Ok(ExitStatus::Success)
         }
         Command::Clean => {
-            commands::clean::clean(log_level)?;
+            commands::clean::clean(global_options.log_level())?;
             Ok(ExitStatus::Success)
         }
         Command::GenerateShellCompletion { shell } => {
             shell.generate(&mut Args::command(), &mut stdout());
             Ok(ExitStatus::Success)
         }
-        Command::Check(args) => check(args, log_level),
-        Command::Format(args) => format(args, log_level),
+        Command::Check(args) => check(args, global_options),
+        Command::Format(args) => format(args, global_options),
+        Command::Server(args) => server(args, global_options.log_level()),
     }
 }
 
-fn format(args: FormatCommand, log_level: LogLevel) -> Result<ExitStatus> {
-    let (cli, overrides) = args.partition();
+fn format(args: FormatCommand, global_options: GlobalConfigArgs) -> Result<ExitStatus> {
+    let (cli, config_arguments) = args.partition(global_options)?;
 
     if is_stdin(&cli.files, cli.stdin_filename.as_deref()) {
-        commands::format_stdin::format_stdin(&cli, &overrides)
+        commands::format_stdin::format_stdin(&cli, &config_arguments)
     } else {
-        commands::format::format(cli, &overrides, log_level)
+        commands::format::format(cli, &config_arguments)
     }
 }
 
-pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
-    let (cli, overrides) = args.partition();
+fn server(args: ServerCommand, log_level: LogLevel) -> Result<ExitStatus> {
+    let ServerCommand { preview } = args;
+    // by default, we set the number of worker threads to `num_cpus`, with a maximum of 4.
+    let worker_threads = num_cpus::get().max(4);
+    commands::server::run_server(
+        preview,
+        NonZeroUsize::try_from(worker_threads).expect("a non-zero worker thread count"),
+        log_level,
+    )
+}
+
+pub fn check(args: CheckCommand, global_options: GlobalConfigArgs) -> Result<ExitStatus> {
+    let (cli, config_arguments) = args.partition(global_options)?;
 
     // Construct the "default" settings. These are used when no `pyproject.toml`
     // files are present, or files are injected from outside of the hierarchy.
-    let pyproject_config = resolve::resolve(
-        cli.isolated,
-        cli.config.as_deref(),
-        &overrides,
-        cli.stdin_filename.as_deref(),
-    )?;
+    let pyproject_config = resolve::resolve(&config_arguments, cli.stdin_filename.as_deref())?;
 
     let mut writer: Box<dyn Write> = match cli.output_file {
         Some(path) if !cli.watch => {
@@ -239,11 +244,21 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
     let files = resolve_default_files(cli.files, is_stdin);
 
     if cli.show_settings {
-        commands::show_settings::show_settings(&files, &pyproject_config, &overrides, &mut writer)?;
+        commands::show_settings::show_settings(
+            &files,
+            &pyproject_config,
+            &config_arguments,
+            &mut writer,
+        )?;
         return Ok(ExitStatus::Success);
     }
     if cli.show_files {
-        commands::show_files::show_files(&files, &pyproject_config, &overrides, &mut writer)?;
+        commands::show_files::show_files(
+            &files,
+            &pyproject_config,
+            &config_arguments,
+            &mut writer,
+        )?;
         return Ok(ExitStatus::Success);
     }
 
@@ -255,7 +270,6 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
         unsafe_fixes,
         output_format,
         show_fixes,
-        show_source,
         ..
     } = pyproject_config.settings;
 
@@ -284,9 +298,6 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
     if show_fixes {
         printer_flags |= PrinterFlags::SHOW_FIX_SUMMARY;
     }
-    if show_source {
-        printer_flags |= PrinterFlags::SHOW_SOURCE;
-    }
     if cli.ecosystem_ci {
         warn_user!(
             "The formatting of fixes emitted by this option is a work-in-progress, subject to \
@@ -306,8 +317,9 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
         if !fix_mode.is_generate() {
             warn_user!("--fix is incompatible with --add-noqa.");
         }
-        let modifications = commands::add_noqa::add_noqa(&files, &pyproject_config, &overrides)?;
-        if modifications > 0 && log_level >= LogLevel::Default {
+        let modifications =
+            commands::add_noqa::add_noqa(&files, &pyproject_config, &config_arguments)?;
+        if modifications > 0 && config_arguments.log_level >= LogLevel::Default {
             let s = if modifications == 1 { "" } else { "s" };
             #[allow(clippy::print_stderr)]
             {
@@ -319,15 +331,24 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
 
     let printer = Printer::new(
         output_format,
-        log_level,
+        config_arguments.log_level,
         fix_mode,
         unsafe_fixes,
         printer_flags,
     );
 
+    // the settings should already be combined with the CLI overrides at this point
+    // TODO(jane): let's make this `PreviewMode`
+    // TODO: this should reference the global preview mode once https://github.com/astral-sh/ruff/issues/8232
+    //   is resolved.
+    let preview = pyproject_config.settings.linter.preview.is_enabled();
+
     if cli.watch {
-        if output_format != SerializationFormat::Text {
-            warn_user!("`--output-format text` is always used in watch mode.");
+        if output_format != SerializationFormat::default(preview) {
+            warn_user!(
+                "`--output-format {}` is always used in watch mode.",
+                SerializationFormat::default(preview)
+            );
         }
 
         // Configure the file watcher.
@@ -347,13 +368,13 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
         let messages = commands::check::check(
             &files,
             &pyproject_config,
-            &overrides,
+            &config_arguments,
             cache.into(),
             noqa.into(),
             fix_mode,
             unsafe_fixes,
         )?;
-        printer.write_continuously(&mut writer, &messages)?;
+        printer.write_continuously(&mut writer, &messages, preview)?;
 
         // In watch mode, we may need to re-resolve the configuration.
         // TODO(charlie): Re-compute other derivative values, like the `printer`.
@@ -367,12 +388,8 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
                     };
 
                     if matches!(change_kind, ChangeKind::Configuration) {
-                        pyproject_config = resolve::resolve(
-                            cli.isolated,
-                            cli.config.as_deref(),
-                            &overrides,
-                            cli.stdin_filename.as_deref(),
-                        )?;
+                        pyproject_config =
+                            resolve::resolve(&config_arguments, cli.stdin_filename.as_deref())?;
                     }
                     Printer::clear_screen()?;
                     printer.write_to_user("File change detected...\n");
@@ -380,13 +397,13 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
                     let messages = commands::check::check(
                         &files,
                         &pyproject_config,
-                        &overrides,
+                        &config_arguments,
                         cache.into(),
                         noqa.into(),
                         fix_mode,
                         unsafe_fixes,
                     )?;
-                    printer.write_continuously(&mut writer, &messages)?;
+                    printer.write_continuously(&mut writer, &messages, preview)?;
                 }
                 Err(err) => return Err(err.into()),
             }
@@ -397,7 +414,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
             commands::check_stdin::check_stdin(
                 cli.stdin_filename.map(fs::normalize_path).as_deref(),
                 &pyproject_config,
-                &overrides,
+                &config_arguments,
                 noqa.into(),
                 fix_mode,
             )?
@@ -405,7 +422,7 @@ pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
             commands::check::check(
                 &files,
                 &pyproject_config,
-                &overrides,
+                &config_arguments,
                 cache.into(),
                 noqa.into(),
                 fix_mode,

crates/ruff/src/main.rs

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

crates/ruff/src/panic.rs

@@ -16,7 +16,7 @@ impl std::fmt::Display for PanicError {
 }
 
 thread_local! {
-    static LAST_PANIC: std::cell::Cell<Option<PanicError>> = std::cell::Cell::new(None);
+    static LAST_PANIC: std::cell::Cell<Option<PanicError>> = const { std::cell::Cell::new(None) };
 }
 
 /// [`catch_unwind`](std::panic::catch_unwind) wrapper that sets a custom [`set_hook`](std::panic::set_hook)

crates/ruff/src/printer.rs

@@ -27,8 +27,6 @@ bitflags! {
     pub(crate) struct Flags: u8 {
         /// Whether to show violations when emitting diagnostics.
         const SHOW_VIOLATIONS = 0b0000_0001;
-        /// Whether to show the source code when emitting diagnostics.
-        const SHOW_SOURCE = 0b000_0010;
         /// Whether to show a summary of the fixed violations when emitting diagnostics.
         const SHOW_FIX_SUMMARY = 0b0000_0100;
         /// Whether to show a diff of each fixed violation when emitting diagnostics.
@@ -120,6 +118,8 @@ impl Printer {
                 } else if remaining > 0 {
                     let s = if remaining == 1 { "" } else { "s" };
                     writeln!(writer, "Found {remaining} error{s}.")?;
+                } else if remaining == 0 {
+                    writeln!(writer, "All checks passed!")?;
                 }
 
                 if let Some(fixables) = fixables {
@@ -218,7 +218,10 @@ impl Printer {
         if !self.flags.intersects(Flags::SHOW_VIOLATIONS) {
             if matches!(
                 self.format,
-                SerializationFormat::Text | SerializationFormat::Grouped
+                SerializationFormat::Text
+                    | SerializationFormat::Full
+                    | SerializationFormat::Concise
+                    | SerializationFormat::Grouped
             ) {
                 if self.flags.intersects(Flags::SHOW_FIX_SUMMARY) {
                     if !diagnostics.fixed.is_empty() {
@@ -245,11 +248,12 @@ impl Printer {
             SerializationFormat::Junit => {
                 JunitEmitter.emit(writer, &diagnostics.messages, &context)?;
             }
-            SerializationFormat::Text => {
+            SerializationFormat::Concise
+            | SerializationFormat::Full => {
                 TextEmitter::default()
                     .with_show_fix_status(show_fix_status(self.fix_mode, fixables.as_ref()))
                     .with_show_fix_diff(self.flags.intersects(Flags::SHOW_FIX_DIFF))
-                    .with_show_source(self.flags.intersects(Flags::SHOW_SOURCE))
+                    .with_show_source(self.format == SerializationFormat::Full)
                     .with_unsafe_fixes(self.unsafe_fixes)
                     .emit(writer, &diagnostics.messages, &context)?;
 
@@ -265,7 +269,6 @@ impl Printer {
             }
             SerializationFormat::Grouped => {
                 GroupedEmitter::default()
-                    .with_show_source(self.flags.intersects(Flags::SHOW_SOURCE))
                     .with_show_fix_status(show_fix_status(self.fix_mode, fixables.as_ref()))
                     .with_unsafe_fixes(self.unsafe_fixes)
                     .emit(writer, &diagnostics.messages, &context)?;
@@ -294,6 +297,7 @@ impl Printer {
             SerializationFormat::Sarif => {
                 SarifEmitter.emit(writer, &diagnostics.messages, &context)?;
             }
+            SerializationFormat::Text => unreachable!("Text is deprecated and should have been automatically converted to the default serialization format")
         }
 
         writer.flush()?;
@@ -342,7 +346,9 @@ impl Printer {
         }
 
         match self.format {
-            SerializationFormat::Text => {
+            SerializationFormat::Text
+            | SerializationFormat::Full
+            | SerializationFormat::Concise => {
                 // Compute the maximum number of digits in the count and code, for all messages,
                 // to enable pretty-printing.
                 let count_width = num_digits(
@@ -403,6 +409,7 @@ impl Printer {
         &self,
         writer: &mut dyn Write,
         diagnostics: &Diagnostics,
+        preview: bool,
     ) -> Result<()> {
         if matches!(self.log_level, LogLevel::Silent) {
             return Ok(());
@@ -430,7 +437,7 @@ impl Printer {
             let context = EmitterContext::new(&diagnostics.notebook_indexes);
             TextEmitter::default()
                 .with_show_fix_status(show_fix_status(self.fix_mode, fixables.as_ref()))
-                .with_show_source(self.flags.intersects(Flags::SHOW_SOURCE))
+                .with_show_source(preview)
                 .with_unsafe_fixes(self.unsafe_fixes)
                 .emit(writer, &diagnostics.messages, &context)?;
         }

crates/ruff/src/resolve.rs

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

crates/ruff/src/version.rs

@@ -70,7 +70,7 @@ pub(crate) fn version() -> VersionInfo {
 
 #[cfg(test)]
 mod tests {
-    use insta::{assert_display_snapshot, assert_json_snapshot};
+    use insta::{assert_json_snapshot, assert_snapshot};
 
     use super::{CommitInfo, VersionInfo};
 
@@ -80,7 +80,7 @@ mod tests {
             version: "0.0.0".to_string(),
             commit_info: None,
         };
-        assert_display_snapshot!(version);
+        assert_snapshot!(version);
     }
 
     #[test]
@@ -95,7 +95,7 @@ mod tests {
                 commits_since_last_tag: 0,
             }),
         };
-        assert_display_snapshot!(version);
+        assert_snapshot!(version);
     }
 
     #[test]
@@ -110,7 +110,7 @@ mod tests {
                 commits_since_last_tag: 24,
             }),
         };
-        assert_display_snapshot!(version);
+        assert_snapshot!(version);
     }
 
     #[test]

crates/ruff/tests/deprecation.rs

@@ -0,0 +1,150 @@
+//! A test suite that ensures deprecated command line options have appropriate warnings / behaviors
+
+use ruff_linter::settings::types::SerializationFormat;
+use std::process::Command;
+
+use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
+
+const BIN_NAME: &str = "ruff";
+
+const STDIN: &str = "l = 1";
+
+fn ruff_check(show_source: Option<bool>, output_format: Option<String>) -> Command {
+    let mut cmd = Command::new(get_cargo_bin(BIN_NAME));
+    let output_format = output_format.unwrap_or(format!("{}", SerializationFormat::default(false)));
+    cmd.arg("check")
+        .arg("--output-format")
+        .arg(output_format)
+        .arg("--no-cache");
+    match show_source {
+        Some(true) => {
+            cmd.arg("--show-source");
+        }
+        Some(false) => {
+            cmd.arg("--no-show-source");
+        }
+        None => {}
+    }
+    cmd.arg("-");
+
+    cmd
+}
+
+#[test]
+fn ensure_show_source_is_deprecated() {
+    assert_cmd_snapshot!(ruff_check(Some(true), None).pass_stdin(STDIN), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `l`
+    Found 1 error.
+
+    ----- stderr -----
+    warning: The `--show-source` argument is deprecated and has been ignored in favor of `--output-format=concise`.
+    "###);
+}
+
+#[test]
+fn ensure_no_show_source_is_deprecated() {
+    assert_cmd_snapshot!(ruff_check(Some(false), None).pass_stdin(STDIN), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `l`
+    Found 1 error.
+
+    ----- stderr -----
+    warning: The `--no-show-source` argument is deprecated and has been ignored in favor of `--output-format=concise`.
+    "###);
+}
+
+#[test]
+fn ensure_output_format_is_deprecated() {
+    assert_cmd_snapshot!(ruff_check(None, Some("text".into())).pass_stdin(STDIN), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `l`
+    Found 1 error.
+
+    ----- stderr -----
+    warning: `--output-format=text` is deprecated. Use `--output-format=full` or `--output-format=concise` instead. `text` will be treated as `concise`.
+    "###);
+}
+
+#[test]
+fn ensure_output_format_overrides_show_source() {
+    assert_cmd_snapshot!(ruff_check(Some(true), Some("concise".into())).pass_stdin(STDIN), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `l`
+    Found 1 error.
+
+    ----- stderr -----
+    warning: The `--show-source` argument is deprecated and has been ignored in favor of `--output-format=concise`.
+    "###);
+}
+
+#[test]
+fn ensure_full_output_format_overrides_no_show_source() {
+    assert_cmd_snapshot!(ruff_check(Some(false), Some("full".into())).pass_stdin(STDIN), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `l`
+      |
+    1 | l = 1
+      | ^ E741
+      |
+
+    Found 1 error.
+
+    ----- stderr -----
+    warning: The `--no-show-source` argument is deprecated and has been ignored in favor of `--output-format=full`.
+    "###);
+}
+
+#[test]
+fn ensure_output_format_uses_concise_over_no_show_source() {
+    assert_cmd_snapshot!(ruff_check(Some(false), Some("concise".into())).pass_stdin(STDIN), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `l`
+    Found 1 error.
+
+    ----- stderr -----
+    warning: The `--no-show-source` argument is deprecated and has been ignored in favor of `--output-format=concise`.
+    "###);
+}
+
+#[test]
+fn ensure_deprecated_output_format_overrides_show_source() {
+    assert_cmd_snapshot!(ruff_check(Some(true), Some("text".into())).pass_stdin(STDIN), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `l`
+    Found 1 error.
+
+    ----- stderr -----
+    warning: The `--show-source` argument is deprecated and has been ignored in favor of `--output-format=text`.
+    warning: `--output-format=text` is deprecated. Use `--output-format=full` or `--output-format=concise` instead. `text` will be treated as `concise`.
+    "###);
+}
+
+#[test]
+fn ensure_deprecated_output_format_overrides_no_show_source() {
+    assert_cmd_snapshot!(ruff_check(Some(false), Some("text".into())).pass_stdin(STDIN), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `l`
+    Found 1 error.
+
+    ----- stderr -----
+    warning: The `--no-show-source` argument is deprecated and has been ignored in favor of `--output-format=text`.
+    warning: `--output-format=text` is deprecated. Use `--output-format=full` or `--output-format=concise` instead. `text` will be treated as `concise`.
+    "###);
+}

crates/ruff/tests/format.rs

@@ -7,10 +7,15 @@ use std::str;
 
 use anyhow::Result;
 use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
+use regex::escape;
 use tempfile::TempDir;
 
 const BIN_NAME: &str = "ruff";
 
+fn tempdir_filter(tempdir: &TempDir) -> String {
+    format!(r"{}\\?/?", escape(tempdir.path().to_str().unwrap()))
+}
+
 #[test]
 fn default_options() {
     assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
@@ -18,7 +23,7 @@ fn default_options() {
         .arg("-")
         .pass_stdin(r#"
 def foo(arg1, arg2,):
-    print('Should\'t change quotes')
+    print('Shouldn\'t change quotes')
 
 
 if condition:
@@ -33,7 +38,7 @@ if condition:
         arg1,
         arg2,
     ):
-        print("Should't change quotes")
+        print("Shouldn't change quotes")
 
 
     if condition:
@@ -90,6 +95,182 @@ fn format_warn_stdin_filename_with_files() {
     "###);
 }
 
+#[test]
+fn nonexistent_config_file() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--config", "foo.toml", "."]), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'foo.toml' for '--config <CONFIG_OPTION>'
+
+      tip: A `--config` flag must either be a path to a `.toml` configuration file
+           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+           option
+
+    It looks like you were trying to pass a path to a configuration file.
+    The path `foo.toml` does not point to a configuration file
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn config_override_rejected_if_invalid_toml() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--config", "foo = bar", "."]), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'foo = bar' for '--config <CONFIG_OPTION>'
+
+      tip: A `--config` flag must either be a path to a `.toml` configuration file
+           or a TOML `<KEY> = <VALUE>` pair overriding a specific configuration
+           option
+
+    The supplied argument is not valid TOML:
+
+    TOML parse error at line 1, column 7
+      |
+    1 | foo = bar
+      |       ^
+    invalid string
+    expected `"`, `'`
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn too_many_config_files() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_dot_toml = tempdir.path().join("ruff.toml");
+    let ruff2_dot_toml = tempdir.path().join("ruff2.toml");
+    fs::File::create(&ruff_dot_toml)?;
+    fs::File::create(&ruff2_dot_toml)?;
+    insta::with_settings!({
+        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/")]
+    }, {
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .arg("format")
+        .arg("--config")
+        .arg(&ruff_dot_toml)
+        .arg("--config")
+        .arg(&ruff2_dot_toml)
+        .arg("."), @r###"
+            success: false
+            exit_code: 2
+            ----- stdout -----
+
+            ----- stderr -----
+            ruff failed
+              Cause: You cannot specify more than one configuration file on the command line.
+
+              tip: remove either `--config=[TMP]/ruff.toml` or `--config=[TMP]/ruff2.toml`.
+                   For more information, try `--help`.
+
+            "###);
+    });
+    Ok(())
+}
+
+#[test]
+fn config_file_and_isolated() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_dot_toml = tempdir.path().join("ruff.toml");
+    fs::File::create(&ruff_dot_toml)?;
+    insta::with_settings!({
+        filters => vec![(tempdir_filter(&tempdir).as_str(), "[TMP]/")]
+    }, {
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .arg("format")
+        .arg("--config")
+        .arg(&ruff_dot_toml)
+        .arg("--isolated")
+        .arg("."), @r###"
+        success: false
+        exit_code: 2
+        ----- stdout -----
+
+        ----- stderr -----
+        ruff failed
+          Cause: The argument `--config=[TMP]/ruff.toml` cannot be used with `--isolated`
+
+          tip: You cannot specify a configuration file and also specify `--isolated`,
+               as `--isolated` causes ruff to ignore all configuration files.
+               For more information, try `--help`.
+
+        "###);
+    });
+    Ok(())
+}
+
+#[test]
+fn config_override_via_cli() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(&ruff_toml, "line-length = 100")?;
+    let fixture = r#"
+def foo():
+    print("looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string")
+
+    "#;
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .arg("format")
+        .arg("--config")
+        .arg(&ruff_toml)
+        // This overrides the long line length set in the config file
+        .args(["--config", "line-length=80"])
+        .arg("-")
+        .pass_stdin(fixture), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    def foo():
+        print(
+            "looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string"
+        )
+
+    ----- stderr -----
+    "###);
+    Ok(())
+}
+
+#[test]
+fn config_doubly_overridden_via_cli() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let ruff_toml = tempdir.path().join("ruff.toml");
+    fs::write(&ruff_toml, "line-length = 70")?;
+    let fixture = r#"
+def foo():
+    print("looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string")
+
+    "#;
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .arg("format")
+        .arg("--config")
+        .arg(&ruff_toml)
+        // This overrides the long line length set in the config file...
+        .args(["--config", "line-length=80"])
+        // ...but this overrides them both:
+        .args(["--line-length", "100"])
+        .arg("-")
+        .pass_stdin(fixture), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    def foo():
+        print("looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong string")
+
+    ----- stderr -----
+    "###);
+    Ok(())
+}
+
 #[test]
 fn format_options() -> Result<()> {
     let tempdir = TempDir::new()?;
@@ -177,58 +358,52 @@ def f(x):
     '''
     pass
 "#), @r###"
-success: true
-exit_code: 0
------ stdout -----
-def f(x):
-    """
-    Something about `f`. And an example:
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    def f(x):
+        """
+        Something about `f`. And an example:
 
-    .. code-block:: python
+        .. code-block:: python
 
-        (
-            foo,
-            bar,
-            quux,
-        ) = this_is_a_long_line(
-            lion,
-            hippo,
-            lemur,
-            bear,
+            foo, bar, quux = (
+                this_is_a_long_line(
+                    lion,
+                    hippo,
+                    lemur,
+                    bear,
+                )
+            )
+
+        Another example:
+
+        ```py
+        foo, bar, quux = (
+            this_is_a_long_line(
+                lion,
+                hippo,
+                lemur,
+                bear,
+            )
         )
+        ```
 
-    Another example:
+        And another:
 
-    ```py
-    (
-        foo,
-        bar,
-        quux,
-    ) = this_is_a_long_line(
-        lion,
-        hippo,
-        lemur,
-        bear,
-    )
-    ```
+        >>> foo, bar, quux = (
+        ...     this_is_a_long_line(
+        ...         lion,
+        ...         hippo,
+        ...         lemur,
+        ...         bear,
+        ...     )
+        ... )
+        """
+        pass
 
-    And another:
-
-    >>> (
-    ...     foo,
-    ...     bar,
-    ...     quux,
-    ... ) = this_is_a_long_line(
-    ...     lion,
-    ...     hippo,
-    ...     lemur,
-    ...     bear,
-    ... )
-    """
-    pass
-
------ stderr -----
-"###);
+    ----- stderr -----
+    "###);
     Ok(())
 }
 
@@ -348,7 +523,7 @@ from module import =
     ----- stdout -----
 
     ----- stderr -----
-    error: Failed to parse main.py:2:20: Unexpected token '='
+    error: Failed to parse main.py:2:20: Expected an import name
     "###);
 
     Ok(())
@@ -508,6 +683,9 @@ if __name__ == '__main__':
         say_hy("dear Ruff contributor")
 
     ----- stderr -----
+    warning: The top-level linter settings are deprecated in favour of their counterparts in the `lint` section. Please update the following options in `ruff.toml`:
+      - 'extend-select' -> 'lint.extend-select'
+      - 'ignore' -> 'lint.ignore'
     "###);
     Ok(())
 }
@@ -546,6 +724,9 @@ if __name__ == '__main__':
         say_hy("dear Ruff contributor")
 
     ----- stderr -----
+    warning: The top-level linter settings are deprecated in favour of their counterparts in the `lint` section. Please update the following options in `ruff.toml`:
+      - 'extend-select' -> 'lint.extend-select'
+      - 'ignore' -> 'lint.ignore'
     "###);
     Ok(())
 }
@@ -1538,3 +1719,322 @@ include = ["*.ipy"]
     "###);
     Ok(())
 }
+
+#[test]
+fn range_formatting() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--stdin-filename", "test.py", "--range=2:8-2:14"])
+        .arg("-")
+        .pass_stdin(r#"
+def foo(arg1, arg2,):
+    print("Shouldn't format this" )
+
+"#), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    def foo(
+        arg1,
+        arg2,
+    ):
+        print("Shouldn't format this" )
+
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn range_formatting_unicode() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--stdin-filename", "test.py", "--range=2:21-3"])
+        .arg("-")
+        .pass_stdin(r#"
+def foo(arg1="👋🏽" ): print("Format this" )
+"#), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    def foo(arg1="👋🏽" ):
+        print("Format this")
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn range_formatting_multiple_files() -> std::io::Result<()> {
+    let tempdir = TempDir::new()?;
+    let file1 = tempdir.path().join("file1.py");
+
+    fs::write(
+        &file1,
+        r#"
+def file1(arg1, arg2,):
+    print("Shouldn't format this" )
+
+"#,
+    )?;
+
+    let file2 = tempdir.path().join("file2.py");
+
+    fs::write(
+        &file2,
+        r#"
+def file2(arg1, arg2,):
+    print("Shouldn't format this" )
+
+"#,
+    )?;
+
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--range=1:8-1:15"])
+        .arg(file1)
+        .arg(file2),  @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    ruff failed
+      Cause: The `--range` option is only supported when formatting a single file but the specified paths resolve to 2 files.
+    "###);
+
+    Ok(())
+}
+
+#[test]
+fn range_formatting_out_of_bounds() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--stdin-filename", "test.py", "--range=100:40-200:1"])
+        .arg("-")
+        .pass_stdin(r#"
+def foo(arg1, arg2,):
+    print("Shouldn't format this" )
+
+"#), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    def foo(arg1, arg2,):
+        print("Shouldn't format this" )
+
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn range_start_larger_than_end() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--stdin-filename", "test.py", "--range=90-50"])
+        .arg("-")
+        .pass_stdin(r#"
+def foo(arg1, arg2,):
+    print("Shouldn't format this" )
+
+"#), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value '90-50' for '--range <RANGE>': the start position '90:1' is greater than the end position '50:1'.
+        tip: Try switching start and end: '50:1-90:1'
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn range_line_numbers_only() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--stdin-filename", "test.py", "--range=2-3"])
+        .arg("-")
+        .pass_stdin(r#"
+def foo(arg1, arg2,):
+    print("Shouldn't format this" )
+
+"#), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    def foo(
+        arg1,
+        arg2,
+    ):
+        print("Shouldn't format this" )
+
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn range_start_only() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--stdin-filename", "test.py", "--range=3"])
+        .arg("-")
+        .pass_stdin(r#"
+def foo(arg1, arg2,):
+    print("Should format this" )
+
+"#), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    def foo(arg1, arg2,):
+        print("Should format this")
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn range_end_only() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--stdin-filename", "test.py", "--range=-3"])
+        .arg("-")
+        .pass_stdin(r#"
+def foo(arg1, arg2,):
+    print("Should format this" )
+
+"#), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    def foo(
+        arg1,
+        arg2,
+    ):
+        print("Should format this" )
+
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn range_missing_line() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--stdin-filename", "test.py", "--range=1-:20"])
+        .arg("-")
+        .pass_stdin(r#"
+def foo(arg1, arg2,):
+    print("Should format this" )
+
+"#), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value '1-:20' for '--range <RANGE>': the end line is not a valid number (cannot parse integer from empty string)
+      tip: The format is 'line:column'.
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn zero_line_number() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--stdin-filename", "test.py", "--range=0:2"])
+        .arg("-")
+        .pass_stdin(r#"
+def foo(arg1, arg2,):
+    print("Should format this" )
+
+"#), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value '0:2' for '--range <RANGE>': the start line is 0, but it should be 1 or greater.
+      tip: The line numbers start at 1.
+      tip: Try 1:2 instead.
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn column_and_line_zero() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--stdin-filename", "test.py", "--range=0:0"])
+        .arg("-")
+        .pass_stdin(r#"
+def foo(arg1, arg2,):
+    print("Should format this" )
+
+"#), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value '0:0' for '--range <RANGE>': the start line and column are both 0, but they should be 1 or greater.
+      tip: The line and column numbers start at 1.
+      tip: Try 1:1 instead.
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn range_formatting_notebook() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["format", "--isolated", "--no-cache", "--stdin-filename", "main.ipynb", "--range=1-2"])
+        .arg("-")
+        .pass_stdin(r#"
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ad6f36d9-4b7d-4562-8d00-f15a0f1fbb6d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=1"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
+"#), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: Failed to format main.ipynb: Range formatting isn't supported for notebooks.
+    "###);
+}

crates/ruff/tests/integration_test.rs

@@ -31,25 +31,14 @@ fn ruff_cmd() -> Command {
 }
 
 /// Builder for `ruff check` commands.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 struct RuffCheck<'a> {
-    output_format: &'a str,
+    output_format: Option<&'a str>,
     config: Option<&'a Path>,
     filename: Option<&'a str>,
     args: Vec<&'a str>,
 }
 
-impl<'a> Default for RuffCheck<'a> {
-    fn default() -> RuffCheck<'a> {
-        RuffCheck {
-            output_format: "text",
-            config: None,
-            filename: None,
-            args: vec![],
-        }
-    }
-}
-
 impl<'a> RuffCheck<'a> {
     /// Set the `--config` option.
     #[must_use]
@@ -61,7 +50,7 @@ impl<'a> RuffCheck<'a> {
     /// Set the `--output-format` option.
     #[must_use]
     fn output_format(mut self, format: &'a str) -> Self {
-        self.output_format = format;
+        self.output_format = Some(format);
         self
     }
 
@@ -82,7 +71,12 @@ impl<'a> RuffCheck<'a> {
     /// Generate a [`Command`] for the `ruff check` command.
     fn build(self) -> Command {
         let mut cmd = ruff_cmd();
-        cmd.args(["--output-format", self.output_format, "--no-cache"]);
+        cmd.arg("check");
+        if let Some(output_format) = self.output_format {
+            cmd.args(["--output-format", output_format]);
+        }
+        cmd.arg("--no-cache");
+
         if let Some(path) = self.config {
             cmd.arg("--config");
             cmd.arg(path);
@@ -107,6 +101,7 @@ fn stdin_success() {
     success: true
     exit_code: 0
     ----- stdout -----
+    All checks passed!
 
     ----- stderr -----
     "###);
@@ -228,6 +223,7 @@ fn stdin_source_type_pyi() {
     success: true
     exit_code: 0
     ----- stdout -----
+    All checks passed!
 
     ----- stderr -----
     "###);
@@ -596,6 +592,7 @@ fn stdin_fix_when_no_issues_should_still_print_contents() {
     print(sys.version)
 
     ----- stderr -----
+    All checks passed!
     "###);
 }
 
@@ -734,17 +731,17 @@ fn stdin_parse_error() {
     success: false
     exit_code: 1
     ----- stdout -----
-    -:1:17: E999 SyntaxError: Unexpected token '='
+    -:1:17: E999 SyntaxError: Expected an import name
     Found 1 error.
 
     ----- stderr -----
-    error: Failed to parse at 1:17: Unexpected token '='
+    error: Failed to parse at 1:17: Expected an import name
     "###);
 }
 
 #[test]
-fn show_source() {
-    let mut cmd = RuffCheck::default().args(["--show-source"]).build();
+fn full_output_preview() {
+    let mut cmd = RuffCheck::default().args(["--preview"]).build();
     assert_cmd_snapshot!(cmd
         .pass_stdin("l = 1"), @r###"
     success: false
@@ -763,13 +760,62 @@ fn show_source() {
 }
 
 #[test]
-fn explain_status_codes_f401() {
-    assert_cmd_snapshot!(ruff_cmd().args(["--explain", "F401"]));
+fn full_output_preview_config() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let pyproject_toml = tempdir.path().join("pyproject.toml");
+    fs::write(
+        &pyproject_toml,
+        r#"
+[tool.ruff]
+preview = true
+"#,
+    )?;
+    let mut cmd = RuffCheck::default().config(&pyproject_toml).build();
+    assert_cmd_snapshot!(cmd.pass_stdin("l = 1"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `l`
+      |
+    1 | l = 1
+      | ^ E741
+      |
+
+    Found 1 error.
+
+    ----- stderr -----
+    "###);
+    Ok(())
 }
 
 #[test]
-fn explain_status_codes_ruf404() {
-    assert_cmd_snapshot!(ruff_cmd().args(["--explain", "RUF404"]), @r###"
+fn full_output_format() {
+    let mut cmd = RuffCheck::default().output_format("full").build();
+    assert_cmd_snapshot!(cmd
+        .pass_stdin("l = 1"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `l`
+      |
+    1 | l = 1
+      | ^ E741
+      |
+
+    Found 1 error.
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn rule_f401() {
+    assert_cmd_snapshot!(ruff_cmd().args(["rule", "F401"]));
+}
+
+#[test]
+fn rule_invalid_rule_name() {
+    assert_cmd_snapshot!(ruff_cmd().args(["rule", "RUF404"]), @r###"
     success: false
     exit_code: 2
     ----- stdout -----
@@ -800,7 +846,9 @@ fn show_statistics() {
 #[test]
 fn nursery_prefix() {
     // Should only detect RUF90X, but not the unstable test rules
-    let mut cmd = RuffCheck::default().args(["--select", "RUF9"]).build();
+    let mut cmd = RuffCheck::default()
+        .args(["--select", "RUF9", "--output-format=concise"])
+        .build();
     assert_cmd_snapshot!(cmd, @r###"
     success: false
     exit_code: 1
@@ -809,7 +857,10 @@ fn nursery_prefix() {
     -:1:1: RUF901 [*] Hey this is a stable test rule with a safe fix.
     -:1:1: RUF902 Hey this is a stable test rule with an unsafe fix.
     -:1:1: RUF903 Hey this is a stable test rule with a display only fix.
-    Found 4 errors.
+    -:1:1: RUF920 Hey this is a deprecated test rule.
+    -:1:1: RUF921 Hey this is another deprecated test rule.
+    -:1:1: RUF950 Hey this is a test rule that was redirected from another.
+    Found 7 errors.
     [*] 1 fixable with the `--fix` option (1 hidden fix can be enabled with the `--unsafe-fixes` option).
 
     ----- stderr -----
@@ -819,7 +870,9 @@ fn nursery_prefix() {
 #[test]
 fn nursery_all() {
     // Should detect RUF90X, but not the unstable test rules
-    let mut cmd = RuffCheck::default().args(["--select", "ALL"]).build();
+    let mut cmd = RuffCheck::default()
+        .args(["--select", "ALL", "--output-format=concise"])
+        .build();
     assert_cmd_snapshot!(cmd, @r###"
     success: false
     exit_code: 1
@@ -829,7 +882,10 @@ fn nursery_all() {
     -:1:1: RUF901 [*] Hey this is a stable test rule with a safe fix.
     -:1:1: RUF902 Hey this is a stable test rule with an unsafe fix.
     -:1:1: RUF903 Hey this is a stable test rule with a display only fix.
-    Found 5 errors.
+    -:1:1: RUF920 Hey this is a deprecated test rule.
+    -:1:1: RUF921 Hey this is another deprecated test rule.
+    -:1:1: RUF950 Hey this is a test rule that was redirected from another.
+    Found 8 errors.
     [*] 1 fixable with the `--fix` option (1 hidden fix can be enabled with the `--unsafe-fixes` option).
 
     ----- stderr -----
@@ -840,41 +896,44 @@ fn nursery_all() {
 
 #[test]
 fn nursery_direct() {
-    // Should warn that the nursery rule is selected without preview flag but still
-    // include the diagnostic
-    let mut cmd = RuffCheck::default().args(["--select", "RUF912"]).build();
+    // Should fail when a nursery rule is selected without the preview flag
+    // Before Ruff v0.2.0 this would warn
+    let mut cmd = RuffCheck::default()
+        .args(["--select", "RUF912", "--output-format=concise"])
+        .build();
     assert_cmd_snapshot!(cmd, @r###"
     success: false
-    exit_code: 1
+    exit_code: 2
     ----- stdout -----
-    -:1:1: RUF912 Hey this is a nursery test rule.
-    Found 1 error.
 
     ----- stderr -----
-    warning: Selection of nursery rule `RUF912` without the `--preview` flag is deprecated.
+    ruff failed
+      Cause: Selection of unstable rule `RUF912` without the `--preview` flag is not allowed.
     "###);
 }
 
 #[test]
 fn nursery_group_selector() {
-    // Only nursery rules should be detected e.g. RUF912
-    let mut cmd = RuffCheck::default().args(["--select", "NURSERY"]).build();
+    // The NURSERY selector is removed but parses in the CLI for a nicer error message
+    // Before Ruff v0.2.0 this would warn
+    let mut cmd = RuffCheck::default()
+        .args(["--select", "NURSERY", "--output-format=concise"])
+        .build();
     assert_cmd_snapshot!(cmd, @r###"
     success: false
-    exit_code: 1
+    exit_code: 2
     ----- stdout -----
-    -:1:1: CPY001 Missing copyright notice at top of file
-    -:1:1: RUF912 Hey this is a nursery test rule.
-    Found 2 errors.
 
     ----- stderr -----
-    warning: The `NURSERY` selector has been deprecated. Use the `--preview` flag instead.
+    ruff failed
+      Cause: The `NURSERY` selector was removed. Use the `--preview` flag instead.
     "###);
 }
 
 #[test]
 fn nursery_group_selector_preview_enabled() {
-    // A warning should be displayed due to deprecated selector usage
+    // When preview mode is enabled, we shouldn't suggest using the `--preview` flag.
+    // Before Ruff v0.2.0 this would warn
     let mut cmd = RuffCheck::default()
         .args(["--select", "NURSERY", "--preview"])
         .build();
@@ -885,7 +944,7 @@ fn nursery_group_selector_preview_enabled() {
 
     ----- stderr -----
     ruff failed
-      Cause: The `NURSERY` selector is deprecated and cannot be used with preview mode enabled.
+      Cause: The `NURSERY` selector was removed. Unstable rules should be selected individually or by their respective groups.
     "###);
 }
 
@@ -893,7 +952,7 @@ fn nursery_group_selector_preview_enabled() {
 fn preview_enabled_prefix() {
     // All the RUF9XX test rules should be triggered
     let mut cmd = RuffCheck::default()
-        .args(["--select", "RUF9", "--preview"])
+        .args(["--select", "RUF9", "--output-format=concise", "--preview"])
         .build();
     assert_cmd_snapshot!(cmd, @r###"
     success: false
@@ -905,7 +964,8 @@ fn preview_enabled_prefix() {
     -:1:1: RUF903 Hey this is a stable test rule with a display only fix.
     -:1:1: RUF911 Hey this is a preview test rule.
     -:1:1: RUF912 Hey this is a nursery test rule.
-    Found 6 errors.
+    -:1:1: RUF950 Hey this is a test rule that was redirected from another.
+    Found 7 errors.
     [*] 1 fixable with the `--fix` option (1 hidden fix can be enabled with the `--unsafe-fixes` option).
 
     ----- stderr -----
@@ -915,7 +975,7 @@ fn preview_enabled_prefix() {
 #[test]
 fn preview_enabled_all() {
     let mut cmd = RuffCheck::default()
-        .args(["--select", "ALL", "--preview"])
+        .args(["--select", "ALL", "--output-format=concise", "--preview"])
         .build();
     assert_cmd_snapshot!(cmd, @r###"
     success: false
@@ -929,7 +989,8 @@ fn preview_enabled_all() {
     -:1:1: RUF903 Hey this is a stable test rule with a display only fix.
     -:1:1: RUF911 Hey this is a preview test rule.
     -:1:1: RUF912 Hey this is a nursery test rule.
-    Found 8 errors.
+    -:1:1: RUF950 Hey this is a test rule that was redirected from another.
+    Found 9 errors.
     [*] 1 fixable with the `--fix` option (1 hidden fix can be enabled with the `--unsafe-fixes` option).
 
     ----- stderr -----
@@ -942,7 +1003,7 @@ fn preview_enabled_all() {
 fn preview_enabled_direct() {
     // Should be enabled without warning
     let mut cmd = RuffCheck::default()
-        .args(["--select", "RUF911", "--preview"])
+        .args(["--select", "RUF911", "--output-format=concise", "--preview"])
         .build();
     assert_cmd_snapshot!(cmd, @r###"
     success: false
@@ -957,40 +1018,49 @@ fn preview_enabled_direct() {
 
 #[test]
 fn preview_disabled_direct() {
-    // RUFF911 is preview not nursery so the selection should be empty
-    let mut cmd = RuffCheck::default().args(["--select", "RUF911"]).build();
+    // RUFF911 is preview so we should warn without selecting
+    let mut cmd = RuffCheck::default()
+        .args(["--select", "RUF911", "--output-format=concise"])
+        .build();
     assert_cmd_snapshot!(cmd, @r###"
     success: true
     exit_code: 0
     ----- stdout -----
+    All checks passed!
 
     ----- stderr -----
-    warning: Selection `RUF911` has no effect because the `--preview` flag was not included.
+    warning: Selection `RUF911` has no effect because preview is not enabled.
     "###);
 }
 
 #[test]
 fn preview_disabled_prefix_empty() {
     // Warns that the selection is empty since all of the RUF91 rules are in preview
-    let mut cmd = RuffCheck::default().args(["--select", "RUF91"]).build();
+    let mut cmd = RuffCheck::default()
+        .args(["--select", "RUF91", "--output-format=concise"])
+        .build();
     assert_cmd_snapshot!(cmd, @r###"
     success: true
     exit_code: 0
     ----- stdout -----
+    All checks passed!
 
     ----- stderr -----
-    warning: Selection `RUF91` has no effect because the `--preview` flag was not included.
+    warning: Selection `RUF91` has no effect because preview is not enabled.
     "###);
 }
 
 #[test]
 fn preview_disabled_does_not_warn_for_empty_ignore_selections() {
     // Does not warn that the selection is empty since the user is not trying to enable the rule
-    let mut cmd = RuffCheck::default().args(["--ignore", "RUF9"]).build();
+    let mut cmd = RuffCheck::default()
+        .args(["--ignore", "RUF9", "--output-format=concise"])
+        .build();
     assert_cmd_snapshot!(cmd, @r###"
     success: true
     exit_code: 0
     ----- stdout -----
+    All checks passed!
 
     ----- stderr -----
     "###);
@@ -999,11 +1069,14 @@ fn preview_disabled_does_not_warn_for_empty_ignore_selections() {
 #[test]
 fn preview_disabled_does_not_warn_for_empty_fixable_selections() {
     // Does not warn that the selection is empty since the user is not trying to enable the rule
-    let mut cmd = RuffCheck::default().args(["--fixable", "RUF9"]).build();
+    let mut cmd = RuffCheck::default()
+        .args(["--fixable", "RUF9", "--output-format=concise"])
+        .build();
     assert_cmd_snapshot!(cmd, @r###"
     success: true
     exit_code: 0
     ----- stdout -----
+    All checks passed!
 
     ----- stderr -----
     "###);
@@ -1013,7 +1086,12 @@ fn preview_disabled_does_not_warn_for_empty_fixable_selections() {
 fn preview_group_selector() {
     // `--select PREVIEW` should error (selector was removed)
     let mut cmd = RuffCheck::default()
-        .args(["--select", "PREVIEW", "--preview"])
+        .args([
+            "--select",
+            "PREVIEW",
+            "--preview",
+            "--output-format=concise",
+        ])
         .build();
     assert_cmd_snapshot!(cmd
         .pass_stdin("I=42\n"), @r###"
@@ -1032,10 +1110,16 @@ fn preview_group_selector() {
 fn preview_enabled_group_ignore() {
     // Should detect stable and unstable rules, RUF9 is more specific than RUF so ignore has no effect
     let mut cmd = RuffCheck::default()
-        .args(["--select", "RUF9", "--ignore", "RUF", "--preview"])
+        .args([
+            "--select",
+            "RUF9",
+            "--ignore",
+            "RUF",
+            "--preview",
+            "--output-format=concise",
+        ])
         .build();
-    assert_cmd_snapshot!(cmd
-        .pass_stdin("I=42\n"), @r###"
+    assert_cmd_snapshot!(cmd, @r###"
     success: false
     exit_code: 1
     ----- stdout -----
@@ -1045,13 +1129,220 @@ fn preview_enabled_group_ignore() {
     -:1:1: RUF903 Hey this is a stable test rule with a display only fix.
     -:1:1: RUF911 Hey this is a preview test rule.
     -:1:1: RUF912 Hey this is a nursery test rule.
-    Found 6 errors.
+    -:1:1: RUF950 Hey this is a test rule that was redirected from another.
+    Found 7 errors.
     [*] 1 fixable with the `--fix` option (1 hidden fix can be enabled with the `--unsafe-fixes` option).
 
     ----- stderr -----
     "###);
 }
 
+#[test]
+fn removed_direct() {
+    // Selection of a removed rule should fail
+    let mut cmd = RuffCheck::default().args(["--select", "RUF931"]).build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    ruff failed
+      Cause: Rule `RUF931` was removed and cannot be selected.
+    "###);
+}
+
+#[test]
+fn removed_direct_multiple() {
+    // Selection of multiple removed rule should fail with a message
+    // including all the rules
+    let mut cmd = RuffCheck::default()
+        .args(["--select", "RUF930", "--select", "RUF931"])
+        .build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    ruff failed
+      Cause: The following rules have been removed and cannot be selected:
+        - RUF930
+        - RUF931
+
+    "###);
+}
+
+#[test]
+fn removed_indirect() {
+    // Selection _including_ a removed rule without matching should not fail
+    // nor should the rule be used
+    let mut cmd = RuffCheck::default().args(["--select", "RUF93"]).build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    All checks passed!
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn redirect_direct() {
+    // Selection of a redirected rule directly should use the new rule and warn
+    let mut cmd = RuffCheck::default().args(["--select", "RUF940"]).build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: RUF950 Hey this is a test rule that was redirected from another.
+    Found 1 error.
+
+    ----- stderr -----
+    warning: `RUF940` has been remapped to `RUF950`.
+    "###);
+}
+
+#[test]
+fn redirect_indirect() {
+    // Selection _including_ a redirected rule without matching should not fail
+    // nor should the rule be used
+    let mut cmd = RuffCheck::default().args(["--select", "RUF94"]).build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    All checks passed!
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn redirect_prefix() {
+    // Selection using a redirected prefix should switch to all rules in the
+    // new prefix
+    let mut cmd = RuffCheck::default().args(["--select", "RUF96"]).build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: RUF950 Hey this is a test rule that was redirected from another.
+    Found 1 error.
+
+    ----- stderr -----
+    warning: `RUF96` has been remapped to `RUF95`.
+    "###);
+}
+
+#[test]
+fn deprecated_direct() {
+    // Selection of a deprecated rule without preview enabled should still work
+    // but a warning should be displayed
+    let mut cmd = RuffCheck::default().args(["--select", "RUF920"]).build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: RUF920 Hey this is a deprecated test rule.
+    Found 1 error.
+
+    ----- stderr -----
+    warning: Rule `RUF920` is deprecated and will be removed in a future release.
+    "###);
+}
+
+#[test]
+fn deprecated_multiple_direct() {
+    let mut cmd = RuffCheck::default()
+        .args(["--select", "RUF920", "--select", "RUF921"])
+        .build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: RUF920 Hey this is a deprecated test rule.
+    -:1:1: RUF921 Hey this is another deprecated test rule.
+    Found 2 errors.
+
+    ----- stderr -----
+    warning: Rule `RUF920` is deprecated and will be removed in a future release.
+    warning: Rule `RUF921` is deprecated and will be removed in a future release.
+    "###);
+}
+
+#[test]
+fn deprecated_indirect() {
+    // `RUF92` includes deprecated rules but should not warn
+    // since it is not a "direct" selection
+    let mut cmd = RuffCheck::default().args(["--select", "RUF92"]).build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: RUF920 Hey this is a deprecated test rule.
+    -:1:1: RUF921 Hey this is another deprecated test rule.
+    Found 2 errors.
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn deprecated_direct_preview_enabled() {
+    // Direct selection of a deprecated rule in preview should fail
+    let mut cmd = RuffCheck::default()
+        .args(["--select", "RUF920", "--preview"])
+        .build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    ruff failed
+      Cause: Selection of deprecated rule `RUF920` is not allowed when preview is enabled.
+    "###);
+}
+
+#[test]
+fn deprecated_indirect_preview_enabled() {
+    // `RUF920` is deprecated and should be off by default in preview.
+    let mut cmd = RuffCheck::default()
+        .args(["--select", "RUF92", "--preview"])
+        .build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    All checks passed!
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn deprecated_multiple_direct_preview_enabled() {
+    // Direct selection of the deprecated rules in preview should fail with
+    // a message listing all of the rule codes
+    let mut cmd = RuffCheck::default()
+        .args(["--select", "RUF920", "--select", "RUF921", "--preview"])
+        .build();
+    assert_cmd_snapshot!(cmd, @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    ruff failed
+      Cause: Selection of deprecated rules is not allowed when preview is enabled. Remove selection of:
+    	- RUF920
+    	- RUF921
+
+    "###);
+}
+
 /// An unreadable pyproject.toml in non-isolated mode causes ruff to hard-error trying to build up
 /// configuration globs
 #[cfg(unix)]
@@ -1062,13 +1353,14 @@ fn unreadable_pyproject_toml() -> Result<()> {
     // Create an empty file with 000 permissions
     fs::OpenOptions::new()
         .create(true)
+        .truncate(true)
         .write(true)
         .mode(0o000)
         .open(pyproject_toml)?;
 
     // Don't `--isolated` since the configuration discovery is where the error happens
     let args = Args::parse_from(["", "check", "--no-cache", tempdir.path().to_str().unwrap()]);
-    let err = run(args).err().context("Unexpected success")?;
+    let err = run(args, None).err().context("Unexpected success")?;
     assert_eq!(
         err.chain()
             .map(std::string::ToString::to_string)
@@ -1102,6 +1394,7 @@ fn unreadable_dir() -> Result<()> {
     success: true
     exit_code: 0
     ----- stdout -----
+    All checks passed!
 
     ----- stderr -----
     warning: Encountered error: Permission denied (os error 13)
@@ -1569,7 +1862,10 @@ extend-safe-fixes = ["RUF9"]
     -:1:1: RUF901 Hey this is a stable test rule with a safe fix.
     -:1:1: RUF902 [*] Hey this is a stable test rule with an unsafe fix.
     -:1:1: RUF903 Hey this is a stable test rule with a display only fix.
-    Found 4 errors.
+    -:1:1: RUF920 Hey this is a deprecated test rule.
+    -:1:1: RUF921 Hey this is another deprecated test rule.
+    -:1:1: RUF950 Hey this is a test rule that was redirected from another.
+    Found 7 errors.
     [*] 1 fixable with the `--fix` option (1 hidden fix can be enabled with the `--unsafe-fixes` option).
 
     ----- stderr -----
@@ -1613,6 +1909,7 @@ def log(x, base) -> float:
     success: true
     exit_code: 0
     ----- stdout -----
+    All checks passed!
 
     ----- stderr -----
     "###

crates/ruff/tests/resolve_files.rs

@@ -39,6 +39,8 @@ fn check_project_include_defaults() {
         [BASEPATH]/include-test/subdirectory/c.py
 
         ----- stderr -----
+        warning: The top-level linter settings are deprecated in favour of their counterparts in the `lint` section. Please update the following options in `nested-project/pyproject.toml`:
+          - 'select' -> 'lint.select'
         "###);
     });
 }

crates/ruff/tests/show_settings.rs

@@ -4,25 +4,29 @@ use std::process::Command;
 
 const BIN_NAME: &str = "ruff";
 
-#[cfg(not(target_os = "windows"))]
-const TEST_FILTERS: &[(&str, &str)] = &[
-    ("\"[^\\*\"]*/pyproject.toml", "\"[BASEPATH]/pyproject.toml"),
-    ("\".*/crates", "\"[BASEPATH]/crates"),
-    ("\".*/\\.ruff_cache", "\"[BASEPATH]/.ruff_cache"),
-    ("\".*/ruff\"", "\"[BASEPATH]\""),
-];
-#[cfg(target_os = "windows")]
-const TEST_FILTERS: &[(&str, &str)] = &[
-    (r#""[^\*"]*\\pyproject.toml"#, "\"[BASEPATH]/pyproject.toml"),
-    (r#"".*\\crates"#, "\"[BASEPATH]/crates"),
-    (r#"".*\\\.ruff_cache"#, "\"[BASEPATH]/.ruff_cache"),
-    (r#"".*\\ruff""#, "\"[BASEPATH]\""),
-    (r#"\\+(\w\w|\s|")"#, "/$1"),
-];
-
 #[test]
 fn display_default_settings() {
-    insta::with_settings!({ filters => TEST_FILTERS.to_vec() }, {
+    // Navigate from the crate directory to the workspace root.
+    let base_path = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap();
+    let base_path = base_path.to_string_lossy();
+
+    // Escape the backslashes for the regex.
+    let base_path = regex::escape(&base_path);
+
+    #[cfg(not(target_os = "windows"))]
+    let test_filters = &[(base_path.as_ref(), "[BASEPATH]")];
+
+    #[cfg(target_os = "windows")]
+    let test_filters = &[
+        (base_path.as_ref(), "[BASEPATH]"),
+        (r#"\\+(\w\w|\s|\.|")"#, "/$1"),
+    ];
+
+    insta::with_settings!({ filters => test_filters.to_vec() }, {
         assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
             .args(["check", "--show-settings", "unformatted.py"]).current_dir(Path::new("./resources/test/fixtures")));
     });

crates/ruff/tests/snapshots/integration_test__rule_f401.snap

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

crates/ruff/tests/snapshots/show_settings__display_default_settings.snap

@@ -17,9 +17,8 @@ Settings path: "[BASEPATH]/pyproject.toml"
 cache_dir = "[BASEPATH]/.ruff_cache"
 fix = false
 fix_only = false
-output_format = text
+output_format = concise
 show_fixes = false
-show_source = false
 unsafe_fixes = hint
 
 # File Resolver Settings
@@ -45,15 +44,16 @@ file_resolver.exclude = [
 	"__pypackages__",
 	"_build",
 	"buck-out",
-	"build",
 	"dist",
 	"node_modules",
 	"site-packages",
 	"venv",
 ]
 file_resolver.extend_exclude = [
+	"crates/ruff/resources/",
 	"crates/ruff_linter/resources/",
 	"crates/ruff_python_formatter/resources/",
+	"crates/ruff_python_parser/resources/",
 ]
 file_resolver.force_exclude = false
 file_resolver.include = [
@@ -69,128 +69,128 @@ file_resolver.project_root = "[BASEPATH]"
 linter.exclude = []
 linter.project_root = "[BASEPATH]"
 linter.rules.enabled = [
-	MultipleImportsOnOneLine,
-	ModuleImportNotAtTopOfFile,
-	MultipleStatementsOnOneLineColon,
-	MultipleStatementsOnOneLineSemicolon,
-	UselessSemicolon,
-	NoneComparison,
-	TrueFalseComparison,
-	NotInTest,
-	NotIsTest,
-	TypeComparison,
-	BareExcept,
-	LambdaAssignment,
-	AmbiguousVariableName,
-	AmbiguousClassName,
-	AmbiguousFunctionName,
-	IOError,
-	SyntaxError,
-	UnusedImport,
-	ImportShadowedByLoopVar,
-	UndefinedLocalWithImportStar,
-	LateFutureImport,
-	UndefinedLocalWithImportStarUsage,
-	UndefinedLocalWithNestedImportStarUsage,
-	FutureFeatureNotDefined,
-	PercentFormatInvalidFormat,
-	PercentFormatExpectedMapping,
-	PercentFormatExpectedSequence,
-	PercentFormatExtraNamedArguments,
-	PercentFormatMissingArgument,
-	PercentFormatMixedPositionalAndNamed,
-	PercentFormatPositionalCountMismatch,
-	PercentFormatStarRequiresSequence,
-	PercentFormatUnsupportedFormatCharacter,
-	StringDotFormatInvalidFormat,
-	StringDotFormatExtraNamedArguments,
-	StringDotFormatExtraPositionalArguments,
-	StringDotFormatMissingArguments,
-	StringDotFormatMixingAutomatic,
-	FStringMissingPlaceholders,
-	MultiValueRepeatedKeyLiteral,
-	MultiValueRepeatedKeyVariable,
-	ExpressionsInStarAssignment,
-	MultipleStarredExpressions,
-	AssertTuple,
-	IsLiteral,
-	InvalidPrintSyntax,
-	IfTuple,
-	BreakOutsideLoop,
-	ContinueOutsideLoop,
-	YieldOutsideFunction,
-	ReturnOutsideFunction,
-	DefaultExceptNotLast,
-	ForwardAnnotationSyntaxError,
-	RedefinedWhileUnused,
-	UndefinedName,
-	UndefinedExport,
-	UndefinedLocal,
-	UnusedVariable,
-	UnusedAnnotation,
-	RaiseNotImplemented,
+	multiple-imports-on-one-line (E401),
+	module-import-not-at-top-of-file (E402),
+	multiple-statements-on-one-line-colon (E701),
+	multiple-statements-on-one-line-semicolon (E702),
+	useless-semicolon (E703),
+	none-comparison (E711),
+	true-false-comparison (E712),
+	not-in-test (E713),
+	not-is-test (E714),
+	type-comparison (E721),
+	bare-except (E722),
+	lambda-assignment (E731),
+	ambiguous-variable-name (E741),
+	ambiguous-class-name (E742),
+	ambiguous-function-name (E743),
+	io-error (E902),
+	syntax-error (E999),
+	unused-import (F401),
+	import-shadowed-by-loop-var (F402),
+	undefined-local-with-import-star (F403),
+	late-future-import (F404),
+	undefined-local-with-import-star-usage (F405),
+	undefined-local-with-nested-import-star-usage (F406),
+	future-feature-not-defined (F407),
+	percent-format-invalid-format (F501),
+	percent-format-expected-mapping (F502),
+	percent-format-expected-sequence (F503),
+	percent-format-extra-named-arguments (F504),
+	percent-format-missing-argument (F505),
+	percent-format-mixed-positional-and-named (F506),
+	percent-format-positional-count-mismatch (F507),
+	percent-format-star-requires-sequence (F508),
+	percent-format-unsupported-format-character (F509),
+	string-dot-format-invalid-format (F521),
+	string-dot-format-extra-named-arguments (F522),
+	string-dot-format-extra-positional-arguments (F523),
+	string-dot-format-missing-arguments (F524),
+	string-dot-format-mixing-automatic (F525),
+	f-string-missing-placeholders (F541),
+	multi-value-repeated-key-literal (F601),
+	multi-value-repeated-key-variable (F602),
+	expressions-in-star-assignment (F621),
+	multiple-starred-expressions (F622),
+	assert-tuple (F631),
+	is-literal (F632),
+	invalid-print-syntax (F633),
+	if-tuple (F634),
+	break-outside-loop (F701),
+	continue-outside-loop (F702),
+	yield-outside-function (F704),
+	return-outside-function (F706),
+	default-except-not-last (F707),
+	forward-annotation-syntax-error (F722),
+	redefined-while-unused (F811),
+	undefined-name (F821),
+	undefined-export (F822),
+	undefined-local (F823),
+	unused-variable (F841),
+	unused-annotation (F842),
+	raise-not-implemented (F901),
 ]
 linter.rules.should_fix = [
-	MultipleImportsOnOneLine,
-	ModuleImportNotAtTopOfFile,
-	MultipleStatementsOnOneLineColon,
-	MultipleStatementsOnOneLineSemicolon,
-	UselessSemicolon,
-	NoneComparison,
-	TrueFalseComparison,
-	NotInTest,
-	NotIsTest,
-	TypeComparison,
-	BareExcept,
-	LambdaAssignment,
-	AmbiguousVariableName,
-	AmbiguousClassName,
-	AmbiguousFunctionName,
-	IOError,
-	SyntaxError,
-	UnusedImport,
-	ImportShadowedByLoopVar,
-	UndefinedLocalWithImportStar,
-	LateFutureImport,
-	UndefinedLocalWithImportStarUsage,
-	UndefinedLocalWithNestedImportStarUsage,
-	FutureFeatureNotDefined,
-	PercentFormatInvalidFormat,
-	PercentFormatExpectedMapping,
-	PercentFormatExpectedSequence,
-	PercentFormatExtraNamedArguments,
-	PercentFormatMissingArgument,
-	PercentFormatMixedPositionalAndNamed,
-	PercentFormatPositionalCountMismatch,
-	PercentFormatStarRequiresSequence,
-	PercentFormatUnsupportedFormatCharacter,
-	StringDotFormatInvalidFormat,
-	StringDotFormatExtraNamedArguments,
-	StringDotFormatExtraPositionalArguments,
-	StringDotFormatMissingArguments,
-	StringDotFormatMixingAutomatic,
-	FStringMissingPlaceholders,
-	MultiValueRepeatedKeyLiteral,
-	MultiValueRepeatedKeyVariable,
-	ExpressionsInStarAssignment,
-	MultipleStarredExpressions,
-	AssertTuple,
-	IsLiteral,
-	InvalidPrintSyntax,
-	IfTuple,
-	BreakOutsideLoop,
-	ContinueOutsideLoop,
-	YieldOutsideFunction,
-	ReturnOutsideFunction,
-	DefaultExceptNotLast,
-	ForwardAnnotationSyntaxError,
-	RedefinedWhileUnused,
-	UndefinedName,
-	UndefinedExport,
-	UndefinedLocal,
-	UnusedVariable,
-	UnusedAnnotation,
-	RaiseNotImplemented,
+	multiple-imports-on-one-line (E401),
+	module-import-not-at-top-of-file (E402),
+	multiple-statements-on-one-line-colon (E701),
+	multiple-statements-on-one-line-semicolon (E702),
+	useless-semicolon (E703),
+	none-comparison (E711),
+	true-false-comparison (E712),
+	not-in-test (E713),
+	not-is-test (E714),
+	type-comparison (E721),
+	bare-except (E722),
+	lambda-assignment (E731),
+	ambiguous-variable-name (E741),
+	ambiguous-class-name (E742),
+	ambiguous-function-name (E743),
+	io-error (E902),
+	syntax-error (E999),
+	unused-import (F401),
+	import-shadowed-by-loop-var (F402),
+	undefined-local-with-import-star (F403),
+	late-future-import (F404),
+	undefined-local-with-import-star-usage (F405),
+	undefined-local-with-nested-import-star-usage (F406),
+	future-feature-not-defined (F407),
+	percent-format-invalid-format (F501),
+	percent-format-expected-mapping (F502),
+	percent-format-expected-sequence (F503),
+	percent-format-extra-named-arguments (F504),
+	percent-format-missing-argument (F505),
+	percent-format-mixed-positional-and-named (F506),
+	percent-format-positional-count-mismatch (F507),
+	percent-format-star-requires-sequence (F508),
+	percent-format-unsupported-format-character (F509),
+	string-dot-format-invalid-format (F521),
+	string-dot-format-extra-named-arguments (F522),
+	string-dot-format-extra-positional-arguments (F523),
+	string-dot-format-missing-arguments (F524),
+	string-dot-format-mixing-automatic (F525),
+	f-string-missing-placeholders (F541),
+	multi-value-repeated-key-literal (F601),
+	multi-value-repeated-key-variable (F602),
+	expressions-in-star-assignment (F621),
+	multiple-starred-expressions (F622),
+	assert-tuple (F631),
+	is-literal (F632),
+	invalid-print-syntax (F633),
+	if-tuple (F634),
+	break-outside-loop (F701),
+	continue-outside-loop (F702),
+	yield-outside-function (F704),
+	return-outside-function (F706),
+	default-except-not-last (F707),
+	forward-annotation-syntax-error (F722),
+	redefined-while-unused (F811),
+	undefined-name (F821),
+	undefined-export (F822),
+	undefined-local (F823),
+	unused-variable (F841),
+	unused-annotation (F842),
+	raise-not-implemented (F901),
 ]
 linter.per_file_ignores = {}
 linter.safety_table.forced_safe = []
@@ -203,10 +203,12 @@ linter.allowed_confusables = []
 linter.builtins = []
 linter.dummy_variable_rgx = ^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$
 linter.external = []
-linter.ignore_init_module_imports = false
+linter.ignore_init_module_imports = true
 linter.logger_objects = []
 linter.namespace_packages = []
-linter.src = ["[BASEPATH]"]
+linter.src = [
+	"[BASEPATH]",
+]
 linter.tab_size = 4
 linter.line_length = 88
 linter.task_tags = [
@@ -231,7 +233,7 @@ linter.flake8_bandit.check_typed_exception = false
 linter.flake8_bugbear.extend_immutable_calls = []
 linter.flake8_builtins.builtins_ignorelist = []
 linter.flake8_comprehensions.allow_dict_calls_with_keyword_arguments = false
-linter.flake8_copyright.notice_rgx = (?i)Copyright\s+(\(C\)\s+)?\d{4}(-\d{4})*
+linter.flake8_copyright.notice_rgx = (?i)Copyright\s+((?:\(C\)|©)\s+)?\d{4}((-|,\s)\d{4})*
 linter.flake8_copyright.author = none
 linter.flake8_copyright.min_file_size = 0
 linter.flake8_errmsg.max_string_length = 0
@@ -241,7 +243,22 @@ linter.flake8_gettext.functions_names = [
 	ngettext,
 ]
 linter.flake8_implicit_str_concat.allow_multiline = true
-linter.flake8_import_conventions.aliases = {"matplotlib": "mpl", "matplotlib.pyplot": "plt", "pandas": "pd", "seaborn": "sns", "tensorflow": "tf", "networkx": "nx", "plotly.express": "px", "polars": "pl", "numpy": "np", "panel": "pn", "pyarrow": "pa", "altair": "alt", "tkinter": "tk", "holoviews": "hv"}
+linter.flake8_import_conventions.aliases = {
+	altair = alt,
+	holoviews = hv,
+	matplotlib = mpl,
+	matplotlib.pyplot = plt,
+	networkx = nx,
+	numpy = np,
+	pandas = pd,
+	panel = pn,
+	plotly.express = px,
+	polars = pl,
+	pyarrow = pa,
+	seaborn = sns,
+	tensorflow = tf,
+	tkinter = tk,
+}
 linter.flake8_import_conventions.banned_aliases = {}
 linter.flake8_import_conventions.banned_from = []
 linter.flake8_pytest_style.fixture_parentheses = true
@@ -311,6 +328,7 @@ linter.isort.section_order = [
 	known { type = first_party },
 	known { type = local_folder },
 ]
+linter.isort.default_section = known { type = third_party }
 linter.isort.no_sections = false
 linter.isort.from_first = false
 linter.isort.length_sort = false
@@ -365,4 +383,3 @@ formatter.docstring_code_format = disabled
 formatter.docstring_code_line_width = dynamic
 
 ----- stderr -----
-

crates/ruff/tests/version.rs

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

crates/ruff_benchmark/Cargo.toml

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

crates/ruff_cache/Cargo.toml

@@ -11,9 +11,9 @@ repository = { workspace = true }
 license = { workspace = true }
 
 [dependencies]
-itertools = { workspace = true }
 glob = { workspace = true }
 globset = { workspace = true }
+itertools = { workspace = true }
 regex = { workspace = true }
 filetime = { workspace = true }
 seahash = { workspace = true }

crates/ruff_cache/src/cache_key.rs

@@ -65,7 +65,7 @@ use seahash::SeaHasher;
 /// The main reason is that hashes and cache keys have different constraints:
 ///
 /// * Cache keys are less performance sensitive: Hashes must be super fast to compute for performant hashed-collections. That's
-///   why some standard types don't implement [`Hash`] where it would be safe to to implement [`CacheKey`], e.g. `HashSet`
+///   why some standard types don't implement [`Hash`] where it would be safe to implement [`CacheKey`], e.g. `HashSet`
 /// * Cache keys must be deterministic where hash keys do not have this constraint. That's why pointers don't implement [`CacheKey`] but they implement [`Hash`].
 /// * Ideally, cache keys are portable
 ///

crates/ruff_dev/Cargo.toml

@@ -22,7 +22,7 @@ ruff_python_formatter = { path = "../ruff_python_formatter" }
 ruff_python_parser = { path = "../ruff_python_parser" }
 ruff_python_stdlib = { path = "../ruff_python_stdlib" }
 ruff_python_trivia = { path = "../ruff_python_trivia" }
-ruff_workspace = { path = "../ruff_workspace", features = ["schemars"]}
+ruff_workspace = { path = "../ruff_workspace", features = ["schemars"] }
 
 anyhow = { workspace = true }
 clap = { workspace = true, features = ["wrap_help"] }
@@ -31,7 +31,6 @@ imara-diff = { workspace = true }
 indicatif = { workspace = true }
 itertools = { workspace = true }
 libcst = { workspace = true }
-once_cell = { workspace = true }
 pretty_assertions = { workspace = true }
 rayon = { workspace = true }
 regex = { workspace = true }

crates/ruff_dev/src/format_dev.rs

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

crates/ruff_dev/src/generate_docs.rs

@@ -1,6 +1,7 @@
 //! Generate Markdown documentation for applicable rules.
 #![allow(clippy::print_stdout, clippy::print_stderr)]
 
+use std::collections::HashSet;
 use std::fs;
 use std::path::PathBuf;
 
@@ -26,9 +27,9 @@ pub(crate) fn main(args: &Args) -> Result<()> {
     for rule in Rule::iter() {
         if let Some(explanation) = rule.explanation() {
             let mut output = String::new();
+
             output.push_str(&format!("# {} ({})", rule.as_ref(), rule.noqa_code()));
             output.push('\n');
-            output.push('\n');
 
             let (linter, _) = Linter::parse_code(&rule.noqa_code().to_string()).unwrap();
             if linter.url().is_some() {
@@ -37,6 +38,22 @@ pub(crate) fn main(args: &Args) -> Result<()> {
                 output.push('\n');
             }
 
+            if rule.is_deprecated() {
+                output.push_str(
+                    r"**Warning: This rule is deprecated and will be removed in a future release.**",
+                );
+                output.push('\n');
+                output.push('\n');
+            }
+
+            if rule.is_removed() {
+                output.push_str(
+                    r"**Warning: This rule has been removed and its documentation is only available for historical reasons.**",
+                );
+                output.push('\n');
+                output.push('\n');
+            }
+
             let fix_availability = rule.fixable();
             if matches!(
                 fix_availability,
@@ -81,12 +98,13 @@ pub(crate) fn main(args: &Args) -> Result<()> {
 fn process_documentation(documentation: &str, out: &mut String, rule_name: &str) {
     let mut in_options = false;
     let mut after = String::new();
+    let mut referenced_options = HashSet::new();
 
     // HACK: This is an ugly regex hack that's necessary because mkdocs uses
     // a non-CommonMark-compliant Markdown parser, which doesn't support code
     // tags in link definitions
     // (see https://github.com/Python-Markdown/markdown/issues/280).
-    let documentation = Regex::new(r"\[`([^`]*?)`]($|[^\[])").unwrap().replace_all(
+    let documentation = Regex::new(r"\[`([^`]*?)`]($|[^\[(])").unwrap().replace_all(
         documentation,
         |caps: &Captures| {
             format!(
@@ -116,9 +134,10 @@ fn process_documentation(documentation: &str, out: &mut String, rule_name: &str)
                     }
                 }
 
-                let anchor = option.replace('.', "-");
+                let anchor = option.replace('.', "_");
                 out.push_str(&format!("- [`{option}`][{option}]\n"));
                 after.push_str(&format!("[{option}]: ../settings.md#{anchor}\n"));
+                referenced_options.insert(option);
 
                 continue;
             }
@@ -126,6 +145,20 @@ fn process_documentation(documentation: &str, out: &mut String, rule_name: &str)
 
         out.push_str(line);
     }
+
+    let re = Regex::new(r"\[`([^`]*?)`]\[(.*?)]").unwrap();
+    for (_, [option, _]) in re.captures_iter(&documentation).map(|c| c.extract()) {
+        if let Some(OptionEntry::Field(field)) = Options::metadata().find(option) {
+            if referenced_options.insert(option) {
+                let anchor = option.replace('.', "_");
+                after.push_str(&format!("[{option}]: ../settings.md#{anchor}\n"));
+            }
+            if field.deprecated.is_some() {
+                eprintln!("Rule {rule_name} references deprecated option {option}.");
+            }
+        }
+    }
+
     if !after.is_empty() {
         out.push('\n');
         out.push('\n');
@@ -142,13 +175,13 @@ mod tests {
         let mut output = String::new();
         process_documentation(
             "
-See also [`mccabe.max-complexity`] and [`task-tags`].
-Something [`else`][other].
+See also [`lint.mccabe.max-complexity`] and [`lint.task-tags`].
+Something [`else`][other]. Some [link](https://example.com).
 
 ## Options
 
-- `task-tags`
-- `mccabe.max-complexity`
+- `lint.task-tags`
+- `lint.mccabe.max-complexity`
 
 [other]: http://example.com.",
             &mut output,
@@ -157,18 +190,18 @@ Something [`else`][other].
         assert_eq!(
             output,
             "
-See also [`mccabe.max-complexity`][mccabe.max-complexity] and [`task-tags`][task-tags].
-Something [`else`][other].
+See also [`lint.mccabe.max-complexity`][lint.mccabe.max-complexity] and [`lint.task-tags`][lint.task-tags].
+Something [`else`][other]. Some [link](https://example.com).
 
 ## Options
 
-- [`task-tags`][task-tags]
-- [`mccabe.max-complexity`][mccabe.max-complexity]
+- [`lint.task-tags`][lint.task-tags]
+- [`lint.mccabe.max-complexity`][lint.mccabe.max-complexity]
 
 [other]: http://example.com.
 
-[task-tags]: ../settings.md#task-tags
-[mccabe.max-complexity]: ../settings.md#mccabe-max-complexity
+[lint.task-tags]: ../settings.md#lint_task-tags
+[lint.mccabe.max-complexity]: ../settings.md#lint_mccabe_max-complexity
 "
         );
     }

crates/ruff_dev/src/generate_options.rs

@@ -1,6 +1,7 @@
 //! Generate a Markdown-compatible listing of configuration options for `pyproject.toml`.
 //!
 //! Used for <https://docs.astral.sh/ruff/settings/>.
+use itertools::Itertools;
 use std::fmt::Write;
 
 use ruff_python_trivia::textwrap;
@@ -9,16 +10,29 @@ use ruff_workspace::options_base::{OptionField, OptionSet, OptionsMetadata, Visi
 
 pub(crate) fn generate() -> String {
     let mut output = String::new();
-    generate_set(&mut output, &Set::Toplevel(Options::metadata()));
+
+    generate_set(
+        &mut output,
+        Set::Toplevel(Options::metadata()),
+        &mut Vec::new(),
+    );
 
     output
 }
 
-fn generate_set(output: &mut String, set: &Set) {
-    if set.level() < 2 {
-        writeln!(output, "### {title}\n", title = set.title()).unwrap();
-    } else {
-        writeln!(output, "#### {title}\n", title = set.title()).unwrap();
+fn generate_set(output: &mut String, set: Set, parents: &mut Vec<Set>) {
+    match &set {
+        Set::Toplevel(_) => {
+            output.push_str("### Top-level\n");
+        }
+        Set::Named { name, .. } => {
+            let title = parents
+                .iter()
+                .filter_map(|set| set.name())
+                .chain(std::iter::once(name.as_str()))
+                .join(".");
+            writeln!(output, "#### `{title}`\n",).unwrap();
+        }
     }
 
     if let Some(documentation) = set.metadata().documentation() {
@@ -35,72 +49,68 @@ fn generate_set(output: &mut String, set: &Set) {
     fields.sort_unstable_by(|(name, _), (name2, _)| name.cmp(name2));
     sets.sort_unstable_by(|(name, _), (name2, _)| name.cmp(name2));
 
+    parents.push(set);
+
     // Generate the fields.
     for (name, field) in &fields {
-        emit_field(output, name, field, set);
+        emit_field(output, name, field, parents.as_slice());
         output.push_str("---\n\n");
     }
 
     // Generate all the sub-sets.
     for (set_name, sub_set) in &sets {
-        generate_set(output, &Set::Named(set_name, *sub_set, set.level() + 1));
+        generate_set(
+            output,
+            Set::Named {
+                name: set_name.to_string(),
+                set: *sub_set,
+            },
+            parents,
+        );
     }
+
+    parents.pop();
 }
 
-enum Set<'a> {
+enum Set {
     Toplevel(OptionSet),
-    Named(&'a str, OptionSet, u32),
+    Named { name: String, set: OptionSet },
 }
 
-impl<'a> Set<'a> {
-    fn name(&self) -> Option<&'a str> {
+impl Set {
+    fn name(&self) -> Option<&str> {
         match self {
             Set::Toplevel(_) => None,
-            Set::Named(name, _, _) => Some(name),
-        }
-    }
-
-    fn title(&self) -> &'a str {
-        match self {
-            Set::Toplevel(_) => "Top-level",
-            Set::Named(name, _, _) => name,
+            Set::Named { name, .. } => Some(name),
         }
     }
 
     fn metadata(&self) -> &OptionSet {
         match self {
             Set::Toplevel(set) => set,
-            Set::Named(_, set, _) => set,
-        }
-    }
-
-    fn level(&self) -> u32 {
-        match self {
-            Set::Toplevel(_) => 0,
-            Set::Named(_, _, level) => *level,
+            Set::Named { set, .. } => set,
         }
     }
 }
 
-fn emit_field(output: &mut String, name: &str, field: &OptionField, parent_set: &Set) {
-    let header_level = if parent_set.level() < 2 {
-        "####"
-    } else {
-        "#####"
-    };
+fn emit_field(output: &mut String, name: &str, field: &OptionField, parents: &[Set]) {
+    let header_level = if parents.is_empty() { "####" } else { "#####" };
+    let parents_anchor = parents.iter().filter_map(|parent| parent.name()).join("_");
+
+    if parents_anchor.is_empty() {
+        output.push_str(&format!(
+            "{header_level} [`{name}`](#{name}) {{: #{name} }}\n"
+        ));
+    } else {
+        output.push_str(&format!(
+            "{header_level} [`{name}`](#{parents_anchor}_{name}) {{: #{parents_anchor}_{name} }}\n"
+        ));
 
-    // if there's a set name, we need to add it to the anchor
-    if let Some(set_name) = parent_set.name() {
         // the anchor used to just be the name, but now it's the group name
         // for backwards compatibility, we need to keep the old anchor
         output.push_str(&format!("<span id=\"{name}\"></span>\n"));
-
-        output.push_str(&format!(
-            "{header_level} [`{name}`](#{set_name}-{name}) {{: #{set_name}-{name} }}\n"
-        ));
-    } else {
-        output.push_str(&format!("{header_level} [`{name}`](#{name})\n"));
     }
+
     output.push('\n');
 
     if let Some(deprecated) = &field.deprecated {
@@ -129,12 +139,12 @@ fn emit_field(output: &mut String, name: &str, field: &OptionField, parent_set:
     output.push_str("**Example usage**:\n\n");
     output.push_str(&format_tab(
         "pyproject.toml",
-        &format_header(field.scope, parent_set, ConfigurationFile::PyprojectToml),
+        &format_header(field.scope, parents, ConfigurationFile::PyprojectToml),
         field.example,
     ));
     output.push_str(&format_tab(
         "ruff.toml",
-        &format_header(field.scope, parent_set, ConfigurationFile::RuffToml),
+        &format_header(field.scope, parents, ConfigurationFile::RuffToml),
         field.example,
     ));
     output.push('\n');
@@ -152,52 +162,22 @@ fn format_tab(tab_name: &str, header: &str, content: &str) -> String {
 /// Format the TOML header for the example usage for a given option.
 ///
 /// For example: `[tool.ruff.format]` or `[tool.ruff.lint.isort]`.
-fn format_header(
-    scope: Option<&str>,
-    parent_set: &Set,
-    configuration: ConfigurationFile,
-) -> String {
-    match configuration {
-        ConfigurationFile::PyprojectToml => {
-            let mut header = if let Some(set_name) = parent_set.name() {
-                if set_name == "format" {
-                    String::from("tool.ruff.format")
-                } else {
-                    format!("tool.ruff.lint.{set_name}")
-                }
-            } else {
-                "tool.ruff".to_string()
-            };
-            if let Some(scope) = scope {
-                if !header.is_empty() {
-                    header.push('.');
-                }
-                header.push_str(scope);
-            }
-            format!("[{header}]")
-        }
-        ConfigurationFile::RuffToml => {
-            let mut header = if let Some(set_name) = parent_set.name() {
-                if set_name == "format" {
-                    String::from("format")
-                } else {
-                    format!("lint.{set_name}")
-                }
-            } else {
-                String::new()
-            };
-            if let Some(scope) = scope {
-                if !header.is_empty() {
-                    header.push('.');
-                }
-                header.push_str(scope);
-            }
-            if header.is_empty() {
-                String::new()
-            } else {
-                format!("[{header}]")
-            }
-        }
+fn format_header(scope: Option<&str>, parents: &[Set], configuration: ConfigurationFile) -> String {
+    let tool_parent = match configuration {
+        ConfigurationFile::PyprojectToml => Some("tool.ruff"),
+        ConfigurationFile::RuffToml => None,
+    };
+
+    let header = tool_parent
+        .into_iter()
+        .chain(parents.iter().filter_map(|parent| parent.name()))
+        .chain(scope)
+        .join(".");
+
+    if header.is_empty() {
+        String::new()
+    } else {
+        format!("[{header}]")
     }
 }
 

crates/ruff_dev/src/generate_rules_table.rs

@@ -3,6 +3,7 @@
 //! Used for <https://docs.astral.sh/ruff/rules/>.
 
 use itertools::Itertools;
+use ruff_linter::codes::RuleGroup;
 use std::borrow::Cow;
 use strum::IntoEnumIterator;
 
@@ -14,6 +15,10 @@ use ruff_workspace::options_base::OptionsMetadata;
 
 const FIX_SYMBOL: &str = "🛠️";
 const PREVIEW_SYMBOL: &str = "🧪";
+const REMOVED_SYMBOL: &str = "❌";
+const WARNING_SYMBOL: &str = "⚠️";
+const STABLE_SYMBOL: &str = "✔️";
+const SPACER: &str = "&nbsp;&nbsp;&nbsp;&nbsp;";
 
 fn generate_table(table_out: &mut String, rules: impl IntoIterator<Item = Rule>, linter: &Linter) {
     table_out.push_str("| Code | Name | Message | |");
@@ -21,20 +26,33 @@ fn generate_table(table_out: &mut String, rules: impl IntoIterator<Item = Rule>,
     table_out.push_str("| ---- | ---- | ------- | ------: |");
     table_out.push('\n');
     for rule in rules {
+        let status_token = match rule.group() {
+            RuleGroup::Removed => {
+                format!("<span title='Rule has been removed'>{REMOVED_SYMBOL}</span>")
+            }
+            RuleGroup::Deprecated => {
+                format!("<span title='Rule has been deprecated'>{WARNING_SYMBOL}</span>")
+            }
+            #[allow(deprecated)]
+            RuleGroup::Preview | RuleGroup::Nursery => {
+                format!("<span title='Rule is in preview'>{PREVIEW_SYMBOL}</span>")
+            }
+            RuleGroup::Stable => {
+                // A full opacity checkmark is a bit aggressive for indicating stable
+                format!("<span title='Rule is stable' style='opacity: 0.6'>{STABLE_SYMBOL}</span>")
+            }
+        };
+
         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 title='Automatic fix not available' style='opacity: 0.1' aria-hidden='true'>{FIX_SYMBOL}</span>")
             }
         };
-        let preview_token = if rule.is_preview() || rule.is_nursery() {
-            format!("<span title='Rule is in preview'>{PREVIEW_SYMBOL}</span>")
-        } else {
-            format!("<span style='opacity: 0.1' aria-hidden='true'>{PREVIEW_SYMBOL}</span>")
-        };
-        let status_token = format!("{fix_token} {preview_token}");
+
+        let tokens = format!("{status_token} {fix_token}");
 
         let rule_name = rule.as_ref();
 
@@ -48,9 +66,20 @@ fn generate_table(table_out: &mut String, rules: impl IntoIterator<Item = Rule>,
             Cow::Borrowed(message)
         };
 
+        // Start and end of style spans
+        let mut ss = "";
+        let mut se = "";
+        if rule.is_removed() {
+            ss = "<span style='opacity: 0.5', title='This rule has been removed'>";
+            se = "</span>";
+        } else if rule.is_deprecated() {
+            ss = "<span style='opacity: 0.8', title='This rule has been deprecated'>";
+            se = "</span>";
+        }
+
         #[allow(clippy::or_fun_call)]
         table_out.push_str(&format!(
-            "| {0}{1} {{ #{0}{1} }} | {2} | {3} | {4} |",
+            "| {ss}{0}{1}{se} {{ #{0}{1} }} | {ss}{2}{se} | {ss}{3}{se} | {ss}{4}{se} |",
             linter.common_prefix(),
             linter.code_for_rule(rule).unwrap(),
             rule.explanation()
@@ -58,7 +87,7 @@ fn generate_table(table_out: &mut String, rules: impl IntoIterator<Item = Rule>,
                 .then_some(format_args!("[{rule_name}](rules/{rule_name}.md)"))
                 .unwrap_or(format_args!("{rule_name}")),
             message,
-            status_token,
+            tokens,
         ));
         table_out.push('\n');
     }
@@ -69,15 +98,33 @@ pub(crate) fn generate() -> String {
     // Generate the table string.
     let mut table_out = String::new();
 
-    table_out.push_str(&format!(
-        "The {FIX_SYMBOL} emoji indicates that a rule is automatically fixable by the `--fix` command-line option."));
-    table_out.push('\n');
+    table_out.push_str("### Legend");
     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)."
+        "{SPACER}{STABLE_SYMBOL}{SPACER} The rule is stable."
     ));
-    table_out.push('\n');
+    table_out.push_str("<br />");
+
+    table_out.push_str(&format!(
+        "{SPACER}{PREVIEW_SYMBOL}{SPACER} The rule is unstable and is in [\"preview\"](faq.md#what-is-preview)."
+    ));
+    table_out.push_str("<br />");
+
+    table_out.push_str(&format!(
+        "{SPACER}{WARNING_SYMBOL}{SPACER} The rule has been deprecated and will be removed in a future release."
+    ));
+    table_out.push_str("<br />");
+
+    table_out.push_str(&format!(
+        "{SPACER}{REMOVED_SYMBOL}{SPACER} The rule has been removed only the documentation is available."
+    ));
+    table_out.push_str("<br />");
+
+    table_out.push_str(&format!(
+        "{SPACER}{FIX_SYMBOL}{SPACER} The rule is automatically fixable by the `--fix` command-line option."
+    ));
+    table_out.push_str("<br />");
     table_out.push('\n');
 
     for linter in Linter::iter() {
@@ -133,8 +180,22 @@ pub(crate) fn generate() -> String {
             .map(|rule| (rule.upstream_category(&linter), rule))
             .into_group_map();
 
+        let mut rules_by_upstream_category: Vec<_> = rules_by_upstream_category.iter().collect();
+
+        // Sort the upstream categories alphabetically by prefix.
+        rules_by_upstream_category.sort_by(|(a, _), (b, _)| {
+            a.as_ref()
+                .map(|category| category.prefix)
+                .unwrap_or_default()
+                .cmp(
+                    b.as_ref()
+                        .map(|category| category.prefix)
+                        .unwrap_or_default(),
+                )
+        });
+
         if rules_by_upstream_category.len() > 1 {
-            for (opt, rules) in &rules_by_upstream_category {
+            for (opt, rules) in rules_by_upstream_category {
                 if opt.is_some() {
                     let UpstreamCategoryAndPrefix { category, prefix } = opt.unwrap();
                     table_out.push_str(&format!("#### {category} ({prefix})"));

crates/ruff_dev/src/main.rs

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

crates/ruff_diagnostics/Cargo.toml

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

crates/ruff_diagnostics/src/diagnostic.rs

@@ -71,6 +71,14 @@ impl Diagnostic {
         }
     }
 
+    /// Consumes `self` and returns a new `Diagnostic` with the given parent node.
+    #[inline]
+    #[must_use]
+    pub fn with_parent(mut self, parent: TextSize) -> Self {
+        self.set_parent(parent);
+        self
+    }
+
     /// Set the location of the diagnostic's parent node.
     #[inline]
     pub fn set_parent(&mut self, parent: TextSize) {

crates/ruff_diagnostics/src/violation.rs

@@ -25,11 +25,6 @@ pub trait Violation: Debug + PartialEq + Eq {
     /// The message used to describe the violation.
     fn message(&self) -> String;
 
-    /// The explanation used in documentation and elsewhere.
-    fn explanation() -> Option<&'static str> {
-        None
-    }
-
     // TODO(micha): Move `fix_title` to `Fix`, add new `advice` method that is shown as an advice.
     // Change the `Diagnostic` renderer to show the advice, and render the fix message after the `Suggested fix: <here>`
 
@@ -50,11 +45,6 @@ pub trait AlwaysFixableViolation: Debug + PartialEq + Eq {
     /// The message used to describe the violation.
     fn message(&self) -> String;
 
-    /// The explanation used in documentation and elsewhere.
-    fn explanation() -> Option<&'static str> {
-        None
-    }
-
     /// The title displayed for the available fix.
     fn fix_title(&self) -> String;
 
@@ -71,10 +61,6 @@ impl<V: AlwaysFixableViolation> Violation for V {
         <Self as AlwaysFixableViolation>::message(self)
     }
 
-    fn explanation() -> Option<&'static str> {
-        <Self as AlwaysFixableViolation>::explanation()
-    }
-
     fn fix_title(&self) -> Option<String> {
         Some(<Self as AlwaysFixableViolation>::fix_title(self))
     }

crates/ruff_formatter/Cargo.toml

@@ -24,7 +24,6 @@ tracing = { workspace = true }
 unicode-width = { workspace = true }
 
 [dev-dependencies]
-insta = { workspace = true }
 
 [features]
 serde = ["dep:serde", "ruff_text_size/serde"]

crates/ruff_formatter/src/buffer.rs

@@ -37,7 +37,7 @@ pub trait Buffer {
     #[doc(hidden)]
     fn elements(&self) -> &[FormatElement];
 
-    /// Glue for usage of the [`write!`] macro with implementors of this trait.
+    /// Glue for usage of the [`write!`] macro with implementers of this trait.
     ///
     /// This method should generally not be invoked manually, but rather through the [`write!`] macro itself.
     ///

crates/ruff_formatter/src/builders.rs

@@ -138,7 +138,7 @@ pub const fn empty_line() -> Line {
 ///
 /// # Examples
 ///
-/// The line breaks are emitted as spaces if the enclosing `Group` fits on a a single line:
+/// The line breaks are emitted as spaces if the enclosing `Group` fits on a single line:
 /// ```
 /// use ruff_formatter::{format, format_args};
 /// use ruff_formatter::prelude::*;
@@ -308,11 +308,8 @@ impl std::fmt::Debug for Token {
 /// assert_eq!(printed.as_code(), r#""Hello 'Ruff'""#);
 /// assert_eq!(printed.sourcemap(), [
 ///     SourceMarker { source: TextSize::new(0), dest: TextSize::new(0) },
-///     SourceMarker { source: TextSize::new(0), dest: TextSize::new(7) },
 ///     SourceMarker { source: TextSize::new(8), dest: TextSize::new(7) },
-///     SourceMarker { source: TextSize::new(8), dest: TextSize::new(13) },
 ///     SourceMarker { source: TextSize::new(14), dest: TextSize::new(13) },
-///     SourceMarker { source: TextSize::new(14), dest: TextSize::new(14) },
 ///     SourceMarker { source: TextSize::new(20), dest: TextSize::new(14) },
 /// ]);
 ///
@@ -340,18 +337,18 @@ impl<Context> Format<Context> for SourcePosition {
     }
 }
 
-/// Creates a text from a dynamic string with its optional start-position in the source document.
+/// Creates a text from a dynamic string.
+///
 /// This is done by allocating a new string internally.
-pub fn text(text: &str, position: Option<TextSize>) -> Text {
+pub fn text(text: &str) -> Text {
     debug_assert_no_newlines(text);
 
-    Text { text, position }
+    Text { text }
 }
 
 #[derive(Eq, PartialEq)]
 pub struct Text<'a> {
     text: &'a str,
-    position: Option<TextSize>,
 }
 
 impl<Context> Format<Context> for Text<'_>
@@ -359,10 +356,6 @@ where
     Context: FormatContext,
 {
     fn fmt(&self, f: &mut Formatter<Context>) -> FormatResult<()> {
-        if let Some(position) = self.position {
-            source_position(position).fmt(f)?;
-        }
-
         f.write_element(FormatElement::Text {
             text: self.text.to_string().into_boxed_str(),
             text_width: TextWidth::from_text(self.text, f.options().indent_width()),
@@ -2292,7 +2285,7 @@ impl<Context, T> std::fmt::Debug for FormatWith<Context, T> {
 ///                 let mut join = f.join_with(&separator);
 ///
 ///                 for item in &self.items {
-///                     join.entry(&format_with(|f| write!(f, [text(item, None)])));
+///                     join.entry(&format_with(|f| write!(f, [text(item)])));
 ///                 }
 ///                 join.finish()
 ///             })),
@@ -2377,7 +2370,7 @@ where
 /// let mut count = 0;
 ///
 /// let value = format_once(|f| {
-///     write!(f, [text(&std::format!("Formatted {count}."), None)])
+///     write!(f, [text(&std::format!("Formatted {count}."))])
 /// });
 ///
 /// format!(SimpleFormatContext::default(), [value]).expect("Formatting once works fine");

crates/ruff_formatter/src/format_element/document.rs

@@ -346,10 +346,7 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                 }
 
                 FormatElement::SourcePosition(position) => {
-                    write!(
-                        f,
-                        [text(&std::format!("source_position({position:?})"), None)]
-                    )?;
+                    write!(f, [text(&std::format!("source_position({position:?})"))])?;
                 }
 
                 FormatElement::LineSuffixBoundary => {
@@ -360,7 +357,7 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                     write!(f, [token("best_fitting(")])?;
 
                     if *mode != BestFittingMode::FirstLine {
-                        write!(f, [text(&std::format!("mode: {mode:?}, "), None)])?;
+                        write!(f, [text(&std::format!("mode: {mode:?}, "))])?;
                     }
 
                     write!(f, [token("[")])?;
@@ -392,17 +389,14 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                             write!(
                                 f,
                                 [
-                                    text(&std::format!("<interned {index}>"), None),
+                                    text(&std::format!("<interned {index}>")),
                                     space(),
                                     &&**interned,
                                 ]
                             )?;
                         }
                         Some(reference) => {
-                            write!(
-                                f,
-                                [text(&std::format!("<ref interned *{reference}>"), None)]
-                            )?;
+                            write!(f, [text(&std::format!("<ref interned *{reference}>"))])?;
                         }
                     }
                 }
@@ -421,7 +415,7 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                                     f,
                                     [
                                         token("<END_TAG_WITHOUT_START<"),
-                                        text(&std::format!("{:?}", tag.kind()), None),
+                                        text(&std::format!("{:?}", tag.kind())),
                                         token(">>"),
                                     ]
                                 )?;
@@ -436,9 +430,9 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                                         token(")"),
                                         soft_line_break_or_space(),
                                         token("ERROR<START_END_TAG_MISMATCH<start: "),
-                                        text(&std::format!("{start_kind:?}"), None),
+                                        text(&std::format!("{start_kind:?}")),
                                         token(", end: "),
-                                        text(&std::format!("{:?}", tag.kind()), None),
+                                        text(&std::format!("{:?}", tag.kind())),
                                         token(">>")
                                     ]
                                 )?;
@@ -470,7 +464,7 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                                 f,
                                 [
                                     token("align("),
-                                    text(&count.to_string(), None),
+                                    text(&count.to_string()),
                                     token(","),
                                     space(),
                                 ]
@@ -482,7 +476,7 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                                 f,
                                 [
                                     token("line_suffix("),
-                                    text(&std::format!("{reserved_width:?}"), None),
+                                    text(&std::format!("{reserved_width:?}")),
                                     token(","),
                                     space(),
                                 ]
@@ -499,11 +493,7 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                             if let Some(group_id) = group.id() {
                                 write!(
                                     f,
-                                    [
-                                        text(&std::format!("\"{group_id:?}\""), None),
-                                        token(","),
-                                        space(),
-                                    ]
+                                    [text(&std::format!("\"{group_id:?}\"")), token(","), space(),]
                                 )?;
                             }
 
@@ -524,11 +514,7 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                             if let Some(group_id) = id {
                                 write!(
                                     f,
-                                    [
-                                        text(&std::format!("\"{group_id:?}\""), None),
-                                        token(","),
-                                        space(),
-                                    ]
+                                    [text(&std::format!("\"{group_id:?}\"")), token(","), space(),]
                                 )?;
                             }
                         }
@@ -561,7 +547,7 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                                 f,
                                 [
                                     token("indent_if_group_breaks("),
-                                    text(&std::format!("\"{id:?}\""), None),
+                                    text(&std::format!("\"{id:?}\"")),
                                     token(","),
                                     space(),
                                 ]
@@ -581,11 +567,7 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                             if let Some(group_id) = condition.group_id {
                                 write!(
                                     f,
-                                    [
-                                        text(&std::format!("\"{group_id:?}\""), None),
-                                        token(","),
-                                        space(),
-                                    ]
+                                    [text(&std::format!("\"{group_id:?}\"")), token(","), space()]
                                 )?;
                             }
                         }
@@ -595,7 +577,7 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                                 f,
                                 [
                                     token("label("),
-                                    text(&std::format!("\"{label_id:?}\""), None),
+                                    text(&std::format!("\"{label_id:?}\"")),
                                     token(","),
                                     space(),
                                 ]
@@ -664,7 +646,7 @@ impl Format<IrFormatContext<'_>> for &[FormatElement] {
                     ContentArrayEnd,
                     token(")"),
                     soft_line_break_or_space(),
-                    text(&std::format!("<START_WITHOUT_END<{top:?}>>"), None),
+                    text(&std::format!("<START_WITHOUT_END<{top:?}>>")),
                 ]
             )?;
         }
@@ -807,7 +789,7 @@ impl Format<IrFormatContext<'_>> for Condition {
                 f,
                 [
                     token("if_group_fits_on_line("),
-                    text(&std::format!("\"{id:?}\""), None),
+                    text(&std::format!("\"{id:?}\"")),
                     token(")")
                 ]
             ),
@@ -816,7 +798,7 @@ impl Format<IrFormatContext<'_>> for Condition {
                 f,
                 [
                     token("if_group_breaks("),
-                    text(&std::format!("\"{id:?}\""), None),
+                    text(&std::format!("\"{id:?}\"")),
                     token(")")
                 ]
             ),

crates/ruff_formatter/src/format_extensions.rs

@@ -32,7 +32,7 @@ pub trait MemoizeFormat<Context> {
     ///         let value = self.value.get();
     ///         self.value.set(value + 1);
     ///
-    ///         write!(f, [text(&std::format!("Formatted {value} times."), None)])
+    ///         write!(f, [text(&std::format!("Formatted {value} times."))])
     ///     }
     /// }
     ///
@@ -110,7 +110,7 @@ where
     ///         write!(f, [
     ///             token("Count:"),
     ///             space(),
-    ///             text(&std::format!("{current}"), None),
+    ///             text(&std::format!("{current}")),
     ///             hard_line_break()
     ///         ])?;
     ///

crates/ruff_formatter/src/lib.rs

@@ -41,7 +41,7 @@ use std::marker::PhantomData;
 use std::num::{NonZeroU16, NonZeroU8, TryFromIntError};
 
 use crate::format_element::document::Document;
-use crate::printer::{Printer, PrinterOptions, SourceMapGeneration};
+use crate::printer::{Printer, PrinterOptions};
 pub use arguments::{Argument, Arguments};
 pub use buffer::{
     Buffer, BufferExtensions, BufferSnapshot, Inspect, RemoveSoftLinesBuffer, VecBuffer,
@@ -269,7 +269,6 @@ impl FormatOptions for SimpleFormatOptions {
             line_width: self.line_width,
             indent_style: self.indent_style,
             indent_width: self.indent_width,
-            source_map_generation: SourceMapGeneration::Enabled,
             ..PrinterOptions::default()
         }
     }
@@ -433,28 +432,40 @@ impl Printed {
         std::mem::take(&mut self.verbatim_ranges)
     }
 
-    /// Slices the formatted code to the sub-slices that covers the passed `source_range`.
+    /// Slices the formatted code to the sub-slices that covers the passed `source_range` in `source`.
     ///
     /// The implementation uses the source map generated during formatting to find the closest range
     /// in the formatted document that covers `source_range` or more. The returned slice
     /// matches the `source_range` exactly (except indent, see below) if the formatter emits [`FormatElement::SourcePosition`] for
     /// the range's offsets.
     ///
+    /// ## Indentation
+    /// The indentation before `source_range.start` is replaced with the indentation returned by the formatter
+    /// to fix up incorrectly intended code.
+    ///
     /// Returns the entire document if the source map is empty.
+    ///
+    /// # Panics
+    /// If `source_range` points to offsets that are not in the bounds of `source`.
     #[must_use]
-    pub fn slice_range(self, source_range: TextRange) -> PrintedRange {
+    pub fn slice_range(self, source_range: TextRange, source: &str) -> PrintedRange {
         let mut start_marker: Option<SourceMarker> = None;
         let mut end_marker: Option<SourceMarker> = None;
 
         // Note: The printer can generate multiple source map entries for the same source position.
         // For example if you have:
+        // * token("a + b")
         // * `source_position(276)`
-        // * `token("def")`
-        // * `token("foo")`
-        // * `source_position(284)`
-        // The printer uses the source position 276 for both the tokens `def` and `foo` because that's the only position it knows of.
+        // * `token(")")`
+        // * `source_position(276)`
+        // *  `hard_line_break`
+        // The printer uses the source position 276 for both the tokens `)` and the `\n` because
+        // there were multiple `source_position` entries in the IR with the same offset.
+        // This can happen if multiple nodes start or end at the same position. A common example
+        // for this are expressions and expression statement that always end at the same offset.
         //
-        // Warning: Source markers are often emitted sorted by their source position but it's not guaranteed.
+        // Warning: Source markers are often emitted sorted by their source position but it's not guaranteed
+        // and depends on the emitted `IR`.
         // They are only guaranteed to be sorted in increasing order by their destination position.
         for marker in self.sourcemap {
             // Take the closest start marker, but skip over start_markers that have the same start.
@@ -471,17 +482,44 @@ impl Printed {
             }
         }
 
-        let start = start_marker.map(|marker| marker.dest).unwrap_or_default();
-        let end = end_marker.map_or_else(|| self.code.text_len(), |marker| marker.dest);
-        let code_range = TextRange::new(start, end);
+        let (source_start, formatted_start) = start_marker
+            .map(|marker| (marker.source, marker.dest))
+            .unwrap_or_default();
+
+        let (source_end, formatted_end) = end_marker
+            .map_or((source.text_len(), self.code.text_len()), |marker| {
+                (marker.source, marker.dest)
+            });
+
+        let source_range = TextRange::new(source_start, source_end);
+        let formatted_range = TextRange::new(formatted_start, formatted_end);
+
+        // Extend both ranges to include the indentation
+        let source_range = extend_range_to_include_indent(source_range, source);
+        let formatted_range = extend_range_to_include_indent(formatted_range, &self.code);
 
         PrintedRange {
-            code: self.code[code_range].to_string(),
+            code: self.code[formatted_range].to_string(),
             source_range,
         }
     }
 }
 
+/// Extends `range` backwards (by reducing `range.start`) to include any directly preceding whitespace (`\t` or ` `).
+///
+/// # Panics
+/// If `range.start` is out of `source`'s bounds.
+fn extend_range_to_include_indent(range: TextRange, source: &str) -> TextRange {
+    let whitespace_len: TextSize = source[..usize::from(range.start())]
+        .chars()
+        .rev()
+        .take_while(|c| matches!(c, ' ' | '\t'))
+        .map(TextLen::text_len)
+        .sum();
+
+    TextRange::new(range.start() - whitespace_len, range.end())
+}
+
 #[derive(Debug, Clone, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
@@ -507,6 +545,10 @@ impl PrintedRange {
         &self.code
     }
 
+    pub fn into_code(self) -> String {
+        self.code
+    }
+
     /// The range the formatted code corresponds to in the source document.
     pub fn source_range(&self) -> TextRange {
         self.source_range
@@ -537,7 +579,7 @@ pub type FormatResult<F> = Result<F, FormatError>;
 /// impl Format<SimpleFormatContext> for Paragraph {
 ///     fn fmt(&self, f: &mut Formatter<SimpleFormatContext>) -> FormatResult<()> {
 ///         write!(f, [
-///             text(&self.0, None),
+///             text(&self.0),
 ///             hard_line_break(),
 ///         ])
 ///     }

crates/ruff_formatter/src/printer/line_suffixes.rs

@@ -21,8 +21,7 @@ impl<'a> LineSuffixes<'a> {
     /// Takes all the pending line suffixes.
     pub(super) fn take_pending<'l>(
         &'l mut self,
-    ) -> impl Iterator<Item = LineSuffixEntry<'a>> + DoubleEndedIterator + 'l + ExactSizeIterator
-    {
+    ) -> impl DoubleEndedIterator<Item = LineSuffixEntry<'a>> + 'l + ExactSizeIterator {
         self.suffixes.drain(..)
     }
 

crates/ruff_formatter/src/printer/mod.rs

@@ -4,7 +4,7 @@ use drop_bomb::DebugDropBomb;
 use unicode_width::UnicodeWidthChar;
 
 pub use printer_options::*;
-use ruff_text_size::{Ranged, TextLen, TextSize};
+use ruff_text_size::{TextLen, TextSize};
 
 use crate::format_element::document::Document;
 use crate::format_element::tag::{Condition, GroupMode};
@@ -76,6 +76,9 @@ impl<'a> Printer<'a> {
             }
         }
 
+        // Push any pending marker
+        self.push_marker();
+
         Ok(Printed::new(
             self.state.buffer,
             None,
@@ -97,42 +100,38 @@ impl<'a> Printer<'a> {
         let args = stack.top();
 
         match element {
-            FormatElement::Space => self.print_text(Text::Token(" "), None),
-            FormatElement::Token { text } => self.print_text(Text::Token(text), None),
-            FormatElement::Text { text, text_width } => self.print_text(
-                Text::Text {
-                    text,
-                    text_width: *text_width,
-                },
-                None,
-            ),
+            FormatElement::Space => self.print_text(Text::Token(" ")),
+            FormatElement::Token { text } => self.print_text(Text::Token(text)),
+            FormatElement::Text { text, text_width } => self.print_text(Text::Text {
+                text,
+                text_width: *text_width,
+            }),
             FormatElement::SourceCodeSlice { slice, text_width } => {
                 let text = slice.text(self.source_code);
-                self.print_text(
-                    Text::Text {
-                        text,
-                        text_width: *text_width,
-                    },
-                    Some(slice.range()),
-                );
+                self.print_text(Text::Text {
+                    text,
+                    text_width: *text_width,
+                });
             }
             FormatElement::Line(line_mode) => {
                 if args.mode().is_flat()
                     && matches!(line_mode, LineMode::Soft | LineMode::SoftOrSpace)
                 {
                     if line_mode == &LineMode::SoftOrSpace {
-                        self.print_text(Text::Token(" "), None);
+                        self.print_text(Text::Token(" "));
                     }
                 } else if self.state.line_suffixes.has_pending() {
                     self.flush_line_suffixes(queue, stack, Some(element));
                 } else {
                     // Only print a newline if the current line isn't already empty
                     if self.state.line_width > 0 {
+                        self.push_marker();
                         self.print_char('\n');
                     }
 
                     // Print a second line break if this is an empty line
                     if line_mode == &LineMode::Empty {
+                        self.push_marker();
                         self.print_char('\n');
                     }
 
@@ -145,14 +144,11 @@ impl<'a> Printer<'a> {
             }
 
             FormatElement::SourcePosition(position) => {
-                self.state.source_position = *position;
                 // The printer defers printing indents until the next text
                 // is printed. Pushing the marker now would mean that the
                 // mapped range includes the indent range, which we don't want.
-                // Only add a marker if we're not in an indented context, e.g. at the end of the file.
-                if self.state.pending_indent.is_empty() {
-                    self.push_marker();
-                }
+                // Queue the source map position and emit it when printing the next character
+                self.state.pending_source_position = Some(*position);
             }
 
             FormatElement::LineSuffixBoundary => {
@@ -444,7 +440,7 @@ impl<'a> Printer<'a> {
         Ok(print_mode)
     }
 
-    fn print_text(&mut self, text: Text, source_range: Option<TextRange>) {
+    fn print_text(&mut self, text: Text) {
         if !self.state.pending_indent.is_empty() {
             let (indent_char, repeat_count) = match self.options.indent_style() {
                 IndentStyle::Tab => ('\t', 1),
@@ -467,19 +463,6 @@ impl<'a> Printer<'a> {
             }
         }
 
-        // Insert source map markers before and after the token
-        //
-        // If the token has source position information the start marker
-        // will use the start position of the original token, and the end
-        // marker will use that position + the text length of the token
-        //
-        // If the token has no source position (was created by the formatter)
-        // both the start and end marker will use the last known position
-        // in the input source (from state.source_position)
-        if let Some(range) = source_range {
-            self.state.source_position = range.start();
-        }
-
         self.push_marker();
 
         match text {
@@ -502,21 +485,15 @@ impl<'a> Printer<'a> {
                 }
             }
         }
-
-        if let Some(range) = source_range {
-            self.state.source_position = range.end();
-        }
-
-        self.push_marker();
     }
 
     fn push_marker(&mut self) {
-        if self.options.source_map_generation.is_disabled() {
+        let Some(source_position) = self.state.pending_source_position.take() else {
             return;
-        }
+        };
 
         let marker = SourceMarker {
-            source: self.state.source_position,
+            source: source_position,
             dest: self.state.buffer.text_len(),
         };
 
@@ -897,7 +874,7 @@ enum FillPairLayout {
 struct PrinterState<'a> {
     buffer: String,
     source_markers: Vec<SourceMarker>,
-    source_position: TextSize,
+    pending_source_position: Option<TextSize>,
     pending_indent: Indention,
     measured_group_fits: bool,
     line_width: u32,
@@ -1752,7 +1729,7 @@ a",
         let result = format_with_options(
             &format_args![
                 token("function main() {"),
-                block_indent(&text("let x = `This is a multiline\nstring`;", None)),
+                block_indent(&text("let x = `This is a multiline\nstring`;")),
                 token("}"),
                 hard_line_break()
             ],
@@ -1769,7 +1746,7 @@ a",
     fn it_breaks_a_group_if_a_string_contains_a_newline() {
         let result = format(&FormatArrayElements {
             items: vec![
-                &text("`This is a string spanning\ntwo lines`", None),
+                &text("`This is a string spanning\ntwo lines`"),
                 &token("\"b\""),
             ],
         });

crates/ruff_formatter/src/printer/printer_options/mod.rs

@@ -14,10 +14,6 @@ pub struct PrinterOptions {
 
     /// The type of line ending to apply to the printed input
     pub line_ending: LineEnding,
-
-    /// Whether the printer should build a source map that allows mapping positions in the source document
-    /// to positions in the formatted document.
-    pub source_map_generation: SourceMapGeneration,
 }
 
 impl<'a, O> From<&'a O> for PrinterOptions

crates/ruff_formatter/src/printer/queue.rs

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

crates/ruff_index/Cargo.toml

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

crates/ruff_linter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.1.15"
+version = "0.4.2"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
@@ -15,7 +15,6 @@ license = { workspace = true }
 [dependencies]
 ruff_cache = { path = "../ruff_cache" }
 ruff_diagnostics = { path = "../ruff_diagnostics", features = ["serde"] }
-ruff_index = { path = "../ruff_index" }
 ruff_notebook = { path = "../ruff_notebook" }
 ruff_macros = { path = "../ruff_macros" }
 ruff_python_ast = { path = "../ruff_python_ast", features = ["serde"] }
@@ -60,7 +59,6 @@ regex = { workspace = true }
 result-like = { workspace = true }
 rustc-hash = { workspace = true }
 schemars = { workspace = true, optional = true }
-semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 similar = { workspace = true }
@@ -76,11 +74,9 @@ url = { workspace = true }
 
 [dev-dependencies]
 insta = { workspace = true }
-pretty_assertions = { workspace = true }
 test-case = { workspace = true }
 # Disable colored output in tests
 colored = { workspace = true, features = ["no-color"] }
-tempfile = { workspace = true }
 
 [features]
 default = []

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

@@ -28,3 +28,40 @@ dictionary = {
 }
 
 #import os  # noqa
+
+# case 1:
+# try:
+# try:  # with comment
+# try: print()
+# except:
+# except Foo:
+# except Exception as e: print(e)
+
+
+# Script tag without an opening tag (Error)
+
+# requires-python = ">=3.11"
+# dependencies = [
+#   "requests<3",
+#   "rich",
+# ]
+# ///
+
+# Script tag (OK)
+
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#   "requests<3",
+#   "rich",
+# ]
+# ///
+
+# Script tag without a closing tag (OK)
+
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#   "requests<3",
+#   "rich",
+# ]

crates/ruff_linter/resources/test/fixtures/flake8_bandit/S104.py

@@ -18,3 +18,7 @@ func("0.0.0.0")
 def my_func():
     x = "0.0.0.0"
     print(x)
+
+
+# Implicit string concatenation
+"0.0.0.0" f"0.0.0.0{expr}0.0.0.0"

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

@@ -18,6 +18,13 @@ with open("/dev/shm/unit/test", "w") as f:
 with open("/foo/bar", "w") as f:
     f.write("def")
 
+# Implicit string concatenation
+with open("/tmp/" "abc", "w") as f:
+    f.write("def")
+
+with open("/tmp/abc" f"/tmp/abc", "w") as f:
+    f.write("def")
+
 # Using `tempfile` module should be ok
 import tempfile
 from tempfile import TemporaryDirectory

crates/ruff_linter/resources/test/fixtures/flake8_bandit/S308.py

@@ -0,0 +1,22 @@
+from django.utils.safestring import mark_safe
+
+
+def some_func():
+    return mark_safe('<script>alert("evil!")</script>')
+
+
+@mark_safe
+def some_func():
+    return '<script>alert("evil!")</script>'
+
+
+from django.utils.html import mark_safe
+
+
+def some_func():
+    return mark_safe('<script>alert("evil!")</script>')
+
+
+@mark_safe
+def some_func():
+    return '<script>alert("evil!")</script>'

crates/ruff_linter/resources/test/fixtures/flake8_bandit/S310.py

@@ -17,3 +17,9 @@ urllib.request.URLopener().open(fullurl='http://www.google.com')
 urllib.request.URLopener().open('http://www.google.com')
 urllib.request.URLopener().open('file:///foo/bar/baz')
 urllib.request.URLopener().open(url)
+
+urllib.request.urlopen(url=urllib.request.Request('http://www.google.com'))
+urllib.request.urlopen(url=urllib.request.Request('http://www.google.com'), **kwargs)
+urllib.request.urlopen(urllib.request.Request('http://www.google.com'))
+urllib.request.urlopen(urllib.request.Request('file:///foo/bar/baz'))
+urllib.request.urlopen(urllib.request.Request(url))

crates/ruff_linter/resources/test/fixtures/flake8_bandit/S311.py

@@ -0,0 +1,22 @@
+import os
+import random
+
+import a_lib
+
+# OK
+random.SystemRandom()
+
+# Errors
+random.Random()
+random.random()
+random.randrange()
+random.randint()
+random.choice()
+random.choices()
+random.uniform()
+random.triangular()
+random.randbytes()
+
+# Unrelated
+os.urandom()
+a_lib.random()

crates/ruff_linter/resources/test/fixtures/flake8_bandit/S324.py

@@ -1,52 +1,47 @@
+import crypt
 import hashlib
 from hashlib import new as hashlib_new
 from hashlib import sha1 as hashlib_sha1
 
-# Invalid
-
+# Errors
 hashlib.new('md5')
-
 hashlib.new('md4', b'test')
-
 hashlib.new(name='md5', data=b'test')
-
 hashlib.new('MD4', data=b'test')
-
 hashlib.new('sha1')
-
 hashlib.new('sha1', data=b'test')
-
 hashlib.new('sha', data=b'test')
-
 hashlib.new(name='SHA', data=b'test')
-
 hashlib.sha(data=b'test')
-
 hashlib.md5()
-
 hashlib_new('sha1')
-
 hashlib_sha1('sha1')
-
 # usedforsecurity arg only available in Python 3.9+
 hashlib.new('sha1', usedforsecurity=True)
 
-# Valid
+crypt.crypt("test", salt=crypt.METHOD_CRYPT)
+crypt.crypt("test", salt=crypt.METHOD_MD5)
+crypt.crypt("test", salt=crypt.METHOD_BLOWFISH)
+crypt.crypt("test", crypt.METHOD_BLOWFISH)
 
+crypt.mksalt(crypt.METHOD_CRYPT)
+crypt.mksalt(crypt.METHOD_MD5)
+crypt.mksalt(crypt.METHOD_BLOWFISH)
+
+# OK
 hashlib.new('sha256')
-
 hashlib.new('SHA512')
-
 hashlib.sha256(data=b'test')
-
 # usedforsecurity arg only available in Python 3.9+
 hashlib_new(name='sha1', usedforsecurity=False)
-
-# usedforsecurity arg only available in Python 3.9+
 hashlib_sha1(name='sha1', usedforsecurity=False)
-
-# usedforsecurity arg only available in Python 3.9+
 hashlib.md4(usedforsecurity=False)
-
-# usedforsecurity arg only available in Python 3.9+
 hashlib.new(name='sha256', usedforsecurity=False)
+
+crypt.crypt("test")
+crypt.crypt("test", salt=crypt.METHOD_SHA256)
+crypt.crypt("test", salt=crypt.METHOD_SHA512)
+
+crypt.mksalt()
+crypt.mksalt(crypt.METHOD_SHA256)
+crypt.mksalt(crypt.METHOD_SHA512)

crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py

@@ -1,4 +1,5 @@
 import os
+import subprocess
 
 import commands
 import popen2
@@ -16,6 +17,8 @@ popen2.Popen3("true")
 popen2.Popen4("true")
 commands.getoutput("true")
 commands.getstatusoutput("true")
+subprocess.getoutput("true")
+subprocess.getstatusoutput("true")
 
 
 # Check command argument looks unsafe.

crates/ruff_linter/resources/test/fixtures/flake8_bandit/S610.py

@@ -0,0 +1,34 @@
+from django.contrib.auth.models import User
+
+# Errors
+User.objects.filter(username='admin').extra(dict(could_be='insecure'))
+User.objects.filter(username='admin').extra(select=dict(could_be='insecure'))
+User.objects.filter(username='admin').extra(select={'test': '%secure' % 'nos'})
+User.objects.filter(username='admin').extra(select={'test': '{}secure'.format('nos')})
+User.objects.filter(username='admin').extra(where=['%secure' % 'nos'])
+User.objects.filter(username='admin').extra(where=['{}secure'.format('no')])
+
+query = '"username") AS "username", * FROM "auth_user" WHERE 1=1 OR "username"=? --'
+User.objects.filter(username='admin').extra(select={'test': query})
+
+where_var = ['1=1) OR 1=1 AND (1=1']
+User.objects.filter(username='admin').extra(where=where_var)
+
+where_str = '1=1) OR 1=1 AND (1=1'
+User.objects.filter(username='admin').extra(where=[where_str])
+
+tables_var = ['django_content_type" WHERE "auth_user"."username"="admin']
+User.objects.all().extra(tables=tables_var).distinct()
+
+tables_str = 'django_content_type" WHERE "auth_user"."username"="admin'
+User.objects.all().extra(tables=[tables_str]).distinct()
+
+# OK
+User.objects.filter(username='admin').extra(
+    select={'test': 'secure'},
+    where=['secure'],
+    tables=['secure']
+)
+User.objects.filter(username='admin').extra({'test': 'secure'})
+User.objects.filter(username='admin').extra(select={'test': 'secure'})
+User.objects.filter(username='admin').extra(where=['secure'])