Move last-mile check filtering to linter.rs

.cargo/config.toml

@@ -1,10 +1,2 @@
 [alias]
 dev = "run --package ruff_dev --bin ruff_dev"
-benchmark = "bench -p ruff_benchmark --bench linter --bench formatter --"
-
-# statically link the C runtime so the executable does not depend on
-# that shared/dynamic library.
-#
-# See: https://github.com/astral-sh/ruff/issues/11503
-[target.'cfg(all(target_env="msvc", target_os = "windows"))']
-rustflags = ["-C", "target-feature=+crt-static"]

.config/nextest.toml

@@ -1,8 +0,0 @@
-[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"

.devcontainer/devcontainer.json

@@ -1,46 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the
-// README at: https://github.com/devcontainers/templates/tree/main/src/rust
-{
-	"name": "Ruff",
-	"image": "mcr.microsoft.com/devcontainers/rust:0-1-bullseye",
-	"mounts": [
-		{
-			"source": "devcontainer-cargo-cache-${devcontainerId}",
-			"target": "/usr/local/cargo",
-			"type": "volume"
-		}
-	],
-	"customizations": {
-		"codespaces": {
-			"openFiles": [
-				"CONTRIBUTING.md"
-			]
-		},
-		"vscode": {
-			"extensions": [
-				"ms-python.python",
-				"rust-lang.rust-analyzer",
-				"fill-labs.dependi",
-				"tamasfe.even-better-toml",
-				"Swellaby.vscode-rust-test-adapter",
-				"charliermarsh.ruff"
-			],
-			"settings": {
-				"rust-analyzer.updates.askBeforeDownload": false
-			}
-		}
-	},
-	// Features to add to the dev container. More info: https://containers.dev/features.
-	"features": {
-		"ghcr.io/devcontainers/features/python": {
-			"installTools": false
-		}
-	},
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-	"postCreateCommand": ".devcontainer/post-create.sh"
-	// Configure tool-specific properties.
-	// "customizations": {},
-	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
-	// "remoteUser": "root"
-}

.devcontainer/post-create.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-
-rustup default < rust-toolchain
-rustup component add clippy rustfmt
-cargo install cargo-insta
-cargo fetch
-
-pip install maturin pre-commit

.editorconfig

@@ -10,11 +10,5 @@ indent_style = space
 insert_final_newline = true
 indent_size = 2
 
-[*.{rs,py,pyi}]
+[*.{rs,py}]
 indent_size = 4
-
-[*.snap]
-trim_trailing_whitespace = false
-
-[*.md]
-max_line_length = 100

.gitattributes

@@ -1,18 +0,0 @@
-* text=auto eol=lf
-
-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/invalid/re_lexing/line_continuation_windows_eol.py text eol=crlf
-crates/ruff_python_parser/resources/invalid/re_lex_logical_token_windows_eol.py text eol=crlf
-crates/ruff_python_parser/resources/invalid/re_lex_logical_token_mac_eol.py text eol=cr
-
-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

@@ -1,21 +0,0 @@
-# GitHub code owners file. For more info: https://help.github.com/articles/about-codeowners/
-#
-# - Comment lines begin with `#` character.
-# - Each line is a file pattern followed by one or more owners.
-# - The '*' pattern is global owners.
-# - Order is important. The last matching pattern has the most precedence.
-
-/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
-
-# red-knot
-/crates/red_knot* @carljm @MichaReiser @AlexWaygood @sharkdp
-/crates/ruff_db/ @carljm @MichaReiser @AlexWaygood @sharkdp

.github/ISSUE_TEMPLATE.md

@@ -1,12 +0,0 @@
-<!--
-Thank you for taking the time to report an issue! We're glad to have you involved with Ruff.
-
-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`).
-* The current Ruff version (`ruff --version`).
--->

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,15 +0,0 @@
-<!--
-Thank you for contributing to Ruff! To help us out with reviewing, please consider the following:
-
-- Does this pull request include a summary of the change? (See below.)
-- Does this pull request include a descriptive title?
-- Does this pull request include references to any relevant issues?
--->
-
-## Summary
-
-<!-- What's the purpose of the change? What does it do, and why? -->
-
-## Test Plan
-
-<!-- How was it tested? -->

.github/renovate.json5

@@ -1,111 +0,0 @@
-{
-  $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", "pip_requirements", "npm"],
-  cargo: {
-    // See https://docs.renovatebot.com/configuration-options/#rangestrategy
-    rangeStrategy: "update-lockfile",
-  },
-  pep621: {
-    // The default for this package manager is to only search for `pyproject.toml` files
-    // found at the repository root: https://docs.renovatebot.com/modules/manager/pep621/#file-matching
-    fileMatch: ["^(python|scripts)/.*pyproject\\.toml$"],
-  },
-  pip_requirements: {
-    // The default for this package manager is to run on all requirements.txt files:
-    // https://docs.renovatebot.com/modules/manager/pip_requirements/#file-matching
-    // `fileMatch` doesn't work for excluding files; to exclude `requirements.txt` files
-    // outside the `doc/` directory, we instead have to use `ignorePaths`. Unlike `fileMatch`,
-    // which takes a regex string, `ignorePaths` takes a glob string, so we have to use
-    // a "negative glob pattern".
-    // See:
-    // - https://docs.renovatebot.com/modules/manager/#ignoring-files-that-match-the-default-filematch
-    // - https://docs.renovatebot.com/configuration-options/#ignorepaths
-    // - https://docs.renovatebot.com/string-pattern-matching/#negative-matching
-    ignorePaths: ["!docs/requirements*.txt"]
-  },
-  npm: {
-    // The default for this package manager is to only search for `package.json` files
-    // found at the repository root: https://docs.renovatebot.com/modules/manager/npm/#file-matching
-    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"],
-      matchDatasources: ["gitea-tags", "github-tags"],
-      matchPackagePatterns: ["actions/.*-artifact"],
-      description: "Weekly update of artifact-related GitHub Actions dependencies",
-    },
-    {
-      // This package rule disables updates for GitHub runners:
-      // we'd only pin them to a specific version
-      // if there was a deliberate reason to do so
-      groupName: "GitHub runners",
-      matchManagers: ["github-actions"],
-      matchDatasources: ["github-runners"],
-      description: "Disable PRs updating GitHub runners (e.g. 'runs-on: macos-14')",
-      enabled: false,
-    },
-    {
-      // Disable updates of `zip-rs`; intentionally pinned for now due to ownership change
-      // See: https://github.com/astral-sh/uv/issues/3642
-      matchPackagePatterns: ["zip"],
-      matchManagers: ["cargo"],
-      enabled: false,
-    },
-    {
-      // `mkdocs-material` requires a manual update to keep the version in sync
-      // with `mkdocs-material-insider`.
-      // See: https://squidfunk.github.io/mkdocs-material/insiders/upgrade/
-      matchManagers: ["pip_requirements"],
-      matchPackagePatterns: ["mkdocs-material"],
-      enabled: false,
-    },
-    {
-      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/build-binaries.yml

@@ -1,470 +0,0 @@
-# Build ruff on all platforms.
-#
-# Generates both wheels (for PyPI) and archived binaries (for GitHub releases).
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a local
-# artifacts job within `cargo-dist`.
-name: "Build binaries"
-
-on:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-  pull_request:
-    paths:
-      # When we change pyproject.toml, we want to ensure that the maturin builds still work.
-      - pyproject.toml
-      # And when we change this workflow itself...
-      - .github/workflows/build-binaries.yml
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-env:
-  PACKAGE_NAME: ruff
-  MODULE_NAME: ruff
-  PYTHON_VERSION: "3.11"
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-
-jobs:
-  sdist:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build sdist"
-        uses: PyO3/maturin-action@v1
-        with:
-          command: sdist
-          args: --out dist
-      - name: "Test sdist"
-        run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*.tar.gz --force-reinstall
-          ${{ env.MODULE_NAME }} --help
-          python -m ${{ env.MODULE_NAME }} --help
-      - name: "Upload sdist"
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-sdist
-          path: dist
-
-  macos-x86_64:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: macos-14
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels - x86_64"
-        uses: PyO3/maturin-action@v1
-        with:
-          target: x86_64
-          args: --release --locked --out dist
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-macos-x86_64
-          path: dist
-      - name: "Archive binary"
-        run: |
-          TARGET=x86_64-apple-darwin
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-macos-x86_64
-          path: |
-            *.tar.gz
-            *.sha256
-
-  macos-aarch64:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: macos-14
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: arm64
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels - aarch64"
-        uses: PyO3/maturin-action@v1
-        with:
-          target: aarch64
-          args: --release --locked --out dist
-      - name: "Test wheel - aarch64"
-        run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-          ruff --help
-          python -m ruff --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-aarch64-apple-darwin
-          path: dist
-      - name: "Archive binary"
-        run: |
-          TARGET=aarch64-apple-darwin
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-aarch64-apple-darwin
-          path: |
-            *.tar.gz
-            *.sha256
-
-  windows:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: windows-latest
-    strategy:
-      matrix:
-        platform:
-          - target: x86_64-pc-windows-msvc
-            arch: x64
-          - target: i686-pc-windows-msvc
-            arch: x86
-          - target: aarch64-pc-windows-msvc
-            arch: x64
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: ${{ matrix.platform.arch }}
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels"
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.platform.target }}
-          args: --release --locked --out dist
-        env:
-          # aarch64 build fails, see https://github.com/PyO3/maturin/issues/2110
-          XWIN_VERSION: 16
-      - name: "Test wheel"
-        if: ${{ !startsWith(matrix.platform.target, 'aarch64') }}
-        shell: bash
-        run: |
-          python -m pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-          ${{ env.MODULE_NAME }} --help
-          python -m ${{ env.MODULE_NAME }} --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ matrix.platform.target }}
-          path: dist
-      - name: "Archive binary"
-        shell: bash
-        run: |
-          ARCHIVE_FILE=ruff-${{ matrix.platform.target }}.zip
-          7z a $ARCHIVE_FILE ./target/${{ matrix.platform.target }}/release/ruff.exe
-          sha256sum $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-${{ matrix.platform.target }}
-          path: |
-            *.zip
-            *.sha256
-
-  linux:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target:
-          - x86_64-unknown-linux-gnu
-          - i686-unknown-linux-gnu
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels"
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          manylinux: auto
-          args: --release --locked --out dist
-      - name: "Test wheel"
-        if: ${{ startsWith(matrix.target, 'x86_64') }}
-        run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-          ${{ env.MODULE_NAME }} --help
-          python -m ${{ env.MODULE_NAME }} --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ matrix.target }}
-          path: dist
-      - name: "Archive binary"
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          TARGET=${{ matrix.target }}
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-${{ matrix.target }}
-          path: |
-            *.tar.gz
-            *.sha256
-
-  linux-cross:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        platform:
-          - target: aarch64-unknown-linux-gnu
-            arch: aarch64
-            # see https://github.com/astral-sh/ruff/issues/3791
-            # and https://github.com/gnzlbg/jemallocator/issues/170#issuecomment-1503228963
-            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
-          - target: armv7-unknown-linux-gnueabihf
-            arch: armv7
-          - target: s390x-unknown-linux-gnu
-            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
-          - target: arm-unknown-linux-musleabihf
-            arch: arm
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels"
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.platform.target }}
-          manylinux: auto
-          docker-options: ${{ matrix.platform.maturin_docker_options }}
-          args: --release --locked --out dist
-      - uses: uraimo/run-on-arch-action@v2
-        if: matrix.platform.arch != 'ppc64'
-        name: Test wheel
-        with:
-          arch: ${{ matrix.platform.arch == 'arm' && 'armv6' || matrix.platform.arch }}
-          distro: ${{ matrix.platform.arch == 'arm' && 'bullseye' || 'ubuntu20.04' }}
-          githubToken: ${{ github.token }}
-          install: |
-            apt-get update
-            apt-get install -y --no-install-recommends python3 python3-pip
-            pip3 install -U pip
-          run: |
-            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
-            ruff --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ matrix.platform.target }}
-          path: dist
-      - name: "Archive binary"
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          TARGET=${{ matrix.platform.target }}
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-${{ matrix.platform.target }}
-          path: |
-            *.tar.gz
-            *.sha256
-
-  musllinux:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target:
-          - x86_64-unknown-linux-musl
-          - i686-unknown-linux-musl
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels"
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          manylinux: musllinux_1_2
-          args: --release --locked --out dist
-      - name: "Test wheel"
-        if: matrix.target == 'x86_64-unknown-linux-musl'
-        uses: addnab/docker-run-action@v3
-        with:
-          image: alpine:latest
-          options: -v ${{ github.workspace }}:/io -w /io
-          run: |
-            apk add python3
-            python -m venv .venv
-            .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
-            .venv/bin/${{ env.MODULE_NAME }} --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ matrix.target }}
-          path: dist
-      - name: "Archive binary"
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          TARGET=${{ matrix.target }}
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-${{ matrix.target }}
-          path: |
-            *.tar.gz
-            *.sha256
-
-  musllinux-cross:
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-build') }}
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        platform:
-          - target: aarch64-unknown-linux-musl
-            arch: aarch64
-            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
-          - target: armv7-unknown-linux-musleabihf
-            arch: armv7
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels"
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.platform.target }}
-          manylinux: musllinux_1_2
-          args: --release --locked --out dist
-          docker-options: ${{ matrix.platform.maturin_docker_options }}
-      - uses: uraimo/run-on-arch-action@v2
-        name: Test wheel
-        with:
-          arch: ${{ matrix.platform.arch }}
-          distro: alpine_latest
-          githubToken: ${{ github.token }}
-          install: |
-            apk add python3
-          run: |
-            python -m venv .venv
-            .venv/bin/pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
-            .venv/bin/${{ env.MODULE_NAME }} --help
-      - name: "Upload wheels"
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ matrix.platform.target }}
-          path: dist
-      - name: "Archive binary"
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          TARGET=${{ matrix.platform.target }}
-          ARCHIVE_NAME=ruff-$TARGET
-          ARCHIVE_FILE=$ARCHIVE_NAME.tar.gz
-
-          mkdir -p $ARCHIVE_NAME
-          cp target/$TARGET/release/ruff $ARCHIVE_NAME/ruff
-          tar czvf $ARCHIVE_FILE $ARCHIVE_NAME
-          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
-      - name: "Upload binary"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-${{ matrix.platform.target }}
-          path: |
-            *.tar.gz
-            *.sha256

.github/workflows/build-docker.yml

@@ -1,290 +0,0 @@
-# Build and publish a Docker image.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a local
-# artifacts job within `cargo-dist`.
-#
-# TODO(charlie): Ideally, the publish step would happen as a publish job within `cargo-dist`, but
-# sharing the built image as an artifact between jobs is challenging.
-name: "[ruff] Build Docker image"
-
-on:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-  pull_request:
-    paths:
-      - .github/workflows/build-docker.yml
-
-env:
-  RUFF_BASE_IMG: ghcr.io/${{ github.repository_owner }}/ruff
-
-jobs:
-  docker-build:
-    name: Build Docker image (ghcr.io/astral-sh/ruff) for ${{ matrix.platform }}
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - linux/amd64
-          - linux/arm64
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-
-      - uses: docker/setup-buildx-action@v3
-
-      - uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Check tag consistency
-        if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-        run: |
-          version=$(grep "version = " pyproject.toml | sed -e 's/version = "\(.*\)"/\1/g')
-          if [ "${{ fromJson(inputs.plan).announcement_tag }}" != "${version}" ]; then
-            echo "The input tag does not match the version from pyproject.toml:" >&2
-            echo "${{ fromJson(inputs.plan).announcement_tag }}" >&2
-            echo "${version}" >&2
-            exit 1
-          else
-            echo "Releasing ${version}"
-          fi
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          # Defining this makes sure the org.opencontainers.image.version OCI label becomes the actual release version and not the branch name
-          tags: |
-            type=raw,value=dry-run,enable=${{ inputs.plan == '' || fromJson(inputs.plan).announcement_tag_is_implicit }}
-            type=pep440,pattern={{ version }},value=${{ inputs.plan != '' && fromJson(inputs.plan).announcement_tag || 'dry-run' }},enable=${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-
-      - name: Normalize Platform Pair (replace / with -)
-        run: |
-          platform=${{ matrix.platform }}
-          echo "PLATFORM_TUPLE=${platform//\//-}" >> $GITHUB_ENV
-
-      # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
-      - name: Build and push by digest
-        id: build
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          platforms: ${{ matrix.platform }}
-          cache-from: type=gha,scope=ruff-${{ env.PLATFORM_TUPLE }}
-          cache-to: type=gha,mode=min,scope=ruff-${{ env.PLATFORM_TUPLE }}
-          labels: ${{ steps.meta.outputs.labels }}
-          outputs: type=image,name=${{ env.RUFF_BASE_IMG }},push-by-digest=true,name-canonical=true,push=${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-
-      - name: Export digests
-        run: |
-          mkdir -p /tmp/digests
-          digest="${{ steps.build.outputs.digest }}"
-          touch "/tmp/digests/${digest#sha256:}"
-
-      - name: Upload digests
-        uses: actions/upload-artifact@v4
-        with:
-          name: digests-${{ env.PLATFORM_TUPLE }}
-          path: /tmp/digests/*
-          if-no-files-found: error
-          retention-days: 1
-
-  docker-publish:
-    name: Publish Docker image (ghcr.io/astral-sh/ruff)
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    needs:
-      - docker-build
-    if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-    steps:
-      - name: Download digests
-        uses: actions/download-artifact@v4
-        with:
-          path: /tmp/digests
-          pattern: digests-*
-          merge-multiple: true
-
-      - uses: docker/setup-buildx-action@v3
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          # Order is on purpose such that the label org.opencontainers.image.version has the first pattern with the full version
-          tags: |
-            type=pep440,pattern={{ version }},value=${{ fromJson(inputs.plan).announcement_tag }}
-            type=pep440,pattern={{ major }}.{{ minor }},value=${{ fromJson(inputs.plan).announcement_tag }}
-
-      - uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
-      - name: Create manifest list and push
-        working-directory: /tmp/digests
-        # The jq command expands the docker/metadata json "tags" array entry to `-t tag1 -t tag2 ...` for each tag in the array
-        # The printf will expand the base image with the `<RUFF_BASE_IMG>@sha256:<sha256> ...` for each sha256 in the directory
-        # The final command becomes `docker buildx imagetools create -t tag1 -t tag2 ... <RUFF_BASE_IMG>@sha256:<sha256_1> <RUFF_BASE_IMG>@sha256:<sha256_2> ...`
-        run: |
-          docker buildx imagetools create \
-            $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf '${{ env.RUFF_BASE_IMG }}@sha256:%s ' *)
-
-  docker-publish-extra:
-    name: Publish additional Docker image based on ${{ matrix.image-mapping }}
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    needs:
-      - docker-publish
-    if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-    strategy:
-      fail-fast: false
-      matrix:
-        # Mapping of base image followed by a comma followed by one or more base tags (comma separated)
-        # Note, org.opencontainers.image.version label will use the first base tag (use the most specific tag first)
-        image-mapping:
-          - alpine:3.20,alpine3.20,alpine
-          - debian:bookworm-slim,bookworm-slim,debian-slim
-          - buildpack-deps:bookworm,bookworm,debian
-    steps:
-      - uses: docker/setup-buildx-action@v3
-
-      - uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Generate Dynamic Dockerfile Tags
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          # Extract the image and tags from the matrix variable
-          IFS=',' read -r BASE_IMAGE BASE_TAGS <<< "${{ matrix.image-mapping }}"
-
-          # Generate Dockerfile content
-          cat <<EOF > Dockerfile
-          FROM ${BASE_IMAGE}
-          COPY --from=${{ env.RUFF_BASE_IMG }}:latest /ruff /usr/local/bin/ruff
-          ENTRYPOINT []
-          CMD ["/usr/local/bin/ruff"]
-          EOF
-
-          # Initialize a variable to store all tag docker metadata patterns
-          TAG_PATTERNS=""
-
-          # Loop through all base tags and append its docker metadata pattern to the list
-          # Order is on purpose such that the label org.opencontainers.image.version has the first pattern with the full version
-          IFS=','; for TAG in ${BASE_TAGS}; do
-            TAG_PATTERNS="${TAG_PATTERNS}type=pep440,pattern={{ version }},suffix=-${TAG},value=${{ fromJson(inputs.plan).announcement_tag }}\n"
-            TAG_PATTERNS="${TAG_PATTERNS}type=pep440,pattern={{ major }}.{{ minor }},suffix=-${TAG},value=${{ fromJson(inputs.plan).announcement_tag }}\n"
-            TAG_PATTERNS="${TAG_PATTERNS}type=raw,value=${TAG}\n"
-          done
-
-          # Remove the trailing newline from the pattern list
-          TAG_PATTERNS="${TAG_PATTERNS%\\n}"
-
-          # Export image cache name
-          echo "IMAGE_REF=${BASE_IMAGE//:/-}" >> $GITHUB_ENV
-
-          # Export tag patterns using the multiline env var syntax
-          {
-            echo "TAG_PATTERNS<<EOF"
-            echo -e "${TAG_PATTERNS}"
-            echo EOF
-          } >> $GITHUB_ENV
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        # ghcr.io prefers index level annotations
-        env:
-          DOCKER_METADATA_ANNOTATIONS_LEVELS: index
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          flavor: |
-            latest=false
-          tags: |
-            ${{ env.TAG_PATTERNS }}
-
-      - name: Build and push
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          platforms: linux/amd64,linux/arm64
-          # We do not really need to cache here as the Dockerfile is tiny
-          #cache-from: type=gha,scope=ruff-${{ env.IMAGE_REF }}
-          #cache-to: type=gha,mode=min,scope=ruff-${{ env.IMAGE_REF }}
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          annotations: ${{ steps.meta.outputs.annotations }}
-
-  # This is effectively a duplicate of `docker-publish` to make https://github.com/astral-sh/ruff/pkgs/container/ruff
-  # show the ruff base image first since GitHub always shows the last updated image digests
-  # This works by annotating the original digests (previously non-annotated) which triggers an update to ghcr.io
-  docker-republish:
-    name: Annotate Docker image (ghcr.io/astral-sh/ruff)
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    needs:
-      - docker-publish-extra
-    if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-    steps:
-      - name: Download digests
-        uses: actions/download-artifact@v4
-        with:
-          path: /tmp/digests
-          pattern: digests-*
-          merge-multiple: true
-
-      - uses: docker/setup-buildx-action@v3
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v5
-        env:
-          DOCKER_METADATA_ANNOTATIONS_LEVELS: index
-        with:
-          images: ${{ env.RUFF_BASE_IMG }}
-          # Order is on purpose such that the label org.opencontainers.image.version has the first pattern with the full version
-          tags: |
-            type=pep440,pattern={{ version }},value=${{ fromJson(inputs.plan).announcement_tag }}
-            type=pep440,pattern={{ major }}.{{ minor }},value=${{ fromJson(inputs.plan).announcement_tag }}
-
-      - uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      # Adapted from https://docs.docker.com/build/ci/github-actions/multi-platform/
-      - name: Create manifest list and push
-        working-directory: /tmp/digests
-        # The readarray part is used to make sure the quoting and special characters are preserved on expansion (e.g. spaces)
-        # The jq command expands the docker/metadata json "tags" array entry to `-t tag1 -t tag2 ...` for each tag in the array
-        # The printf will expand the base image with the `<RUFF_BASE_IMG>@sha256:<sha256> ...` for each sha256 in the directory
-        # The final command becomes `docker buildx imagetools create -t tag1 -t tag2 ... <RUFF_BASE_IMG>@sha256:<sha256_1> <RUFF_BASE_IMG>@sha256:<sha256_2> ...`
-        run: |
-          readarray -t lines <<< "$DOCKER_METADATA_OUTPUT_ANNOTATIONS"; annotations=(); for line in "${lines[@]}"; do annotations+=(--annotation "$line"); done
-          docker buildx imagetools create \
-            "${annotations[@]}" \
-            $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
-            $(printf '${{ env.RUFF_BASE_IMG }}@sha256:%s ' *)

.github/workflows/ci.yaml

@@ -4,637 +4,129 @@ on:
   push:
     branches: [main]
   pull_request:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }}
-  cancel-in-progress: true
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-  PACKAGE_NAME: ruff
-  PYTHON_VERSION: "3.12"
+    branches: [main]
 
 jobs:
-  determine_changes:
-    name: "Determine changes"
+  cargo_build:
+    name: "cargo build"
     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
-      formatter: ${{ steps.changed.outputs.formatter_any_changed }}
-      # Flag that is raised when any code is changed
-      # This is superset of the linter and formatter
-      code: ${{ steps.changed.outputs.code_any_changed }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
         with:
-          fetch-depth: 0
-
-      - uses: tj-actions/changed-files@v45
-        id: changed
+          profile: minimal
+      - uses: actions/cache@v3
+        env:
+          cache-name: cache-cargo
         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
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ env.cache-name }}-
+            ${{ runner.os }}-build-
+            ${{ runner.os }}-
+      - run: cargo build --all --release
 
-            linter:
-              - Cargo.toml
-              - Cargo.lock
-              - crates/**
-              - "!crates/ruff_python_formatter/**"
-              - "!crates/ruff_formatter/**"
-              - "!crates/ruff_dev/**"
-              - scripts/*
-              - python/**
-              - .github/workflows/ci.yaml
-
-            formatter:
-              - Cargo.toml
-              - Cargo.lock
-              - crates/ruff_python_formatter/**
-              - crates/ruff_formatter/**
-              - crates/ruff_python_trivia/**
-              - crates/ruff_python_ast/**
-              - crates/ruff_source_file/**
-              - crates/ruff_python_index/**
-              - crates/ruff_text_size/**
-              - crates/ruff_python_parser/**
-              - crates/ruff_dev/**
-              - scripts/*
-              - python/**
-              - .github/workflows/ci.yaml
-
-            code:
-              - "**/*"
-              - "!**/*.md"
-              - "!docs/**"
-              - "!assets/**"
-
-  cargo-fmt:
+  cargo_fmt:
     name: "cargo fmt"
     runs-on: ubuntu-latest
-    timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup component add rustfmt
+      - uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly-2022-11-01
+          override: true
+          components: rustfmt
+      - uses: actions/cache@v3
+        env:
+          cache-name: cache-cargo
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ env.cache-name }}-
+            ${{ runner.os }}-build-
+            ${{ runner.os }}-
       - run: cargo fmt --all --check
 
-  cargo-clippy:
+  cargo_clippy:
     name: "cargo clippy"
     runs-on: ubuntu-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
-    timeout-minutes: 20
     steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: |
-          rustup component add clippy
-          rustup target add wasm32-unknown-unknown
-      - uses: Swatinem/rust-cache@v2
-      - name: "Clippy"
-        run: cargo clippy --workspace --all-targets --all-features --locked -- -D warnings
-      - name: "Clippy (wasm)"
-        run: cargo clippy -p ruff_wasm -p red_knot_wasm --target wasm32-unknown-unknown --all-features --locked -- -D warnings
-
-  cargo-test-linux:
-    name: "cargo test (linux)"
-    runs-on: ubuntu-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
-    timeout-minutes: 20
-    steps:
-      - 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
+      - uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
         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"
-        shell: bash
+          profile: minimal
+          toolchain: nightly-2022-11-01
+          override: true
+          components: clippy
+      - uses: actions/cache@v3
         env:
-          NEXTEST_PROFILE: "ci"
-        run: cargo insta test --all-features --unreferenced reject --test-runner nextest
+          cache-name: cache-cargo
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ env.cache-name }}-
+            ${{ runner.os }}-build-
+            ${{ runner.os }}-
+      - run: cargo clippy --all -- -D warnings
 
-      # Check for broken links in the documentation.
-      - run: cargo doc --all --no-deps
+  cargo_test:
+    name: "cargo test"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly-2022-11-01
+          override: true
+      - uses: actions/cache@v3
         env:
-          RUSTDOCFLAGS: "-D warnings"
-      # Use --document-private-items so that all our doc comments are kept in
-      # sync, not just public items. Eventually we should do this for all
-      # crates; for now add crates here as they are warning-clean to prevent
-      # regression.
-      - run: cargo doc --no-deps -p red_knot_python_semantic -p red_knot -p red_knot_test -p ruff_db --document-private-items
+          cache-name: cache-cargo
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ env.cache-name }}-
+            ${{ runner.os }}-build-
+            ${{ runner.os }}-
+      - run: cargo test --all
+
+  maturin_build:
+    name: "maturin build"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly-2022-11-01
+          override: true
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+      - run: pip install maturin
+      - uses: actions/cache@v3
         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@v4
+          cache-name: cache-cargo
         with:
-          name: ruff
-          path: target/debug/ruff
-
-  cargo-test-windows:
-    name: "cargo test (windows)"
-    runs-on: windows-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
-    timeout-minutes: 20
-    steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - name: "Install cargo nextest"
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-nextest
-      - uses: Swatinem/rust-cache@v2
-      - name: "Run tests"
-        shell: bash
-        env:
-          # Workaround for <https://github.com/nextest-rs/nextest/issues/1493>.
-          RUSTUP_WINDOWS_PATH_ADD_BIN: 1
-        run: |
-          cargo nextest run --all-features --profile ci
-          cargo test --all-features --doc
-
-  cargo-test-wasm:
-    name: "cargo test (wasm)"
-    runs-on: ubuntu-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
-    timeout-minutes: 10
-    steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: "npm"
-          cache-dependency-path: playground/package-lock.json
-      - uses: jetli/wasm-pack-action@v0.4.0
-      - uses: Swatinem/rust-cache@v2
-      - name: "Test ruff_wasm"
-        run: |
-          cd crates/ruff_wasm
-          wasm-pack test --node
-      - name: "Test red_knot_wasm"
-        run: |
-          cd crates/red_knot_wasm
-          wasm-pack test --node
-
-  cargo-build-release:
-    name: "cargo build (release)"
-    runs-on: macos-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
-    timeout-minutes: 20
-    steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - name: "Install mold"
-        uses: rui314/setup-mold@v1
-      - uses: Swatinem/rust-cache@v2
-      - name: "Build"
-        run: cargo build --release --locked
-
-  cargo-build-msrv:
-    name: "cargo build (msrv)"
-    runs-on: ubuntu-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
-    timeout-minutes: 20
-    steps:
-      - uses: actions/checkout@v4
-      - uses: SebRollen/toml-action@v1.2.0
-        id: msrv
-        with:
-          file: "Cargo.toml"
-          field: "workspace.package.rust-version"
-      - name: "Install Rust toolchain"
-        run: rustup default ${{ steps.msrv.outputs.value }}
-      - 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"
-        shell: bash
-        env:
-          NEXTEST_PROFILE: "ci"
-        run: cargo +${{ steps.msrv.outputs.value }} insta test --all-features --unreferenced reject --test-runner nextest
-
-  cargo-fuzz:
-    name: "cargo fuzz"
-    runs-on: ubuntu-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
-    timeout-minutes: 10
-    steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: "fuzz -> target"
-      - name: "Install cargo-binstall"
-        uses: cargo-bins/cargo-binstall@main
-        with:
-          tool: cargo-fuzz@0.11.2
-      - name: "Install cargo-fuzz"
-        # Download the latest version from quick install and not the github releases because github releases only has MUSL targets.
-        run: cargo binstall cargo-fuzz --force  --disable-strategies crate-meta-data --no-confirm
-      - 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
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
-    timeout-minutes: 5
-    steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup component add rustfmt
-      - uses: Swatinem/rust-cache@v2
-      - run: ./scripts/add_rule.py --name DoTheThing --prefix PL --code C0999 --linter pylint
-      - run: cargo check
-      - run: cargo fmt --all --check
-      - run: |
-          ./scripts/add_plugin.py test --url https://pypi.org/project/-test/0.1.0/ --prefix TST
-          ./scripts/add_rule.py --name FirstRule --prefix TST --code 001 --linter test
-      - run: cargo check
-      - run: cargo fmt --all --check
-
-  ecosystem:
-    name: "ecosystem"
-    runs-on: ubuntu-latest
-    needs:
-      - cargo-test-linux
-      - 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' }}
-    timeout-minutes: 20
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-
-      - uses: actions/download-artifact@v4
-        name: Download comparison Ruff binary
-        id: ruff-target
-        with:
-          name: ruff
-          path: target/debug
-
-      - uses: dawidd6/action-download-artifact@v6
-        name: Download baseline Ruff binary
-        with:
-          name: ruff
-          branch: ${{ github.event.pull_request.base.ref }}
-          workflow: "ci.yaml"
-          check_artifacts: true
-
-      - name: Install ruff-ecosystem
-        run: |
-          pip install ./python/ruff-ecosystem
-
-      - name: Run `ruff check` stable ecosystem check
-        if: ${{ needs.determine_changes.outputs.linter == 'true' }}
-        run: |
-          # Make executable, since artifact download doesn't preserve this
-          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
-
-          # Set pipefail to avoid hiding errors with tee
-          set -eo pipefail
-
-          ruff-ecosystem check ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff --cache ./checkouts --output-format markdown | tee ecosystem-result-check-stable
-
-          cat ecosystem-result-check-stable > $GITHUB_STEP_SUMMARY
-          echo "### Linter (stable)"  > ecosystem-result
-          cat ecosystem-result-check-stable >> ecosystem-result
-          echo "" >> ecosystem-result
-
-      - name: Run `ruff check` preview ecosystem check
-        if: ${{ needs.determine_changes.outputs.linter == 'true' }}
-        run: |
-          # Make executable, since artifact download doesn't preserve this
-          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
-
-          # Set pipefail to avoid hiding errors with tee
-          set -eo pipefail
-
-          ruff-ecosystem check ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff --cache ./checkouts --output-format markdown --force-preview | tee ecosystem-result-check-preview
-
-          cat ecosystem-result-check-preview > $GITHUB_STEP_SUMMARY
-          echo "### Linter (preview)" >> ecosystem-result
-          cat ecosystem-result-check-preview >> ecosystem-result
-          echo "" >> ecosystem-result
-
-      - name: Run `ruff format` stable ecosystem check
-        if: ${{ needs.determine_changes.outputs.formatter == 'true' }}
-        run: |
-          # Make executable, since artifact download doesn't preserve this
-          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
-
-          # Set pipefail to avoid hiding errors with tee
-          set -eo pipefail
-
-          ruff-ecosystem format ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff --cache ./checkouts --output-format markdown | tee ecosystem-result-format-stable
-
-          cat ecosystem-result-format-stable > $GITHUB_STEP_SUMMARY
-          echo "### Formatter (stable)" >> ecosystem-result
-          cat ecosystem-result-format-stable >> ecosystem-result
-          echo "" >> ecosystem-result
-
-      - name: Run `ruff format` preview ecosystem check
-        if: ${{ needs.determine_changes.outputs.formatter == 'true' }}
-        run: |
-          # Make executable, since artifact download doesn't preserve this
-          chmod +x ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
-
-          # Set pipefail to avoid hiding errors with tee
-          set -eo pipefail
-
-          ruff-ecosystem format ./ruff ${{ steps.ruff-target.outputs.download-path }}/ruff --cache ./checkouts --output-format markdown --force-preview | tee ecosystem-result-format-preview
-
-          cat ecosystem-result-format-preview > $GITHUB_STEP_SUMMARY
-          echo "### Formatter (preview)" >> ecosystem-result
-          cat ecosystem-result-format-preview >> ecosystem-result
-          echo "" >> ecosystem-result
-
-      - name: Export pull request number
-        run: |
-          echo ${{ github.event.number }} > pr-number
-
-      - uses: actions/upload-artifact@v4
-        name: Upload PR Number
-        with:
-          name: pr-number
-          path: pr-number
-
-      - uses: actions/upload-artifact@v4
-        name: Upload Results
-        with:
-          name: ecosystem-result
-          path: ecosystem-result
-
-  cargo-shear:
-    name: "cargo shear"
-    runs-on: ubuntu-latest
-    needs: determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: cargo-bins/cargo-binstall@main
-      - run: cargo binstall --no-confirm cargo-shear
-      - run: cargo shear
-
-  python-package:
-    name: "python package"
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
-      - uses: Swatinem/rust-cache@v2
-      - name: "Prep README.md"
-        run: python scripts/transform_readme.py --target pypi
-      - name: "Build wheels"
-        uses: PyO3/maturin-action@v1
-        with:
-          args: --out dist
-      - name: "Test wheel"
-        run: |
-          pip install --force-reinstall --find-links dist ${{ env.PACKAGE_NAME }}
-          ruff --help
-          python -m ruff --help
-      - name: "Remove wheels from cache"
-        run: rm -rf target/wheels
-
-  pre-commit:
-    name: "pre-commit"
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - uses: Swatinem/rust-cache@v2
-      - name: "Install pre-commit"
-        run: pip install pre-commit
-      - name: "Cache pre-commit"
-        uses: actions/cache@v4
-        with:
-          path: ~/.cache/pre-commit
-          key: pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
-      - name: "Run pre-commit"
-        run: |
-          echo '```console' > $GITHUB_STEP_SUMMARY
-          # Enable color output for pre-commit and remove it for the summary
-          SKIP=cargo-fmt,clippy,dev-generate-all pre-commit run --all-files --show-diff-on-failure --color=always | \
-            tee >(sed -E 's/\x1B\[([0-9]{1,2}(;[0-9]{1,2})*)?[mGK]//g' >> $GITHUB_STEP_SUMMARY) >&1
-          exit_code=${PIPESTATUS[0]}
-          echo '```' >> $GITHUB_STEP_SUMMARY
-          exit $exit_code
-
-  docs:
-    name: "mkdocs"
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    env:
-      MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.13"
-      - name: "Add SSH key"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        uses: webfactory/ssh-agent@v0.9.0
-        with:
-          ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - name: Install uv
-        uses: astral-sh/setup-uv@v3
-      - uses: Swatinem/rust-cache@v2
-      - name: "Install Insiders dependencies"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        run: uv pip install -r docs/requirements-insiders.txt --system
-      - name: "Install dependencies"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
-        run: uv pip install -r docs/requirements.txt --system
-      - name: "Update README File"
-        run: python scripts/transform_readme.py --target mkdocs
-      - name: "Generate docs"
-        run: python scripts/generate_mkdocs.py
-      - name: "Check docs formatting"
-        run: python scripts/check_docs_formatted.py
-      - name: "Build Insiders docs"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        run: mkdocs build --strict -f mkdocs.insiders.yml
-      - name: "Build docs"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
-        run: mkdocs build --strict -f mkdocs.public.yml
-
-  check-formatter-instability-and-black-similarity:
-    name: "formatter instabilities and black similarity"
-    runs-on: ubuntu-latest
-    needs: determine_changes
-    if: needs.determine_changes.outputs.formatter == 'true' || github.ref == 'refs/heads/main'
-    timeout-minutes: 10
-    steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - name: "Cache rust"
-        uses: Swatinem/rust-cache@v2
-      - name: "Formatter progress"
-        run: scripts/formatter_ecosystem_checks.sh
-      - name: "Github step summary"
-        run: cat target/progress_projects_stats.txt > $GITHUB_STEP_SUMMARY
-      - name: "Remove checkouts from cache"
-        run: rm -r target/progress_projects
-
-  check-ruff-lsp:
-    name: "test ruff-lsp"
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    needs:
-      - cargo-test-linux
-      - determine_changes
-    if: ${{ needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main' }}
-    steps:
-      - uses: extractions/setup-just@v2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - uses: actions/checkout@v4
-        name: "Download ruff-lsp source"
-        with:
-          repository: "astral-sh/ruff-lsp"
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-
-      - uses: actions/download-artifact@v4
-        name: Download development ruff binary
-        id: ruff-target
-        with:
-          name: ruff
-          path: target/debug
-
-      - name: Install ruff-lsp dependencies
-        run: |
-          just install
-
-      - name: Run ruff-lsp tests
-        run: |
-          # Setup development binary
-          pip uninstall --yes ruff
-          chmod +x ${{ steps.ruff-target.outputs.download-path }}/ruff
-          export PATH=${{ steps.ruff-target.outputs.download-path }}:$PATH
-          ruff version
-
-          just test
-
-  benchmarks:
-    runs-on: ubuntu-22.04
-    needs: determine_changes
-    if: ${{ github.repository == 'astral-sh/ruff' && (needs.determine_changes.outputs.code == 'true' || github.ref == 'refs/heads/main') }}
-    timeout-minutes: 20
-    steps:
-      - name: "Checkout Branch"
-        uses: actions/checkout@v4
-
-      - name: "Install Rust toolchain"
-        run: rustup show
-
-      - name: "Install codspeed"
-        uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-codspeed
-
-      - uses: Swatinem/rust-cache@v2
-
-      - name: "Build benchmarks"
-        run: cargo codspeed build --features codspeed -p ruff_benchmark
-
-      - name: "Run benchmarks"
-        uses: CodSpeedHQ/action@v3
-        with:
-          run: cargo codspeed run
-          token: ${{ secrets.CODSPEED_TOKEN }}
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ env.cache-name }}-
+            ${{ runner.os }}-build-
+            ${{ runner.os }}-
+      - run: maturin build -b bin

.github/workflows/daily_fuzz.yaml

@@ -1,72 +0,0 @@
-name: Daily parser fuzz
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 0 * * *"
-  pull_request:
-    paths:
-      - ".github/workflows/daily_fuzz.yaml"
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-  PACKAGE_NAME: ruff
-  FORCE_COLOR: 1
-
-jobs:
-  fuzz:
-    name: Fuzz
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    # Don't run the cron job on forks:
-    if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.12"
-      - 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
-      - name: "Install Rust toolchain"
-        run: rustup show
-      - name: "Install mold"
-        uses: rui314/setup-mold@v1
-      - uses: Swatinem/rust-cache@v2
-      - name: Build ruff
-        # A debug build means the script runs slower once it gets started,
-        # but this is outweighed by the fact that a release build takes *much* longer to compile in CI
-        run: cargo build --locked
-      - name: Fuzz
-        run: python scripts/fuzz-parser/fuzz.py $(shuf -i 0-9999999999999999999 -n 1000) --test-executable target/debug/ruff
-
-  create-issue-on-failure:
-    name: Create an issue if the daily fuzz surfaced any bugs
-    runs-on: ubuntu-latest
-    needs: fuzz
-    if: ${{ github.repository == 'astral-sh/ruff' && always() && github.event_name == 'schedule' && needs.fuzz.result == 'failure' }}
-    permissions:
-      issues: write
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            await github.rest.issues.create({
-              owner: "astral-sh",
-              repo: "ruff",
-              title: `Daily parser fuzz failed on ${new Date().toDateString()}`,
-              body: "Runs listed here: https://github.com/astral-sh/ruff/actions/workflows/daily_fuzz.yml",
-              labels: ["bug", "parser", "fuzzer"],
-            })

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

@@ -0,0 +1,298 @@
+name: "[flake8-to-ruff] Release"
+
+on: workflow_dispatch
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  PACKAGE_NAME: flake8-to-ruff
+  CRATE_NAME: flake8_to_ruff
+  PYTHON_VERSION: "3.7" # to build abi3 wheels
+
+jobs:
+  macos-x86_64:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels - x86_64
+        uses: messense/maturin-action@v1
+        with:
+          target: x86_64
+          args: --release --out dist --sdist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel - x86_64
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+  macos-universal:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels - universal2
+        uses: messense/maturin-action@v1
+        with:
+          args: --release --universal2 --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel - universal2
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*universal2.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target: [x64, x86]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: ${{ matrix.target }}
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        shell: bash
+        run: |
+          python -m pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64, i686]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  linux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [aarch64, armv7, s390x, ppc64le, ppc64]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --no-default-features --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@v2.0.5
+        if: matrix.target != 'ppc64'
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.target }}
+          distro: ubuntu20.04
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update
+            apt-get install -y --no-install-recommends python3 python3-pip
+            pip3 install -U pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target:
+          - x86_64-unknown-linux-musl
+          - i686-unknown-linux-musl
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64-unknown-linux-musl'
+        uses: addnab/docker-run-action@v3
+        with:
+          image: alpine:latest
+          options: -v ${{ github.workspace }}:/io -w /io
+          run: |
+            apk add py3-pip
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links /io/dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        platform:
+          - target: aarch64-unknown-linux-musl
+            arch: aarch64
+          - target: armv7-unknown-linux-musleabihf
+            arch: armv7
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@master
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.platform.arch }}
+          distro: alpine_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apk add py3-pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  pypy:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        target: [x86_64, aarch64]
+        python-version:
+          - "3.7"
+          - "3.8"
+          - "3.9"
+        exclude:
+          - os: macos-latest
+            target: aarch64
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: pypy${{ matrix.python-version }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          maturin-version: "v0.13.0"
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist -i pypy${{ matrix.python-version }} -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    needs:
+      - macos-universal
+      - macos-x86_64
+      - windows
+      - linux
+      - linux-cross
+      - musllinux
+      - musllinux-cross
+      - pypy
+    steps:
+      - uses: actions/download-artifact@v2
+        with:
+          name: wheels
+      - uses: actions/setup-python@v4
+      - name: Publish to PyPi
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.FLAKE8_TO_RUFF_TOKEN }}
+        run: |
+          pip install --upgrade twine
+          twine upload --skip-existing *

.github/workflows/notify-dependents.yml

@@ -1,29 +0,0 @@
-# Notify downstream repositories of a new release.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a post-announce
-# job within `cargo-dist`.
-name: "[ruff] Notify dependents"
-
-on:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-jobs:
-  update-dependents:
-    name: Notify dependents
-    runs-on: ubuntu-latest
-    steps:
-      - name: "Update pre-commit mirror"
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.RUFF_PRE_COMMIT_PAT }}
-          script: |
-            github.rest.actions.createWorkflowDispatch({
-              owner: 'astral-sh',
-              repo: 'ruff-pre-commit',
-              workflow_id: 'main.yml',
-              ref: 'main',
-            })

.github/workflows/pr-comment.yaml

@@ -1,89 +0,0 @@
-name: Ecosystem check comment
-
-on:
-  workflow_run:
-    workflows: [CI]
-    types: [completed]
-  workflow_dispatch:
-    inputs:
-      workflow_run_id:
-        description: The ecosystem workflow that triggers the workflow run
-        required: true
-
-permissions:
-  pull-requests: write
-
-jobs:
-  comment:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: dawidd6/action-download-artifact@v6
-        name: Download pull request number
-        with:
-          name: pr-number
-          run_id: ${{ github.event.workflow_run.id ||  github.event.inputs.workflow_run_id }}
-          if_no_artifact_found: ignore
-          allow_forks: true
-
-      - name: Parse pull request number
-        id: pr-number
-        run: |
-          if [[ -f pr-number ]]
-          then
-            echo "pr-number=$(<pr-number)" >> $GITHUB_OUTPUT
-          fi
-
-      - uses: dawidd6/action-download-artifact@v6
-        name: "Download ecosystem results"
-        id: download-ecosystem-result
-        if: steps.pr-number.outputs.pr-number
-        with:
-          name: ecosystem-result
-          workflow: ci.yaml
-          pr: ${{ steps.pr-number.outputs.pr-number }}
-          path: pr/ecosystem
-          workflow_conclusion: completed
-          if_no_artifact_found: ignore
-          allow_forks: true
-
-      - name: Generate comment content
-        id: generate-comment
-        if: steps.download-ecosystem-result.outputs.found_artifact == 'true'
-        run: |
-          # Guard against malicious ecosystem results that symlink to a secret
-          # file on this runner
-          if [[ -L pr/ecosystem/ecosystem-result ]]
-          then
-              echo "Error: ecosystem-result cannot be a symlink"
-              exit 1
-          fi
-
-          # Note this identifier is used to find the comment to update on
-          # subsequent runs
-          echo '<!-- generated-comment ecosystem -->' >> comment.txt
-
-          echo '## `ruff-ecosystem` results' >> comment.txt
-          cat pr/ecosystem/ecosystem-result >> comment.txt
-          echo "" >> comment.txt
-
-          echo 'comment<<EOF' >> $GITHUB_OUTPUT
-          cat comment.txt >> $GITHUB_OUTPUT
-          echo 'EOF' >> $GITHUB_OUTPUT
-
-      - name: Find existing comment
-        uses: peter-evans/find-comment@v3
-        if: steps.generate-comment.outcome == 'success'
-        id: find-comment
-        with:
-          issue-number: ${{ steps.pr-number.outputs.pr-number }}
-          comment-author: "github-actions[bot]"
-          body-includes: "<!-- generated-comment ecosystem -->"
-
-      - name: Create or update comment
-        if: steps.find-comment.outcome == 'success'
-        uses: peter-evans/create-or-update-comment@v4
-        with:
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          issue-number: ${{ steps.pr-number.outputs.pr-number }}
-          body-path: comment.txt
-          edit-mode: replace

.github/workflows/publish-docs.yml

@@ -1,152 +0,0 @@
-# Publish the Ruff documentation.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a post-announce
-# job within `cargo-dist`.
-name: mkdocs
-
-on:
-  workflow_dispatch:
-    inputs:
-      ref:
-        description: "The commit SHA, tag, or branch to publish. Uses the default branch if not specified."
-        default: ""
-        type: string
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-jobs:
-  mkdocs:
-    runs-on: ubuntu-latest
-    env:
-      MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ inputs.ref }}
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: 3.12
-
-      - name: "Set docs version"
-        run: |
-          version="${{ (inputs.plan != '' && fromJson(inputs.plan).announcement_tag) || inputs.ref }}"
-          # if version is missing, use 'latest'
-          if [ -z "$version" ]; then
-            echo "Using 'latest' as version"
-            version="latest"
-          fi
-
-          # Use version as display name for now
-          display_name="$version"
-
-          echo "version=$version" >> $GITHUB_ENV
-          echo "display_name=$display_name" >> $GITHUB_ENV
-
-      - name: "Set branch name"
-        run: |
-          version="${{ env.version }}"
-          display_name="${{ env.display_name }}"
-          timestamp="$(date +%s)"
-
-          # create branch_display_name from display_name by replacing all
-          # characters disallowed in git branch names with hyphens
-          branch_display_name="$(echo "$display_name" | tr -c '[:alnum:]._' '-' | tr -s '-')"
-
-          echo "branch_name=update-docs-$branch_display_name-$timestamp" >> $GITHUB_ENV
-          echo "timestamp=$timestamp" >> $GITHUB_ENV
-
-      - name: "Add SSH key"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        uses: webfactory/ssh-agent@v0.9.0
-        with:
-          ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
-
-      - name: "Install Rust toolchain"
-        run: rustup show
-
-      - uses: Swatinem/rust-cache@v2
-
-      - name: "Install Insiders dependencies"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        run: pip install -r docs/requirements-insiders.txt
-
-      - name: "Install dependencies"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
-        run: pip install -r docs/requirements.txt
-
-      - name: "Copy README File"
-        run: |
-          python scripts/transform_readme.py --target mkdocs
-          python scripts/generate_mkdocs.py
-
-      - name: "Build Insiders docs"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
-        run: mkdocs build --strict -f mkdocs.insiders.yml
-
-      - name: "Build docs"
-        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
-        run: mkdocs build --strict -f mkdocs.public.yml
-
-      - name: "Clone docs repo"
-        run: |
-          version="${{ env.version }}"
-          git clone https://${{ secrets.ASTRAL_DOCS_PAT }}@github.com/astral-sh/docs.git astral-docs
-
-      - name: "Copy docs"
-        run: rm -rf astral-docs/site/ruff && mkdir -p astral-docs/site && cp -r site/ruff astral-docs/site/
-
-      - name: "Commit docs"
-        working-directory: astral-docs
-        run: |
-          branch_name="${{ env.branch_name }}"
-
-          git config user.name "astral-docs-bot"
-          git config user.email "176161322+astral-docs-bot@users.noreply.github.com"
-
-          git checkout -b $branch_name
-          git add site/ruff
-          git commit -m "Update ruff documentation for $version"
-
-      - name: "Create Pull Request"
-        working-directory: astral-docs
-        env:
-          GITHUB_TOKEN: ${{ secrets.ASTRAL_DOCS_PAT }}
-        run: |
-          version="${{ env.version }}"
-          display_name="${{ env.display_name }}"
-          branch_name="${{ env.branch_name }}"
-
-          # set the PR title
-          pull_request_title="Update ruff documentation for $display_name"
-
-          # Delete any existing pull requests that are open for this version
-          # by checking against pull_request_title because the new PR will
-          # supersede the old one.
-          gh pr list --state open --json title --jq '.[] | select(.title == "$pull_request_title") | .number' | \
-            xargs -I {} gh pr close {}
-
-          # push the branch to GitHub
-          git push origin $branch_name
-
-          # create the PR
-          gh pr create --base main --head $branch_name \
-            --title "$pull_request_title" \
-            --body "Automated documentation update for $display_name" \
-            --label "documentation"
-
-      - name: "Merge Pull Request"
-        if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-        working-directory: astral-docs
-        env:
-          GITHUB_TOKEN: ${{ secrets.ASTRAL_DOCS_PAT }}
-        run: |
-          branch_name="${{ env.branch_name }}"
-
-          # auto-merge the PR if the build was triggered by a release. Manual builds should be reviewed by a human.
-          # give the PR a few seconds to be created before trying to auto-merge it
-          sleep 10
-          gh pr merge --squash $branch_name

.github/workflows/publish-playground.yml

@@ -1,55 +0,0 @@
-# Publish the Ruff playground.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a post-announce
-# job within `cargo-dist`.
-name: "[Playground] Release"
-
-on:
-  workflow_dispatch:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    env:
-      CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup target add wasm32-unknown-unknown
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: "npm"
-          cache-dependency-path: playground/package-lock.json
-      - uses: jetli/wasm-pack-action@v0.4.0
-      - uses: jetli/wasm-bindgen-action@v0.2.0
-      - name: "Run wasm-pack"
-        run: wasm-pack build --target web --out-dir ../../playground/src/pkg crates/ruff_wasm
-      - name: "Install Node dependencies"
-        run: npm ci
-        working-directory: playground
-      - name: "Run TypeScript checks"
-        run: npm run check
-        working-directory: playground
-      - name: "Build JavaScript bundle"
-        run: npm run build
-        working-directory: playground
-      - name: "Deploy to Cloudflare Pages"
-        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
-        uses: cloudflare/wrangler-action@v3.11.0
-        with:
-          apiToken: ${{ secrets.CF_API_TOKEN }}
-          accountId: ${{ secrets.CF_ACCOUNT_ID }}
-          # `github.head_ref` is only set during pull requests and for manual runs or tags we use `main` to deploy to production
-          command: pages deploy playground/dist --project-name=ruff-playground --branch ${{ github.head_ref || 'main' }} --commit-hash ${GITHUB_SHA}

.github/workflows/publish-pypi.yml

@@ -1,32 +0,0 @@
-# Publish a release to PyPI.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a publish job
-# within `cargo-dist`.
-name: "[ruff] Publish to PyPI"
-
-on:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-jobs:
-  pypi-publish:
-    name: Upload to PyPI
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    permissions:
-      # For PyPI's trusted publishing.
-      id-token: write
-    steps:
-      - name: "Install uv"
-        uses: astral-sh/setup-uv@v3
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: wheels-*
-          path: wheels
-          merge-multiple: true
-      - name: Publish to PyPi
-        run: uv publish -v wheels/*

.github/workflows/publish-wasm.yml

@@ -1,55 +0,0 @@
-# Build and publish ruff-api for wasm.
-#
-# Assumed to run as a subworkflow of .github/workflows/release.yml; specifically, as a publish
-# job within `cargo-dist`.
-name: "Build and publish wasm"
-
-on:
-  workflow_dispatch:
-  workflow_call:
-    inputs:
-      plan:
-        required: true
-        type: string
-
-env:
-  CARGO_INCREMENTAL: 0
-  CARGO_NET_RETRY: 10
-  CARGO_TERM_COLOR: always
-  RUSTUP_MAX_RETRIES: 10
-
-jobs:
-  ruff_wasm:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    strategy:
-      matrix:
-        target: [web, bundler, nodejs]
-      fail-fast: false
-    steps:
-      - uses: actions/checkout@v4
-      - name: "Install Rust toolchain"
-        run: rustup target add wasm32-unknown-unknown
-      - uses: jetli/wasm-pack-action@v0.4.0
-      - uses: jetli/wasm-bindgen-action@v0.2.0
-      - name: "Run wasm-pack build"
-        run: wasm-pack build --target ${{ matrix.target }} crates/ruff_wasm
-      - name: "Rename generated package"
-        run: | # Replace the package name w/ jq
-          jq '.name="@astral-sh/ruff-wasm-${{ matrix.target }}"' crates/ruff_wasm/pkg/package.json > /tmp/package.json
-          mv /tmp/package.json crates/ruff_wasm/pkg
-      - run: cp LICENSE crates/ruff_wasm/pkg # wasm-pack does not put the LICENSE file in the pkg
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: "https://registry.npmjs.org"
-      - name: "Publish (dry-run)"
-        if: ${{ inputs.plan == '' || fromJson(inputs.plan).announcement_tag_is_implicit }}
-        run: npm publish --dry-run crates/ruff_wasm/pkg
-      - name: "Publish"
-        if: ${{ inputs.plan != '' && !fromJson(inputs.plan).announcement_tag_is_implicit }}
-        run: npm publish --provenance --access public crates/ruff_wasm/pkg
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/release.yml

@@ -1,300 +0,0 @@
-# This file was autogenerated by cargo-dist: https://opensource.axo.dev/cargo-dist/
-#
-# Copyright 2022-2024, axodotdev
-# SPDX-License-Identifier: MIT or Apache-2.0
-#
-# CI that:
-#
-# * checks for a Git Tag that looks like a release
-# * builds artifacts with cargo-dist (archives, installers, hashes)
-# * uploads those artifacts to temporary workflow zip
-# * on success, uploads the artifacts to a GitHub Release
-#
-# Note that the GitHub Release will be created with a generated
-# title/body based on your changelogs.
-
-name: Release
-permissions:
-  "contents": "write"
-
-# This task will run whenever you workflow_dispatch with a tag that looks like a version
-# like "1.0.0", "v0.1.0-prerelease.1", "my-app/0.1.0", "releases/v1.0.0", etc.
-# Various formats will be parsed into a VERSION and an optional PACKAGE_NAME, where
-# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION
-# must be a Cargo-style SemVer Version (must have at least major.minor.patch).
-#
-# If PACKAGE_NAME is specified, then the announcement will be for that
-# package (erroring out if it doesn't have the given version or isn't cargo-dist-able).
-#
-# If PACKAGE_NAME isn't specified, then the announcement will be for all
-# (cargo-dist-able) packages in the workspace with that version (this mode is
-# intended for workspaces with only one dist-able package, or with all dist-able
-# packages versioned/released in lockstep).
-#
-# If you push multiple tags at once, separate instances of this workflow will
-# spin up, creating an independent announcement for each one. However, GitHub
-# will hard limit this to 3 tags per commit, as it will assume more tags is a
-# mistake.
-#
-# If there's a prerelease-style suffix to the version, then the release(s)
-# will be marked as a prerelease.
-on:
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: Release Tag
-        required: true
-        default: dry-run
-        type: string
-
-jobs:
-  # Run 'cargo dist plan' (or host) to determine what tasks we need to do
-  plan:
-    runs-on: "ubuntu-20.04"
-    outputs:
-      val: ${{ steps.plan.outputs.manifest }}
-      tag: ${{ (inputs.tag != 'dry-run' && inputs.tag) || '' }}
-      tag-flag: ${{ inputs.tag && inputs.tag != 'dry-run' && format('--tag={0}', inputs.tag) || '' }}
-      publishing: ${{ inputs.tag && inputs.tag != 'dry-run' }}
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - name: Install cargo-dist
-        # we specify bash to get pipefail; it guards against the `curl` command
-        # failing. otherwise `sh` won't catch that `curl` returned non-0
-        shell: bash
-        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.22.1/cargo-dist-installer.sh | sh"
-      - name: Cache cargo-dist
-        uses: actions/upload-artifact@v4
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/cargo-dist
-      # sure would be cool if github gave us proper conditionals...
-      # so here's a doubly-nested ternary-via-truthiness to try to provide the best possible
-      # functionality based on whether this is a pull_request, and whether it's from a fork.
-      # (PRs run on the *source* but secrets are usually on the *target* -- that's *good*
-      # but also really annoying to build CI around when it needs secrets to work right.)
-      - id: plan
-        run: |
-          cargo dist ${{ (inputs.tag && inputs.tag != 'dry-run' && format('host --steps=create --tag={0}', inputs.tag)) || 'plan' }} --output-format=json > plan-dist-manifest.json
-          echo "cargo dist ran successfully"
-          cat plan-dist-manifest.json
-          echo "manifest=$(jq -c "." plan-dist-manifest.json)" >> "$GITHUB_OUTPUT"
-      - name: "Upload dist-manifest.json"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-plan-dist-manifest
-          path: plan-dist-manifest.json
-
-  custom-build-binaries:
-    needs:
-      - plan
-    if: ${{ needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload' || inputs.tag == 'dry-run' }}
-    uses: ./.github/workflows/build-binaries.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-
-  custom-build-docker:
-    needs:
-      - plan
-    if: ${{ needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload' || inputs.tag == 'dry-run' }}
-    uses: ./.github/workflows/build-docker.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-    permissions:
-      "contents": "read"
-      "packages": "write"
-
-  # Build and package all the platform-agnostic(ish) things
-  build-global-artifacts:
-    needs:
-      - plan
-      - custom-build-binaries
-      - custom-build-docker
-    runs-on: "ubuntu-20.04"
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      BUILD_MANIFEST_NAME: target/distrib/global-dist-manifest.json
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - name: Install cached cargo-dist
-        uses: actions/download-artifact@v4
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/cargo-dist
-      # Get all the local artifacts for the global tasks to use (for e.g. checksums)
-      - name: Fetch local artifacts
-        uses: actions/download-artifact@v4
-        with:
-          pattern: artifacts-*
-          path: target/distrib/
-          merge-multiple: true
-      - id: cargo-dist
-        shell: bash
-        run: |
-          cargo dist build ${{ needs.plan.outputs.tag-flag }} --output-format=json "--artifacts=global" > dist-manifest.json
-          echo "cargo dist ran successfully"
-
-          # Parse out what we just built and upload it to scratch storage
-          echo "paths<<EOF" >> "$GITHUB_OUTPUT"
-          jq --raw-output ".upload_files[]" dist-manifest.json >> "$GITHUB_OUTPUT"
-          echo "EOF" >> "$GITHUB_OUTPUT"
-
-          cp dist-manifest.json "$BUILD_MANIFEST_NAME"
-      - name: "Upload artifacts"
-        uses: actions/upload-artifact@v4
-        with:
-          name: artifacts-build-global
-          path: |
-            ${{ steps.cargo-dist.outputs.paths }}
-            ${{ env.BUILD_MANIFEST_NAME }}
-  # Determines if we should publish/announce
-  host:
-    needs:
-      - plan
-      - custom-build-binaries
-      - custom-build-docker
-      - build-global-artifacts
-    # Only run if we're "publishing", and only if local and global didn't fail (skipped is fine)
-    if: ${{ always() && needs.plan.outputs.publishing == 'true' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs.custom-build-binaries.result == 'skipped' || needs.custom-build-binaries.result == 'success') && (needs.custom-build-docker.result == 'skipped' || needs.custom-build-docker.result == 'success') }}
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    runs-on: "ubuntu-20.04"
-    outputs:
-      val: ${{ steps.host.outputs.manifest }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      - name: Install cached cargo-dist
-        uses: actions/download-artifact@v4
-        with:
-          name: cargo-dist-cache
-          path: ~/.cargo/bin/
-      - run: chmod +x ~/.cargo/bin/cargo-dist
-      # Fetch artifacts from scratch-storage
-      - name: Fetch artifacts
-        uses: actions/download-artifact@v4
-        with:
-          pattern: artifacts-*
-          path: target/distrib/
-          merge-multiple: true
-      # This is a harmless no-op for GitHub Releases, hosting for that happens in "announce"
-      - id: host
-        shell: bash
-        run: |
-          cargo dist host ${{ needs.plan.outputs.tag-flag }} --steps=upload --steps=release --output-format=json > dist-manifest.json
-          echo "artifacts uploaded and released successfully"
-          cat dist-manifest.json
-          echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT"
-      - name: "Upload dist-manifest.json"
-        uses: actions/upload-artifact@v4
-        with:
-          # Overwrite the previous copy
-          name: artifacts-dist-manifest
-          path: dist-manifest.json
-
-  custom-publish-pypi:
-    needs:
-      - plan
-      - host
-    if: ${{ !fromJson(needs.plan.outputs.val).announcement_is_prerelease || fromJson(needs.plan.outputs.val).publish_prereleases }}
-    uses: ./.github/workflows/publish-pypi.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-    # publish jobs get escalated permissions
-    permissions:
-      "id-token": "write"
-      "packages": "write"
-
-  custom-publish-wasm:
-    needs:
-      - plan
-      - host
-    if: ${{ !fromJson(needs.plan.outputs.val).announcement_is_prerelease || fromJson(needs.plan.outputs.val).publish_prereleases }}
-    uses: ./.github/workflows/publish-wasm.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-    # publish jobs get escalated permissions
-    permissions:
-      "contents": "read"
-      "id-token": "write"
-      "packages": "write"
-
-  # Create a GitHub Release while uploading all files to it
-  announce:
-    needs:
-      - plan
-      - host
-      - custom-publish-pypi
-      - custom-publish-wasm
-    # use "always() && ..." to allow us to wait for all publish jobs while
-    # still allowing individual publish jobs to skip themselves (for prereleases).
-    # "host" however must run to completion, no skipping allowed!
-    if: ${{ always() && needs.host.result == 'success' && (needs.custom-publish-pypi.result == 'skipped' || needs.custom-publish-pypi.result == 'success') && (needs.custom-publish-wasm.result == 'skipped' || needs.custom-publish-wasm.result == 'success') }}
-    runs-on: "ubuntu-20.04"
-    env:
-      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: recursive
-      # Create a GitHub Release while uploading all files to it
-      - name: "Download GitHub Artifacts"
-        uses: actions/download-artifact@v4
-        with:
-          pattern: artifacts-*
-          path: artifacts
-          merge-multiple: true
-      - name: Cleanup
-        run: |
-          # Remove the granular manifests
-          rm -f artifacts/*-dist-manifest.json
-      - name: Create GitHub Release
-        env:
-          PRERELEASE_FLAG: "${{ fromJson(needs.host.outputs.val).announcement_is_prerelease && '--prerelease' || '' }}"
-          ANNOUNCEMENT_TITLE: "${{ fromJson(needs.host.outputs.val).announcement_title }}"
-          ANNOUNCEMENT_BODY: "${{ fromJson(needs.host.outputs.val).announcement_github_body }}"
-          RELEASE_COMMIT: "${{ github.sha }}"
-        run: |
-          # Write and read notes from a file to avoid quoting breaking things
-          echo "$ANNOUNCEMENT_BODY" > $RUNNER_TEMP/notes.txt
-
-          gh release create "${{ needs.plan.outputs.tag }}" --target "$RELEASE_COMMIT" $PRERELEASE_FLAG --title "$ANNOUNCEMENT_TITLE" --notes-file "$RUNNER_TEMP/notes.txt" artifacts/*
-
-  custom-notify-dependents:
-    needs:
-      - plan
-      - announce
-    uses: ./.github/workflows/notify-dependents.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-
-  custom-publish-docs:
-    needs:
-      - plan
-      - announce
-    uses: ./.github/workflows/publish-docs.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit
-
-  custom-publish-playground:
-    needs:
-      - plan
-      - announce
-    uses: ./.github/workflows/publish-playground.yml
-    with:
-      plan: ${{ needs.plan.outputs.val }}
-    secrets: inherit

.github/workflows/ruff.yaml

@@ -0,0 +1,301 @@
+name: "[ruff] Release"
+
+on:
+  create:
+    tags:
+      - v*
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  PACKAGE_NAME: ruff
+  PYTHON_VERSION: "3.7" # to build abi3 wheels
+
+jobs:
+  macos-x86_64:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels - x86_64
+        uses: messense/maturin-action@v1
+        with:
+          target: x86_64
+          args: --release --out dist --sdist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel - x86_64
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+  macos-universal:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels - universal2
+        uses: messense/maturin-action@v1
+        with:
+          args: --release --universal2 --out dist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel - universal2
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*universal2.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target: [x64, x86]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: ${{ matrix.target }}
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          default: true
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        shell: bash
+        run: |
+          python -m pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64, i686]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  linux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [aarch64, armv7, s390x, ppc64le, ppc64]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --no-default-features --release --out dist
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@v2.0.5
+        if: matrix.target != 'ppc64'
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.target }}
+          distro: ubuntu20.04
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update
+            apt-get install -y --no-install-recommends python3 python3-pip
+            pip3 install -U pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target:
+          - x86_64-unknown-linux-musl
+          - i686-unknown-linux-musl
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64-unknown-linux-musl'
+        uses: addnab/docker-run-action@v3
+        with:
+          image: alpine:latest
+          options: -v ${{ github.workspace }}:/io -w /io
+          run: |
+            apk add py3-pip
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links /io/dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        platform:
+          - target: aarch64-unknown-linux-musl
+            arch: aarch64
+          - target: armv7-unknown-linux-musleabihf
+            arch: armv7
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@master
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.platform.arch }}
+          distro: alpine_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apk add py3-pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  pypy:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        target: [x86_64, aarch64]
+        python-version:
+          - "3.7"
+          - "3.8"
+          - "3.9"
+        exclude:
+          - os: macos-latest
+            target: aarch64
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: pypy${{ matrix.python-version }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          maturin-version: "v0.13.0"
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist -i pypy${{ matrix.python-version }}
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    needs:
+      - macos-universal
+      - macos-x86_64
+      - windows
+      - linux
+      - linux-cross
+      - musllinux
+      - musllinux-cross
+      - pypy
+    if: "startsWith(github.ref, 'refs/tags/')"
+    steps:
+      - uses: actions/download-artifact@v2
+        with:
+          name: wheels
+      - uses: actions/setup-python@v4
+      - name: Publish to PyPi
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.RUFF_TOKEN }}
+        run: |
+          pip install --upgrade twine
+          twine upload --skip-existing *

.github/workflows/sync_typeshed.yaml

@@ -1,80 +0,0 @@
-name: Sync typeshed
-
-on:
-  workflow_dispatch:
-  schedule:
-    # Run on the 1st and the 15th of every month:
-    - cron: "0 0 1,15 * *"
-
-env:
-  FORCE_COLOR: 1
-  GH_TOKEN: ${{ github.token }}
-
-jobs:
-  sync:
-    name: Sync typeshed
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    # Don't run the cron job on forks:
-    if: ${{ github.repository == 'astral-sh/ruff' || github.event_name != 'schedule' }}
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        name: Checkout Ruff
-        with:
-          path: ruff
-      - uses: actions/checkout@v4
-        name: Checkout typeshed
-        with:
-          repository: python/typeshed
-          path: typeshed
-      - name: Setup git
-        run: |
-          git config --global user.name typeshedbot
-          git config --global user.email '<>'
-      - name: Sync typeshed
-        id: sync
-        run: |
-          rm -rf ruff/crates/red_knot_vendored/vendor/typeshed
-          mkdir ruff/crates/red_knot_vendored/vendor/typeshed
-          cp typeshed/README.md ruff/crates/red_knot_vendored/vendor/typeshed
-          cp typeshed/LICENSE ruff/crates/red_knot_vendored/vendor/typeshed
-          cp -r typeshed/stdlib ruff/crates/red_knot_vendored/vendor/typeshed/stdlib
-          rm -rf ruff/crates/red_knot_vendored/vendor/typeshed/stdlib/@tests
-          git -C typeshed rev-parse HEAD > ruff/crates/red_knot_vendored/vendor/typeshed/source_commit.txt
-      - name: Commit the changes
-        id: commit
-        if: ${{ steps.sync.outcome == 'success' }}
-        run: |
-          cd ruff
-          git checkout -b typeshedbot/sync-typeshed
-          git add .
-          git diff --staged --quiet || git commit -m "Sync typeshed. Source commit: https://github.com/python/typeshed/commit/$(git -C ../typeshed rev-parse HEAD)"
-      - name: Create a PR
-        if: ${{ steps.sync.outcome == 'success' && steps.commit.outcome == 'success' }}
-        run: |
-          cd ruff
-          git push --force origin typeshedbot/sync-typeshed
-          gh pr list --repo $GITHUB_REPOSITORY --head typeshedbot/sync-typeshed --json id --jq length | grep 1 && exit 0 # exit if there is existing pr
-          gh pr create --title "Sync vendored typeshed stubs" --body "Close and reopen this PR to trigger CI" --label "internal"
-
-  create-issue-on-failure:
-    name: Create an issue if the typeshed sync failed
-    runs-on: ubuntu-latest
-    needs: [sync]
-    if: ${{ github.repository == 'astral-sh/ruff' && always() && github.event_name == 'schedule' && needs.sync.result == 'failure' }}
-    permissions:
-      issues: write
-    steps:
-      - uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            await github.rest.issues.create({
-              owner: "astral-sh",
-              repo: "ruff",
-              title: `Automated typeshed sync failed on ${new Date().toDateString()}`,
-              body: "Runs are listed here: https://github.com/astral-sh/ruff/actions/workflows/sync_typeshed.yaml",
-            })

.gitignore

@@ -1,33 +1,6 @@
-# Benchmarking cpython (CONTRIBUTING.md)
-crates/ruff_linter/resources/test/cpython
-# generate_mkdocs.py
-mkdocs.generated.yml
-# check_ecosystem.py
-ruff-old
-github_search*.jsonl
-# update_schemastore.py
-schemastore
-# `maturin develop` and ecosystem_all_check.sh
-.venv*
-# Formatter debugging (crates/ruff_python_formatter/README.md)
-scratch.*
-# Created by `perf` (CONTRIBUTING.md)
-perf.data
-perf.data.old
-# Created by `flamegraph` (CONTRIBUTING.md)
-flamegraph.svg
-# Additional target directories that don't invalidate the main compile cache when changing linker settings,
-# e.g. `CARGO_TARGET_DIR=target-maturin maturin build --release --strip` or
-# `CARGO_TARGET_DIR=target-llvm-lines RUSTFLAGS="-Csymbol-mangling-version=v0" cargo llvm-lines -p ruff --lib`
-/target*
-
-# samply profiles
-profile.json
-
-# tracing-flame traces
-tracing.folded
-tracing-flamechart.svg
-tracing-flamegraph.svg
+# Local cache
+.ruff_cache
+resources/test/cpython
 
 ###
 # Rust.gitignore
@@ -100,7 +73,6 @@ coverage.xml
 .hypothesis/
 .pytest_cache/
 cover/
-repos/
 
 # Translations
 *.mo
@@ -209,17 +181,3 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 .idea/
-.vimspector.json
-
-# Visual Studio Code
-.vscode/
-
-# VIM
-.*.sw?
-.sw?
-
-# Custom re-inclusions for the resolver test cases
-!crates/ruff_python_resolver/resources/test/airflow/venv/
-!crates/ruff_python_resolver/resources/test/airflow/venv/lib
-!crates/ruff_python_resolver/resources/test/airflow/venv/lib/python3.11/site-packages/_watchdog_fsevents.cpython-311-darwin.so
-!crates/ruff_python_resolver/resources/test/airflow/venv/lib/python3.11/site-packages/orjson/orjson.cpython-311-darwin.so

.markdownlint.yaml

@@ -1,23 +0,0 @@
-# default to true for all rules
-default: true
-
-# MD007/unordered-list-indent
-MD007:
-  indent: 4
-
-# MD033/no-inline-html
-MD033: false
-
-# MD041/first-line-h1
-MD041: false
-
-# MD013/line-length
-MD013: false
-
-# MD014/commands-show-output
-MD014: false
-
-# MD024/no-duplicate-heading
-MD024:
-  # Allow when nested under different parents e.g. CHANGELOG.md
-  siblings_only: true

.pre-commit-config.yaml

@@ -1,92 +1,10 @@
-fail_fast: false
-
-exclude: |
-  (?x)^(
-    crates/red_knot_vendored/vendor/.*|
-    crates/red_knot_workspace/resources/.*|
-    crates/ruff_linter/resources/.*|
-    crates/ruff_linter/src/rules/.*/snapshots/.*|
-    crates/ruff_notebook/resources/.*|
-    crates/ruff_server/resources/.*|
-    crates/ruff/resources/.*|
-    crates/ruff_python_formatter/resources/.*|
-    crates/ruff_python_formatter/tests/snapshots/.*|
-    crates/ruff_python_resolver/resources/.*|
-    crates/ruff_python_resolver/tests/snapshots/.*
-  )$
-
 repos:
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.0.107
+    hooks:
+      - id: ruff
+
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.22
+    rev: v0.10.1
     hooks:
       - id: validate-pyproject
-
-  - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.18
-    hooks:
-      - id: mdformat
-        additional_dependencies:
-          - mdformat-mkdocs
-          - mdformat-admon
-          - mdformat-footnote
-        exclude: |
-          (?x)^(
-            docs/formatter/black\.md
-            | docs/\w+\.md
-          )$
-
-  - repo: https://github.com/igorshubovych/markdownlint-cli
-    rev: v0.42.0
-    hooks:
-      - id: markdownlint-fix
-        exclude: |
-          (?x)^(
-            docs/formatter/black\.md
-            | docs/\w+\.md
-          )$
-
-  - repo: https://github.com/adamchainz/blacken-docs
-    rev: 1.19.1
-    hooks:
-      - id: blacken-docs
-        args: ["--pyi", "--line-length", "130"]
-        files: '^crates/.*/resources/mdtest/.*\.md'
-        exclude: |
-          (?x)^(
-            .*?invalid(_.+)_syntax.md
-          )$
-        additional_dependencies:
-          - black==24.10.0
-
-  - repo: https://github.com/crate-ci/typos
-    rev: v1.27.0
-    hooks:
-      - id: typos
-
-  - repo: local
-    hooks:
-      - id: cargo-fmt
-        name: cargo fmt
-        entry: cargo fmt --
-        language: system
-        types: [rust]
-        pass_filenames: false # This makes it a lot faster
-
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.2
-    hooks:
-      - id: ruff-format
-      - id: ruff
-        args: [--fix, --exit-non-zero-on-fix]
-        types_or: [python, pyi]
-        require_serial: true
-
-  # Prettier
-  - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.3.3
-    hooks:
-      - id: prettier
-        types: [yaml]
-
-ci:
-  skip: [cargo-fmt, dev-generate-all]

.prettierignore

@@ -1,2 +0,0 @@
-# Auto-generated by `cargo-dist`.
-.github/workflows/release.yml

.vscode/extensions.json

@@ -1,5 +0,0 @@
-{
-    "recommendations": [
-        "rust-lang.rust-analyzer"
-    ]
-}

.vscode/settings.json

@@ -1,6 +0,0 @@
-{
-    "rust-analyzer.check.extraArgs": [
-        "--all-features"
-    ],
-    "rust-analyzer.check.command": "clippy",
-}

BREAKING_CHANGES.md

@@ -1,478 +0,0 @@
-# Breaking Changes
-
-## 0.7.0
-
-- The pytest rules `PT001` and `PT023` now default to omitting the decorator parentheses when there are no arguments
-    ([#12838](https://github.com/astral-sh/ruff/pull/12838), [#13292](https://github.com/astral-sh/ruff/pull/13292)).
-    This was a change that we attempted to make in Ruff v0.6.0, but only partially made due to an error on our part.
-    See the [blog post](https://astral.sh/blog/ruff-v0.7.0) for more details.
-- The `useless-try-except` rule (in our `tryceratops` category) has been recoded from `TRY302` to
-    `TRY203` ([#13502](https://github.com/astral-sh/ruff/pull/13502)). This ensures Ruff's code is consistent with
-    the same rule in the [`tryceratops`](https://github.com/guilatrova/tryceratops) linter.
-- The `lint.allow-unused-imports` setting has been removed ([#13677](https://github.com/astral-sh/ruff/pull/13677)). Use
-    [`lint.pyflakes.allow-unused-imports`](https://docs.astral.sh/ruff/settings/#lint_pyflakes_allowed-unused-imports)
-    instead.
-
-## 0.6.0
-
-- Detect imports in `src` layouts by default for `isort` rules ([#12848](https://github.com/astral-sh/ruff/pull/12848))
-
-- The pytest rules `PT001` and `PT023` now default to omitting the decorator parentheses when there are no arguments ([#12838](https://github.com/astral-sh/ruff/pull/12838)).
-
-- Lint and format Jupyter Notebook by default ([#12878](https://github.com/astral-sh/ruff/pull/12878)).
-
-    You can disable specific rules for notebooks using [`per-file-ignores`](https://docs.astral.sh/ruff/settings/#lint_per-file-ignores):
-
-    ```toml
-    [tool.ruff.lint.per-file-ignores]
-    "*.ipynb" = ["E501"] # disable line-too-long in notebooks
-    ```
-
-    If you'd prefer to either only lint or only format Jupyter Notebook files, you can use the
-    section-specific `exclude` option to do so. For example, the following would only lint Jupyter
-    Notebook files and not format them:
-
-    ```toml
-    [tool.ruff.format]
-    exclude = ["*.ipynb"]
-    ```
-
-    And, conversely, the following would only format Jupyter Notebook files and not lint them:
-
-    ```toml
-    [tool.ruff.lint]
-    exclude = ["*.ipynb"]
-    ```
-
-    You can completely disable Jupyter Notebook support by updating the [`extend-exclude`](https://docs.astral.sh/ruff/settings/#extend-exclude) setting:
-
-    ```toml
-    [tool.ruff]
-    extend-exclude = ["*.ipynb"]
-    ```
-
-## 0.5.0
-
-- Follow the XDG specification to discover user-level configurations on macOS (same as on other Unix platforms)
-- Selecting `ALL` now excludes deprecated rules
-- The released archives now include an extra level of nesting, which can be removed with `--strip-components=1` when untarring.
-- The release artifact's file name no longer includes the version tag. This enables users to install via `/latest` URLs on GitHub.
-
-## 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))
-
-Ruff maintains a list of default exclusions, which now consists of the following patterns:
-
-- `.bzr`
-- `.direnv`
-- `.eggs`
-- `.git-rewrite`
-- `.git`
-- `.hg`
-- `.ipynb_checkpoints`
-- `.mypy_cache`
-- `.nox`
-- `.pants.d`
-- `.pyenv`
-- `.pytest_cache`
-- `.pytype`
-- `.ruff_cache`
-- `.svn`
-- `.tox`
-- `.venv`
-- `.vscode`
-- `__pypackages__`
-- `_build`
-- `buck-out`
-- `build`
-- `dist`
-- `node_modules`
-- `site-packages`
-- `venv`
-
-Previously, the `site-packages` directory was not excluded by default. While `site-packages` tends
-to be excluded anyway by virtue of the `.venv` exclusion, this may not be the case when using Ruff
-from VS Code outside a virtual environment.
-
-## 0.1.0
-
-### The deprecated `format` setting has been removed
-
-Ruff previously used the `format` setting, `--format` CLI option, and `RUFF_FORMAT` environment variable to
-configure the output format of the CLI. This usage was deprecated in `v0.0.291` — the `format` setting is now used
-to control Ruff's code formatting. As of this release:
-
-- The `format` setting cannot be used to configure the output format, use `output-format` instead
-- The `RUFF_FORMAT` environment variable is ignored, use `RUFF_OUTPUT_FORMAT` instead
-- The `--format` option has been removed from `ruff check`, use `--output-format` instead
-
-### Unsafe fixes are not applied by default ([#7769](https://github.com/astral-sh/ruff/pull/7769))
-
-Ruff labels fixes as "safe" and "unsafe". The meaning and intent of your code will be retained when applying safe
-fixes, but the meaning could be changed when applying unsafe fixes. Previously, unsafe fixes were always displayed
-and applied when fixing was enabled. Now, unsafe fixes are hidden by default and not applied. The `--unsafe-fixes`
-flag or `unsafe-fixes` configuration option can be used to enable unsafe fixes.
-
-See the [docs](https://docs.astral.sh/ruff/configuration/#fix-safety) for details.
-
-### Remove formatter-conflicting rules from the default rule set  ([#7900](https://github.com/astral-sh/ruff/pull/7900))
-
-Previously, Ruff enabled all implemented rules in Pycodestyle (`E`) by default. Ruff now only includes the
-Pycodestyle prefixes `E4`, `E7`, and `E9` to exclude rules that conflict with automatic formatters. Consequently,
-the stable rule set no longer includes `line-too-long` (`E501`) and `mixed-spaces-and-tabs` (`E101`). Other
-excluded Pycodestyle rules include whitespace enforcement in `E1` and `E2`; these rules are currently in preview, and are already omitted by default.
-
-This change only affects those using Ruff under its default rule set. Users that include `E` in their `select` will experience no change in behavior.
-
-## 0.0.288
-
-### Remove support for emoji identifiers ([#7212](https://github.com/astral-sh/ruff/pull/7212))
-
-Previously, Ruff supported the non-standard compliant emoji identifiers e.g. `📦 = 1`.
-We decided to remove this non-standard language extension, and Ruff now reports syntax errors for emoji identifiers in your code, the same as CPython.
-
-### Improved GitLab fingerprints ([#7203](https://github.com/astral-sh/ruff/pull/7203))
-
-GitLab uses fingerprints to identify new, existing, or fixed violations. Previously, Ruff included the violation's position in the fingerprint. Using the location has the downside that changing any code before the violation causes the fingerprint to change, resulting in GitLab reporting one fixed and one new violation even though it is a pre-existing violation.
-
-Ruff now uses a more stable location-agnostic fingerprint to minimize that existing violations incorrectly get marked as fixed and re-reported as new violations.
-
-Expect GitLab to report each pre-existing violation in your project as fixed and a new violation in your Ruff upgrade PR.
-
-## 0.0.283 / 0.284
-
-### The target Python version now defaults to 3.8 instead of 3.10 ([#6397](https://github.com/astral-sh/ruff/pull/6397))
-
-Previously, when a target Python version was not specified, Ruff would use a default of Python 3.10. However, it is safer to default to an _older_ Python version to avoid assuming the availability of new features. We now default to the oldest supported Python version which is currently Python 3.8.
-
-(We still support Python 3.7 but since [it has reached EOL](https://devguide.python.org/versions/#unsupported-versions) we've decided not to make it the default here.)
-
-Note this change was announced in 0.0.283 but not active until 0.0.284.
-
-## 0.0.277
-
-### `.ipynb_checkpoints`, `.pyenv`, `.pytest_cache`, and `.vscode` are now excluded by default ([#5513](https://github.com/astral-sh/ruff/pull/5513))
-
-Ruff maintains a list of default exclusions, which 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`
-- `build`
-- `dist`
-- `node_modules`
-- `venv`
-
-Previously, the `.ipynb_checkpoints`, `.pyenv`, `.pytest_cache`, and `.vscode` directories were not
-excluded by default. This change brings Ruff's default exclusions in line with other tools like
-Black.
-
-## 0.0.276
-
-### The `keep-runtime-typing` setting has been reinstated ([#5470](https://github.com/astral-sh/ruff/pull/5470))
-
-The `keep-runtime-typing` setting has been reinstated with revised semantics. This setting was
-removed in [#4427](https://github.com/astral-sh/ruff/pull/4427), as it was equivalent to ignoring
-the `UP006` and `UP007` rules via Ruff's standard `ignore` mechanism.
-
-Taking `UP006` (rewrite `List[int]` to `list[int]`) as an example, the setting now behaves as
-follows:
-
-- On Python 3.7 and Python 3.8, setting `keep-runtime-typing = true` will cause Ruff to ignore
-    `UP006` violations, even if `from __future__ import annotations` is present in the file.
-    While such annotations are valid in Python 3.7 and Python 3.8 when combined with
-    `from __future__ import annotations`, they aren't supported by libraries like Pydantic and
-    FastAPI, which rely on runtime type checking.
-- On Python 3.9 and above, the setting has no effect, as `list[int]` is a valid type annotation,
-    and libraries like Pydantic and FastAPI support it without issue.
-
-In short: `keep-runtime-typing` can be used to ensure that Ruff doesn't introduce type annotations
-that are not supported at runtime by the current Python version, which are unsupported by libraries
-like Pydantic and FastAPI.
-
-Note that this is not a breaking change, but is included here to complement the previous removal
-of `keep-runtime-typing`.
-
-## 0.0.268
-
-### The `keep-runtime-typing` setting has been removed ([#4427](https://github.com/astral-sh/ruff/pull/4427))
-
-Enabling the `keep-runtime-typing` option, located under the `pyupgrade` section, is equivalent
-to ignoring the `UP006` and `UP007` rules via Ruff's standard `ignore` mechanism. As there's no
-need for a dedicated setting to disable these rules, the `keep-runtime-typing` option has been
-removed.
-
-## 0.0.267
-
-### `update-check` is no longer a valid configuration option ([#4313](https://github.com/astral-sh/ruff/pull/4313))
-
-The `update-check` functionality was deprecated in [#2530](https://github.com/astral-sh/ruff/pull/2530),
-in that the behavior itself was removed, and Ruff was changed to warn when that option was enabled.
-
-Now, Ruff will throw an error when `update-check` is provided via a configuration file (e.g.,
-`update-check = false`) or through the command-line, since it has no effect. Users should remove
-this option from their configuration.
-
-## 0.0.265
-
-### `--fix-only` now exits with a zero exit code, unless `--exit-non-zero-on-fix` is specified ([#4146](https://github.com/astral-sh/ruff/pull/4146))
-
-Previously, `--fix-only` would exit with a non-zero exit code if any fixes were applied. This
-behavior was inconsistent with `--fix`, and further, meant that `--exit-non-zero-on-fix` was
-effectively ignored when `--fix-only` was specified.
-
-Now, `--fix-only` will exit with a zero exit code, unless `--exit-non-zero-on-fix` is specified,
-in which case it will exit with a non-zero exit code if any fixes were applied.
-
-## 0.0.260
-
-### Fixes are now represented as a list of edits ([#3709](https://github.com/astral-sh/ruff/pull/3709))
-
-Previously, Ruff represented each fix as a single edit, which prohibited Ruff from automatically
-fixing violations that required multiple edits across a file. As such, Ruff now represents each
-fix as a list of edits.
-
-This primarily affects the JSON API. Ruff's JSON representation used to represent the `fix` field as
-a single edit, like so:
-
-```json
-{
-    "message": "Remove unused import: `sys`",
-    "content": "",
-    "location": {"row": 1, "column": 0},
-    "end_location": {"row": 2, "column": 0}
-}
-```
-
-The updated representation instead includes a list of edits:
-
-```json
-{
-    "message": "Remove unused import: `sys`",
-    "edits": [
-        {
-            "content": "",
-            "location": {"row": 1, "column": 0},
-            "end_location": {"row": 2, "column": 0},
-        }
-    ]
-}
-```
-
-## 0.0.246
-
-### `multiple-statements-on-one-line-def` (`E704`) was removed ([#2773](https://github.com/astral-sh/ruff/pull/2773))
-
-This rule was introduced in v0.0.245. However, it turns out that pycodestyle and Flake8 ignore this
-rule by default, as it is not part of PEP 8. As such, we've removed it from Ruff.
-
-## 0.0.245
-
-### Ruff's public `check` method was removed ([#2709](https://github.com/astral-sh/ruff/pull/2709))
-
-Previously, Ruff exposed a `check` method as a public Rust API. This method was used by few,
-if any clients, and was not well documented or supported. As such, it has been removed, with
-the intention of adding a stable public API in the future.
-
-## 0.0.238
-
-### `select`, `extend-select`, `ignore`, and `extend-ignore` have new semantics ([#2312](https://github.com/astral-sh/ruff/pull/2312))
-
-Previously, the interplay between `select` and its related options could lead to unexpected
-behavior. For example, `ruff --select E501 --ignore ALL` and `ruff --select E501 --extend-ignore ALL`
-behaved differently. (See [#2312](https://github.com/astral-sh/ruff/pull/2312) for more
-examples.)
-
-When Ruff determines the enabled rule set, it has to reconcile `select` and `ignore` from a variety
-of sources, including the current `pyproject.toml`, any inherited `pyproject.toml` files, and the
-CLI.
-
-The new semantics are such that Ruff uses the "highest-priority" `select` as the basis for the rule
-set, and then applies any `extend-select`, `ignore`, and `extend-ignore` adjustments. CLI options
-are given higher priority than `pyproject.toml` options, and the current `pyproject.toml` file is
-given higher priority than any inherited `pyproject.toml` files.
-
-`extend-select` and `extend-ignore` are no longer given "top priority"; instead, they merely append
-to the `select` and `ignore` lists, as in Flake8.
-
-This change is largely backwards compatible -- most users should experience no change in behavior.
-However, as an example of a breaking change, consider the following:
-
-```toml
-[tool.ruff]
-ignore = ["F401"]
-```
-
-Running `ruff --select F` would previously have enabled all `F` rules, apart from `F401`. Now, it
-will enable all `F` rules, including `F401`, as the command line's `--select` resets the resolution.
-
-### `remove-six-compat` (`UP016`) has been removed ([#2332](https://github.com/astral-sh/ruff/pull/2332))
-
-The `remove-six-compat` rule has been removed. This rule was only useful for one-time Python 2-to-3
-upgrades.
-
-## 0.0.237
-
-### `--explain`, `--clean`, and `--generate-shell-completion` are now subcommands ([#2190](https://github.com/astral-sh/ruff/pull/2190))
-
-`--explain`, `--clean`, and `--generate-shell-completion` are now implemented as subcommands:
-
-```console
-ruff .         # Still works! And will always work.
-ruff check .   # New! Also works.
-
-ruff --explain E402   # Still works.
-ruff rule E402        # New! Also works. (And preferred.)
-
-# Oops! The command has to come first.
-ruff --format json --explain E402   # No longer works.
-ruff --explain E402 --format json   # Still works!
-ruff rule E402   --format json      # Works! (And preferred.)
-```
-
-This change is largely backwards compatible -- most users should experience
-no change in behavior. However, please note the following exceptions:
-
-- Subcommands will now fail when invoked with unsupported arguments, instead
-    of silently ignoring them. For example, the following will now fail:
-
-    ```console
-    ruff --clean --respect-gitignore
-    ```
-
-    (the `clean` command doesn't support `--respect-gitignore`.)
-
-- The semantics of `ruff <arg>` have changed slightly when `<arg>` is a valid subcommand.
-    For example, prior to this release, running `ruff rule` would run `ruff` over a file or
-    directory called `rule`. Now, `ruff rule` would invoke the `rule` subcommand. This should
-    only impact projects with files or directories named `rule`, `check`, `explain`, `clean`,
-    or `generate-shell-completion`.
-
-- Scripts that invoke ruff should supply `--` before any positional arguments.
-    (The semantics of `ruff -- <arg>` have not changed.)
-
-- `--explain` previously treated `--format grouped` as a synonym for `--format text`.
-    This is no longer supported; instead, use `--format text`.
-
-## 0.0.226
-
-### `misplaced-comparison-constant` (`PLC2201`) was deprecated in favor of `SIM300` ([#1980](https://github.com/astral-sh/ruff/pull/1980))
-
-These two rules contain (nearly) identical logic. To deduplicate the rule set, we've upgraded
-`SIM300` to handle a few more cases, and deprecated `PLC2201` in favor of `SIM300`.
-
-## 0.0.225
-
-### `@functools.cache` rewrites have been moved to a standalone rule (`UP033`) ([#1938](https://github.com/astral-sh/ruff/pull/1938))
-
-Previously, `UP011` handled both `@functools.lru_cache()`-to-`@functools.lru_cache` conversions,
-_and_ `@functools.lru_cache(maxsize=None)`-to-`@functools.cache` conversions. The latter has been
-moved out to its own rule (`UP033`). As such, some `# noqa: UP011` comments may need to be updated
-to reflect the change in rule code.
-
-## 0.0.222
-
-### `--max-complexity` has been removed from the CLI ([#1877](https://github.com/astral-sh/ruff/pull/1877))
-
-The McCabe plugin's `--max-complexity` setting has been removed from the CLI, for consistency with
-the treatment of other, similar settings.
-
-To set the maximum complexity, use the `max-complexity` property in your `pyproject.toml` file,
-like so:
-
-```toml
-[tool.ruff.mccabe]
-max-complexity = 10
-```
-
-## 0.0.181
-
-### Files excluded by `.gitignore` are now ignored ([#1234](https://github.com/astral-sh/ruff/pull/1234))
-
-Ruff will now avoid checking files that are excluded by `.ignore`, `.gitignore`,
-`.git/info/exclude`, and global `gitignore` files. This behavior is powered by the [`ignore`](https://docs.rs/ignore/latest/ignore/struct.WalkBuilder.html#ignore-rules)
-crate, and is applied in addition to Ruff's built-in `exclude` system.
-
-To disable this behavior, set `respect-gitignore = false` in your `pyproject.toml` file.
-
-Note that hidden files (i.e., files and directories prefixed with a `.`) are _not_ ignored by
-default.
-
-## 0.0.178
-
-### Configuration files are now resolved hierarchically ([#1190](https://github.com/astral-sh/ruff/pull/1190))
-
-`pyproject.toml` files are now resolved hierarchically, such that for each Python file, we find
-the first `pyproject.toml` file in its path, and use that to determine its lint settings.
-
-See the [documentation](https://docs.astral.sh/ruff/configuration/#python-file-discovery) for more.

CODE_OF_CONDUCT.md

@@ -1,17 +1,5 @@
 # Contributor Covenant Code of Conduct
 
-- [Our Pledge](#our-pledge)
-- [Our Standards](#our-standards)
-- [Enforcement Responsibilities](#enforcement-responsibilities)
-- [Scope](#scope)
-- [Enforcement](#enforcement)
-- [Enforcement Guidelines](#enforcement-guidelines)
-    - [1. Correction](#1-correction)
-    - [2. Warning](#2-warning)
-    - [3. Temporary Ban](#3-temporary-ban)
-    - [4. Permanent Ban](#4-permanent-ban)
-- [Attribution](#attribution)
-
 ## Our Pledge
 
 We as members, contributors, and leaders pledge to make participation in our
@@ -29,24 +17,24 @@ diverse, inclusive, and healthy community.
 Examples of behavior that contributes to a positive environment for our
 community include:
 
-- Demonstrating empathy and kindness toward other people
-- Being respectful of differing opinions, viewpoints, and experiences
-- Giving and gracefully accepting constructive feedback
-- Accepting responsibility and apologizing to those affected by our mistakes,
-    and learning from the experience
-- Focusing on what is best not just for us as individuals, but for the
-    overall community
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
 
 Examples of unacceptable behavior include:
 
-- The use of sexualized language or imagery, and sexual attention or
-    advances of any kind
-- Trolling, insulting or derogatory comments, and personal or political attacks
-- Public or private harassment
-- Publishing others' private information, such as a physical or email
-    address, without their explicit permission
-- Other conduct which could reasonably be considered inappropriate in a
-    professional setting
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
 
 ## Enforcement Responsibilities
 
@@ -72,7 +60,7 @@ representative at an online or offline event.
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
 reported to the community leaders responsible for enforcement at
-<charlie.r.marsh@gmail.com>.
+charlie.r.marsh@gmail.com.
 All complaints will be reviewed and investigated promptly and fairly.
 
 All community leaders are obligated to respect the privacy and security of the
@@ -118,7 +106,7 @@ Violating these terms may lead to a permanent ban.
 ### 4. Permanent Ban
 
 **Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior, harassment of an
+standards, including sustained inappropriate behavior,  harassment of an
 individual, or aggression toward or disparagement of classes of individuals.
 
 **Consequence**: A permanent ban from any sort of public interaction within
@@ -127,12 +115,14 @@ the community.
 ## Attribution
 
 This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available [here](https://www.contributor-covenant.org/version/2/0/code_of_conduct.html).
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
 
 Community Impact Guidelines were inspired by [Mozilla's code of conduct
 enforcement ladder](https://github.com/mozilla/diversity).
 
-For answers to common questions about this code of conduct, see the [FAQ](https://www.contributor-covenant.org/faq).
-Translations are available [here](https://www.contributor-covenant.org/translations).
-
 [homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -2,21 +2,12 @@
 
 Welcome! We're happy to have you here. Thank you in advance for your contribution to Ruff.
 
-## The Basics
+## The basics
 
-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.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 have suggestions on how we might improve the contributing documentation, [let us know](https://github.com/astral-sh/ruff/discussions/5693)!
+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 submitting an [Issue](https://github.com/charliermarsh/ruff/issues) outlining
+your proposed change.
 
 ### Prerequisites
 
@@ -29,262 +20,85 @@ You'll also need [Insta](https://insta.rs/docs/) to update snapshot tests:
 cargo install cargo-insta
 ```
 
-You'll need [uv](https://docs.astral.sh/uv/getting-started/installation/) (or `pipx` and `pip`) to
-run Python utility commands.
-
-You can optionally install pre-commit hooks to automatically run the validation checks
-when making a commit:
-
-```shell
-uv tool install pre-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:
+After cloning the repository, run Ruff locally with:
 
 ```shell
-cargo run -p ruff -- check /path/to/file.py --no-cache
+cargo run resources/test/fixtures --no-cache
 ```
 
-Prior to opening a pull request, ensure that your code has been auto-formatted,
-and that it passes both the lint and test validation checks:
+Prior to opening a pull request, ensure that your code has been auto-formatted, and that it passes
+both the lint and test validation checks:
 
 ```shell
-cargo clippy --workspace --all-targets --all-features -- -D warnings  # Rust linting
-RUFF_UPDATE_SCHEMA=1 cargo test  # Rust testing and updating ruff.schema.json
-uvx pre-commit run --all-files --show-diff-on-failure  # Rust and Python formatting, Markdown and Python linting, etc.
+cargo +nightly fmt --all     # Auto-formatting...
+cargo +nightly clippy --all  # Linting...
+cargo +nightly test --all    # Testing...
 ```
 
-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.
 
-If you're using VS Code, you can also install the recommended [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer) extension to get these checks while editing.
-
-Note that many code changes also require updating the snapshot tests, which is done interactively
-after running `cargo test` like so:
-
-```shell
-cargo insta review
-```
-
-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
+Your Pull Request will be reviewed by a maintainer, which may involve a few rounds of iteration
 prior to merging.
 
-### Project Structure
-
-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_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:
-
-- `crates/ruff_linter`: library crate containing all lint rules and the core logic for running them.
-    If you're working on a rule, this is the crate for you.
-- `crates/ruff_benchmark`: binary crate for running micro-benchmarks.
-- `crates/ruff_cache`: library crate for caching lint results.
-- `crates/ruff`: binary crate containing Ruff's command-line interface.
-- `crates/ruff_dev`: binary crate containing utilities used in the development of Ruff itself (e.g.,
-    `cargo dev generate-all`), see the [`cargo dev`](#cargo-dev) section below.
-- `crates/ruff_diagnostics`: library crate for the rule-independent abstractions in the lint
-    diagnostics APIs.
-- `crates/ruff_formatter`: library crate for language agnostic code formatting logic based on an
-    intermediate representation. The backend for `ruff_python_formatter`.
-- `crates/ruff_index`: library crate inspired by `rustc_index`.
-- `crates/ruff_macros`: proc macro crate containing macros used by Ruff.
-- `crates/ruff_notebook`: library crate for parsing and manipulating Jupyter notebooks.
-- `crates/ruff_python_ast`: library crate containing Python-specific AST types and utilities.
-- `crates/ruff_python_codegen`: library crate containing utilities for generating Python source code.
-- `crates/ruff_python_formatter`: library crate implementing the Python formatter. Emits an
-    intermediate representation for each node, which `ruff_formatter` prints based on the configured
-    line length.
-- `crates/ruff_python_semantic`: library crate containing Python-specific semantic analysis logic,
-    including Ruff's semantic model. Used to resolve queries like "What import does this variable
-    refer to?"
-- `crates/ruff_python_stdlib`: library crate containing Python-specific standard library data, e.g.
-    the names of all built-in exceptions and which standard library types are immutable.
-- `crates/ruff_python_trivia`: library crate containing Python-specific trivia utilities (e.g.,
-    for analyzing indentation, newlines, etc.).
-- `crates/ruff_python_parser`: library crate containing the Python parser.
-- `crates/ruff_wasm`: library crate for exposing Ruff as a WebAssembly module. Powers the
-    [Ruff Playground](https://play.ruff.rs/).
-
 ### Example: Adding a new lint rule
 
-At a high level, the steps involved in adding a new lint rule are as follows:
+There are four phases to adding a new lint rule:
 
-1. Determine a name for the new rule as per our [rule naming convention](#rule-naming-convention)
-    (e.g., `AssertFalse`, as in, "allow `assert False`").
+1. Define the rule in `src/checks.rs`.
+2. Define the _logic_ for triggering the rule in `src/check_ast.rs` (for AST-based checks),
+   `src/check_tokens.rs` (for token-based checks), or `src/check_lines.rs` (for text-based checks).
+3. Add a test fixture.
+4. Update the generated files (documentation and generated code).
 
-1. Create a file for your rule (e.g., `crates/ruff_linter/src/rules/flake8_bugbear/rules/assert_false.rs`).
+To define the rule, open up `src/checks.rs`. You'll need to define both a `CheckCode` and
+`CheckKind`. As an example, you can grep for `E402` and `ModuleImportNotAtTopOfFile`, and follow the
+pattern implemented therein.
 
-1. In that file, define a violation struct (e.g., `pub struct AssertFalse`). You can grep for
-    `#[violation]` to see examples.
+To trigger the rule, you'll likely want to augment the logic in `src/check_ast.rs`, which defines
+the Python AST visitor, responsible for iterating over the abstract syntax tree and collecting
+lint-rule violations as it goes. If you need to inspect the AST, you can run `cargo dev print-ast`
+with a Python file. Grep for the `Check::new` invocations to understand how other, similar rules
+are implemented.
 
-1. In that file, define a function that adds the violation to the diagnostic list as appropriate
-    (e.g., `pub(crate) fn assert_false`) based on whatever inputs are required for the rule (e.g.,
-    an `ast::StmtAssert` node).
+To add a test fixture, create a file under `resources/test/fixtures`, named to match the `CheckCode`
+you defined earlier (e.g., `E402.py`). This file should contain a variety of violations and
+non-violations designed to evaluate and demonstrate the behavior of your lint rule. Run Ruff locally
+with (e.g.) `cargo run resources/test/fixtures/E402.py --no-cache`. Once you're satisfied with the
+output, codify the behavior as a snapshot test by adding a new `testcase` macro to the `mod tests`
+section of `src/linter.rs`, like so:
 
-1. Define the logic for invoking the diagnostic in `crates/ruff_linter/src/checkers/ast/analyze` (for
-    AST-based rules), `crates/ruff_linter/src/checkers/tokens.rs` (for token-based rules),
-    `crates/ruff_linter/src/checkers/physical_lines.rs` (for text-based rules),
-    `crates/ruff_linter/src/checkers/filesystem.rs` (for filesystem-based rules), etc. For AST-based rules,
-    you'll likely want to modify `analyze/statement.rs` (if your rule is based on analyzing
-    statements, like imports) or `analyze/expression.rs` (if your rule is based on analyzing
-    expressions, like function calls).
+```rust
+#[test_case(CheckCode::A001, Path::new("A001.py"); "A001")]
+...
+```
 
-1. Map the violation struct to a rule code in `crates/ruff_linter/src/codes.rs` (e.g., `B011`). New rules
-    should be added in `RuleGroup::Preview`.
+Then, run `cargo test`. Your test will fail, but you'll be prompted to follow-up with
+`cargo insta review`. Accept the generated snapshot, then commit the snapshot file alongside the
+rest of your changes.
 
-1. Add proper [testing](#rule-testing-fixtures-and-snapshots) for your rule.
-
-1. Update the generated files (documentation and generated code).
-
-To trigger the violation, you'll likely want to augment the logic in `crates/ruff_linter/src/checkers/ast.rs`
-to call your new function at the appropriate time and with the appropriate inputs. The `Checker`
-defined therein is a Python AST visitor, which iterates over the AST, building up a semantic model,
-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)), and regenerate the documentation and
-associated 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
-
-Like Clippy, Ruff's rule names should make grammatical and logical sense when read as "allow
-${rule}" or "allow ${rule} items", as in the context of suppression comments.
-
-For example, `AssertFalse` fits this convention: it flags `assert False` statements, and so a
-suppression comment would be framed as "allow `assert False`".
-
-As such, rule names should...
-
-- Highlight the pattern that is being linted against, rather than the preferred alternative.
-    For example, `AssertFalse` guards against `assert False` statements.
-
-- _Not_ contain instructions on how to fix the violation, which instead belong in the rule
-    documentation and the `fix_title`.
-
-- _Not_ contain a redundant prefix, like `Disallow` or `Banned`, which are already implied by the
-    convention.
-
-When re-implementing rules from other linters, we prioritize adhering to this convention over
-preserving the original rule name.
-
-#### Rule testing: fixtures and snapshots
-
-To test rules, Ruff uses snapshots of Ruff's output for a given file (fixture). Generally, there
-will be one file per rule (e.g., `E402.py`), and each file will contain all necessary examples of
-both violations and non-violations. `cargo insta review` will generate a snapshot file containing
-Ruff's output for each fixture, which you can then commit alongside your changes.
-
-Once you've completed the code for the rule itself, you can define tests with the following steps:
-
-1. Add a Python file to `crates/ruff_linter/resources/test/fixtures/[linter]` that contains the code you
-    want to test. The file name should match the rule name (e.g., `E402.py`), and it should include
-    examples of both violations and non-violations.
-
-1. Run Ruff locally against your file and verify the output is as expected. Once you're satisfied
-    with the output (you see the violations you expect, and no others), proceed to the next step.
-    For example, if you're adding a new rule named `E402`, you would run:
-
-    ```shell
-    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
-    you activate it by adding `--select ${rule_code}` to the command.
-
-1. Add the test to the relevant `crates/ruff_linter/src/rules/[linter]/mod.rs` file. If you're contributing
-    a rule to a pre-existing set, you should be able to find a similar example to pattern-match
-    against. If you're adding a new linter, you'll need to create a new `mod.rs` file (see,
-    e.g., `crates/ruff_linter/src/rules/flake8_bugbear/mod.rs`)
-
-1. Run `cargo test`. Your test will fail, but you'll be prompted to follow-up
-    with `cargo insta review`. Run `cargo insta review`, review and accept the generated snapshot,
-    then commit the snapshot file alongside the rest of your changes.
-
-1. Run `cargo test` again to ensure that your test passes.
+Finally, to update the documentation, run `cargo dev generate-rules-table` from the repo root. To
+update the generated prefix map, run `cargo dev generate-check-code-prefix`. Both of these commands
+should be run whenever a new check is added to the codebase.
 
 ### Example: Adding a new configuration option
 
-Ruff's user-facing settings live in a few different places.
+Ruff's user-facing settings live in two places: first, the command-line options defined with
+[clap](https://docs.rs/clap/latest/clap/) via the `Cli` struct in `src/main.rs`; and second, the
+`Config` struct defined `src/pyproject.rs`, which is responsible for extracting user-defined
+settings from a `pyproject.toml` file.
 
-First, the command-line options are defined via the `Args` struct in `crates/ruff/src/args.rs`.
+Ultimately, these two sources of configuration are merged into the `Settings` struct defined
+in `src/settings.rs`, which is then threaded through the codebase.
 
-Second, the `pyproject.toml` options are defined in `crates/ruff_workspace/src/options.rs` (via the
-`Options` struct), `crates/ruff_workspace/src/configuration.rs` (via the `Configuration` struct),
-and `crates/ruff_workspace/src/settings.rs` (via the `Settings` struct), which then includes
-the `LinterSettings` struct as a field.
+To add a new configuration option, you'll likely want to _both_ add a CLI option to `src/main.rs`
+_and_ a `pyproject.toml` parameter to `src/pyproject.rs`. If you want to pattern-match against an
+existing example, grep for `dummy_variable_rgx`, which defines a regular expression to match against
+acceptable unused variables (e.g., `_`).
 
-These represent, respectively: the schema used to parse the `pyproject.toml` file; an internal,
-intermediate representation; and the final, internal representation used to power Ruff.
-
-To add a new configuration option, you'll likely want to modify these latter few files (along with
-`args.rs`, if appropriate). If you want to pattern-match against an existing example, grep for
-`dummy_variable_rgx`, which defines a regular expression to match against acceptable unused
-variables (e.g., `_`).
-
-Note that plugin-specific configuration options are defined in their own modules (e.g.,
-`Settings` in `crates/ruff_linter/src/flake8_unused_arguments/settings.rs` coupled with
-`Flake8UnusedArgumentsOptions` in `crates/ruff_workspace/src/options.rs`).
-
-Finally, regenerate the documentation and generated code with `cargo dev generate-all`.
-
-## MkDocs
-
-To preview any changes to the documentation locally:
-
-1. Install the [Rust toolchain](https://www.rust-lang.org/tools/install).
-
-1. Generate the MkDocs site with:
-
-    ```shell
-    uv run --no-project --isolated --with-requirements docs/requirements.txt scripts/generate_mkdocs.py
-    ```
-
-1. Run the development server with:
-
-    ```shell
-    # For contributors.
-    uvx --with-requirements docs/requirements.txt -- mkdocs serve -f mkdocs.public.yml
-
-    # For members of the Astral org, which has access to MkDocs Insiders via sponsorship.
-    uvx --with-requirements docs/requirements-insiders.txt -- mkdocs serve -f mkdocs.insiders.yml
-    ```
-
-The documentation should then be available locally at
-[http://127.0.0.1:8000/ruff/](http://127.0.0.1:8000/ruff/).
-
-## Release Process
+## Release process
 
 As of now, Ruff has an ad hoc release process: releases are cut with high frequency via GitHub
 Actions, which automatically generates the appropriate wheels across architectures and publishes
@@ -292,617 +106,3 @@ them to [PyPI](https://pypi.org/project/ruff/).
 
 Ruff follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
 even patch releases may contain [non-backwards-compatible changes](https://semver.org/#spec-item-4).
-
-### Creating a new release
-
-1. Install `uv`: `curl -LsSf https://astral.sh/uv/install.sh | sh`
-
-1. Run `./scripts/release.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
-
-1. Highlight any breaking changes in `BREAKING_CHANGES.md`
-
-1. Run `cargo check`. This should update the lock file with new versions.
-
-1. Create a pull request with the changelog and version updates
-
-1. Merge the PR
-
-1. Run the [release workflow](https://github.com/astral-sh/ruff/actions/workflows/release.yml) with:
-
-    - The new version number (without starting `v`)
-
-1. The release workflow will do the following:
-
-    1. Build all the assets. If this fails (even though we tested in step 4), we haven't tagged or
-        uploaded anything, you can restart after pushing a fix. If you just need to rerun the build,
-        make sure you're [re-running all the failed
-        jobs](https://docs.github.com/en/actions/managing-workflow-runs/re-running-workflows-and-jobs#re-running-failed-jobs-in-a-workflow) and not just a single failed job.
-    1. Upload to PyPI.
-    1. Create and push the Git tag (as extracted from `pyproject.toml`). We create the Git tag only
-        after building the wheels and uploading to PyPI, since we can't delete or modify the tag ([#4468](https://github.com/astral-sh/ruff/issues/4468)).
-    1. Attach artifacts to draft GitHub release
-    1. Trigger downstream repositories. This can fail non-catastrophically, as we can run any
-        downstream jobs manually if needed.
-
-1. Verify the GitHub release:
-
-    1. The Changelog should match the content of `CHANGELOG.md`
-    1. Append the contributors from the `scripts/release.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.
-    1. Once run successfully, you should follow the link in the output to create a PR.
-
-1. If needed, update the [`ruff-lsp`](https://github.com/astral-sh/ruff-lsp) and
-    [`ruff-vscode`](https://github.com/astral-sh/ruff-vscode) repositories and follow
-    the release instructions in those repositories. `ruff-lsp` should always be updated
-    before `ruff-vscode`.
-
-    This step is generally not required for a patch release, but should always be done
-    for a minor release.
-
-## Ecosystem CI
-
-GitHub Actions will run your changes against a number of real-world projects from GitHub and
-report on any linter or formatter differences. You can also run those checks locally via:
-
-```shell
-uvx --from ./python/ruff-ecosystem ruff-ecosystem check ruff "./target/debug/ruff"
-uvx --from ./python/ruff-ecosystem ruff-ecosystem format ruff "./target/debug/ruff"
-```
-
-See the [ruff-ecosystem package](https://github.com/astral-sh/ruff/tree/main/python/ruff-ecosystem) for more details.
-
-## Benchmarking and Profiling
-
-We have several ways of benchmarking and profiling Ruff:
-
-- Our main performance benchmark comparing Ruff with other tools on the CPython codebase
-- 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,
-which makes it a good target for benchmarking.
-
-```shell
-git clone --branch 3.10 https://github.com/python/cpython.git crates/ruff_linter/resources/test/cpython
-```
-
-Install `hyperfine`:
-
-```shell
-cargo install hyperfine
-```
-
-To benchmark the release build:
-
-```shell
-cargo build --release && hyperfine --warmup 10 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache -e" \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ -e"
-
-Benchmark 1: ./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache
-  Time (mean ± σ):     293.8 ms ±   3.2 ms    [User: 2384.6 ms, System: 90.3 ms]
-  Range (min … max):   289.9 ms … 301.6 ms    10 runs
-
-Benchmark 2: ./target/release/ruff ./crates/ruff_linter/resources/test/cpython/
-  Time (mean ± σ):      48.0 ms ±   3.1 ms    [User: 65.2 ms, System: 124.7 ms]
-  Range (min … max):    45.0 ms …  66.7 ms    62 runs
-
-Summary
-  './target/release/ruff ./crates/ruff_linter/resources/test/cpython/' ran
-    6.12 ± 0.41 times faster than './target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache'
-```
-
-To benchmark against the ecosystem's existing tools:
-
-```shell
-hyperfine --ignore-failure --warmup 5 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache" \
-  "pyflakes crates/ruff_linter/resources/test/cpython" \
-  "autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython" \
-  "pycodestyle crates/ruff_linter/resources/test/cpython" \
-  "flake8 crates/ruff_linter/resources/test/cpython"
-
-Benchmark 1: ./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache
-  Time (mean ± σ):     294.3 ms ±   3.3 ms    [User: 2467.5 ms, System: 89.6 ms]
-  Range (min … max):   291.1 ms … 302.8 ms    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Benchmark 2: pyflakes crates/ruff_linter/resources/test/cpython
-  Time (mean ± σ):     15.786 s ±  0.143 s    [User: 15.560 s, System: 0.214 s]
-  Range (min … max):   15.640 s … 16.157 s    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Benchmark 3: autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython
-  Time (mean ± σ):      6.175 s ±  0.169 s    [User: 54.102 s, System: 1.057 s]
-  Range (min … max):    5.950 s …  6.391 s    10 runs
-
-Benchmark 4: pycodestyle crates/ruff_linter/resources/test/cpython
-  Time (mean ± σ):     46.921 s ±  0.508 s    [User: 46.699 s, System: 0.202 s]
-  Range (min … max):   46.171 s … 47.863 s    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Benchmark 5: flake8 crates/ruff_linter/resources/test/cpython
-  Time (mean ± σ):     12.260 s ±  0.321 s    [User: 102.934 s, System: 1.230 s]
-  Range (min … max):   11.848 s … 12.933 s    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Summary
-  './target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache' ran
-   20.98 ± 0.62 times faster than 'autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython'
-   41.66 ± 1.18 times faster than 'flake8 crates/ruff_linter/resources/test/cpython'
-   53.64 ± 0.77 times faster than 'pyflakes crates/ruff_linter/resources/test/cpython'
-  159.43 ± 2.48 times faster than 'pycodestyle crates/ruff_linter/resources/test/cpython'
-```
-
-To benchmark a subset of rules, e.g. `LineTooLong` and `DocLineTooLong`:
-
-```shell
-cargo build --release && hyperfine --warmup 10 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache -e --select W505,E501"
-```
-
-You can run `poetry install` from `./scripts/benchmarks` to create a working environment for the
-above. All reported benchmarks were computed using the versions specified by
-`./scripts/benchmarks/pyproject.toml` on Python 3.11.
-
-To benchmark Pylint, remove the following files from the CPython repository:
-
-```shell
-rm Lib/test/bad_coding.py \
-  Lib/test/bad_coding2.py \
-  Lib/test/bad_getattr.py \
-  Lib/test/bad_getattr2.py \
-  Lib/test/bad_getattr3.py \
-  Lib/test/badcert.pem \
-  Lib/test/badkey.pem \
-  Lib/test/badsyntax_3131.py \
-  Lib/test/badsyntax_future10.py \
-  Lib/test/badsyntax_future3.py \
-  Lib/test/badsyntax_future4.py \
-  Lib/test/badsyntax_future5.py \
-  Lib/test/badsyntax_future6.py \
-  Lib/test/badsyntax_future7.py \
-  Lib/test/badsyntax_future8.py \
-  Lib/test/badsyntax_future9.py \
-  Lib/test/badsyntax_pep3120.py \
-  Lib/test/test_asyncio/test_runners.py \
-  Lib/test/test_copy.py \
-  Lib/test/test_inspect.py \
-  Lib/test/test_typing.py
-```
-
-Then, from `crates/ruff_linter/resources/test/cpython`, run: `time pylint -j 0 -E $(git ls-files '*.py')`. This
-will execute Pylint with maximum parallelism and only report errors.
-
-To benchmark Pyupgrade, run the following from `crates/ruff_linter/resources/test/cpython`:
-
-```shell
-hyperfine --ignore-failure --warmup 5 --prepare "git reset --hard HEAD" \
-  "find . -type f -name \"*.py\" | xargs -P 0 pyupgrade --py311-plus"
-
-Benchmark 1: find . -type f -name "*.py" | xargs -P 0 pyupgrade --py311-plus
-  Time (mean ± σ):     30.119 s ±  0.195 s    [User: 28.638 s, System: 0.390 s]
-  Range (min … max):   29.813 s … 30.356 s    10 runs
-```
-
-### Microbenchmarks
-
-The `ruff_benchmark` crate benchmarks the linter and the formatter on individual files.
-
-You can run the benchmarks with
-
-```shell
-cargo benchmark
-```
-
-`cargo benchmark` is an alias for `cargo bench -p ruff_benchmark --bench linter --bench formatter --`
-
-#### Benchmark-driven Development
-
-Ruff uses [Criterion.rs](https://bheisler.github.io/criterion.rs/book/) for benchmarks. You can use
-`--save-baseline=<name>` to store an initial baseline benchmark (e.g. on `main`) and then use
-`--benchmark=<name>` to compare against that benchmark. Criterion will print a message telling you
-if the benchmark improved/regressed compared to that baseline.
-
-```shell
-# Run once on your "baseline" code
-cargo bench -p ruff_benchmark -- --save-baseline=main
-
-# Then iterate with
-cargo bench -p ruff_benchmark -- --baseline=main
-```
-
-#### PR Summary
-
-You can use `--save-baseline` and `critcmp` to get a pretty comparison between two recordings.
-This is useful to illustrate the improvements of a PR.
-
-```shell
-# On main
-cargo bench -p ruff_benchmark -- --save-baseline=main
-
-# After applying your changes
-cargo bench -p ruff_benchmark -- --save-baseline=pr
-
-critcmp main pr
-```
-
-You must install [`critcmp`](https://github.com/BurntSushi/critcmp) for the comparison.
-
-```bash
-cargo install critcmp
-```
-
-#### Tips
-
-- Use `cargo bench -p ruff_benchmark <filter>` to only run specific benchmarks. For example: `cargo bench -p ruff_benchmark lexer`
-    to only run the lexer benchmarks.
-- Use `cargo bench -p ruff_benchmark -- --quiet` for a more cleaned up output (without statistical relevance)
-- Use `cargo bench -p ruff_benchmark -- --quick` to get faster results (more prone to noise)
-
-### Profiling Projects
-
-You can either use the microbenchmarks from above or a project directory for benchmarking. There
-are a lot of profiling tools out there,
-[The Rust Performance Book](https://nnethercote.github.io/perf-book/profiling.html) lists some
-examples.
-
-#### Linux
-
-Install `perf` and build `ruff_benchmark` with the `profiling` profile and then run it with perf
-
-```shell
-cargo bench -p ruff_benchmark --no-run --profile=profiling && perf record --call-graph dwarf -F 9999 cargo bench -p ruff_benchmark --profile=profiling -- --profile-time=1
-```
-
-You can also use the `ruff_dev` launcher to run `ruff check` multiple times on a repository to
-gather enough samples for a good flamegraph (change the 999, the sample rate, and the 30, the number
-of checks, to your liking)
-
-```shell
-cargo build --bin ruff_dev --profile=profiling
-perf record -g -F 999 target/profiling/ruff_dev repeat --repeat 30 --exit-zero --no-cache path/to/cpython > /dev/null
-```
-
-Then convert the recorded profile
-
-```shell
-perf script -F +pid > /tmp/test.perf
-```
-
-You can now view the converted file with [firefox profiler](https://profiler.firefox.com/), with a
-more in-depth guide [here](https://profiler.firefox.com/docs/#/./guide-perf-profiling)
-
-An alternative is to convert the perf data to `flamegraph.svg` using
-[flamegraph](https://github.com/flamegraph-rs/flamegraph) (`cargo install flamegraph`):
-
-```shell
-flamegraph --perfdata perf.data --no-inline
-```
-
-#### Mac
-
-Install [`cargo-instruments`](https://crates.io/crates/cargo-instruments):
-
-```shell
-cargo install cargo-instruments
-```
-
-Then run the profiler with
-
-```shell
-cargo instruments -t time --bench linter --profile profiling -p ruff_benchmark -- --profile-time=1
-```
-
-- `-t`: Specifies what to profile. Useful options are `time` to profile the wall time and `alloc`
-    for profiling the allocations.
-- You may want to pass an additional filter to run a single test file
-
-Otherwise, follow the instructions from the linux section.
-
-## `cargo dev`
-
-`cargo dev` is a shortcut for `cargo run --package ruff_dev --bin ruff_dev`. You can run some useful
-utils with it:
-
-- `cargo dev print-ast <file>`: Print the AST of a python file using Ruff's
-    [Python parser](https://github.com/astral-sh/ruff/tree/main/crates/ruff_python_parser).
-    For `if True: pass # comment`, you can see the syntax tree, the byte offsets for start and
-    stop of each node and also how the `:` token, the comment and whitespace are not represented
-    anymore:
-
-```text
-[
-    If(
-        StmtIf {
-            range: 0..13,
-            test: Constant(
-                ExprConstant {
-                    range: 3..7,
-                    value: Bool(
-                        true,
-                    ),
-                    kind: None,
-                },
-            ),
-            body: [
-                Pass(
-                    StmtPass {
-                        range: 9..13,
-                    },
-                ),
-            ],
-            orelse: [],
-        },
-    ),
-]
-```
-
-- `cargo dev print-tokens <file>`: Print the tokens that the AST is built upon. Again for
-    `if True: pass # comment`:
-
-```text
-0 If 2
-3 True 7
-7 Colon 8
-9 Pass 13
-14 Comment(
-    "# comment",
-) 23
-23 Newline 24
-```
-
-- `cargo dev print-cst <file>`: Print the CST of a python file using
-    [LibCST](https://github.com/Instagram/LibCST), which is used in addition to the RustPython parser
-    in Ruff. E.g. for `if True: pass # comment` everything including the whitespace is represented:
-
-```text
-Module {
-    body: [
-        Compound(
-            If(
-                If {
-                    test: Name(
-                        Name {
-                            value: "True",
-                            lpar: [],
-                            rpar: [],
-                        },
-                    ),
-                    body: SimpleStatementSuite(
-                        SimpleStatementSuite {
-                            body: [
-                                Pass(
-                                    Pass {
-                                        semicolon: None,
-                                    },
-                                ),
-                            ],
-                            leading_whitespace: SimpleWhitespace(
-                                " ",
-                            ),
-                            trailing_whitespace: TrailingWhitespace {
-                                whitespace: SimpleWhitespace(
-                                    " ",
-                                ),
-                                comment: Some(
-                                    Comment(
-                                        "# comment",
-                                    ),
-                                ),
-                                newline: Newline(
-                                    None,
-                                    Real,
-                                ),
-                            },
-                        },
-                    ),
-                    orelse: None,
-                    leading_lines: [],
-                    whitespace_before_test: SimpleWhitespace(
-                        " ",
-                    ),
-                    whitespace_after_test: SimpleWhitespace(
-                        "",
-                    ),
-                    is_elif: false,
-                },
-            ),
-        ),
-    ],
-    header: [],
-    footer: [],
-    default_indent: "    ",
-    default_newline: "\n",
-    has_trailing_newline: true,
-    encoding: "utf-8",
-}
-```
-
-- `cargo dev generate-all`: Update `ruff.schema.json`, `docs/configuration.md` and `docs/rules`.
-    You can also set `RUFF_UPDATE_SCHEMA=1` to update `ruff.schema.json` during `cargo test`.
-- `cargo dev generate-cli-help`, `cargo dev generate-docs` and `cargo dev generate-json-schema`:
-    Update just `docs/configuration.md`, `docs/rules` and `ruff.schema.json` respectively.
-- `cargo dev generate-options`: Generate a markdown-compatible table of all `pyproject.toml`
-    options. Used for <https://docs.astral.sh/ruff/settings/>.
-- `cargo dev generate-rules-table`: Generate a markdown-compatible table of all rules. Used for <https://docs.astral.sh/ruff/rules/>.
-- `cargo dev round-trip <python file or jupyter notebook>`: Read a Python file or Jupyter Notebook,
-    parse it, serialize the parsed representation and write it back. Used to check how good our
-    representation is so that fixes don't rewrite irrelevant parts of a file.
-- `cargo dev format_dev`: See ruff_python_formatter README.md
-
-## Subsystems
-
-### Compilation Pipeline
-
-If we view Ruff as a compiler, in which the inputs are paths to Python files and the outputs are
-diagnostics, then our current compilation pipeline proceeds as follows:
-
-1. **File discovery**: Given paths like `foo/`, locate all Python files in any specified subdirectories, taking into account our hierarchical settings system and any `exclude` options.
-
-1. **Package resolution**: Determine the "package root" for every file by traversing over its parent directories and looking for `__init__.py` files.
-
-1. **Cache initialization**: For every "package root", initialize an empty cache.
-
-1. **Analysis**: For every file, in parallel:
-
-    1. **Cache read**: If the file is cached (i.e., its modification timestamp hasn't changed since it was last analyzed), short-circuit, and return the cached diagnostics.
-
-    1. **Tokenization**: Run the lexer over the file to generate a token stream.
-
-    1. **Indexing**: Extract metadata from the token stream, such as: comment ranges, `# noqa` locations, `# isort: off` locations, "doc lines", etc.
-
-    1. **Token-based rule evaluation**: Run any lint rules that are based on the contents of the token stream (e.g., commented-out code).
-
-    1. **Filesystem-based rule evaluation**: Run any lint rules that are based on the contents of the filesystem (e.g., lack of `__init__.py` file in a package).
-
-    1. **Logical line-based rule evaluation**: Run any lint rules that are based on logical lines (e.g., stylistic rules).
-
-    1. **Parsing**: Run the parser over the token stream to produce an AST. (This consumes the token stream, so anything that relies on the token stream needs to happen before parsing.)
-
-    1. **AST-based rule evaluation**: Run any lint rules that are based on the AST. This includes the vast majority of lint rules. As part of this step, we also build the semantic model for the current file as we traverse over the AST. Some lint rules are evaluated eagerly, as we iterate over the AST, while others are evaluated in a deferred manner (e.g., unused imports, since we can't determine whether an import is unused until we've finished analyzing the entire file), after we've finished the initial traversal.
-
-    1. **Import-based rule evaluation**: Run any lint rules that are based on the module's imports (e.g., import sorting). These could, in theory, be included in the AST-based rule evaluation phase — they're just separated for simplicity.
-
-    1. **Physical line-based rule evaluation**: Run any lint rules that are based on physical lines (e.g., line-length).
-
-    1. **Suppression enforcement**: Remove any violations that are suppressed via `# noqa` directives or `per-file-ignores`.
-
-    1. **Cache write**: Write the generated diagnostics to the package cache using the file as a key.
-
-1. **Reporting**: Print diagnostics in the specified format (text, JSON, etc.), to the specified output channel (stdout, a file, etc.).
-
-### Import Categorization
-
-To understand Ruff's import categorization system, we first need to define two concepts:
-
-- "Project root": The directory containing the `pyproject.toml`, `ruff.toml`, or `.ruff.toml` file,
-    discovered by identifying the "closest" such directory for each Python file. (If you're running
-    via `ruff --config /path/to/pyproject.toml`, then the current working directory is used as the
-    "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 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:
-
-```text
-my_project
-├── pyproject.toml
-└── src
-    └── foo
-        ├── __init__.py
-        └── bar
-            ├── __init__.py
-            └── baz.py
-```
-
-Then when analyzing `baz.py`, the project root would be the top-level directory (`./my_project`),
-and the package root would be `./my_project/src/foo`.
-
-#### Project root
-
-The project root does not have a significant impact beyond that all relative paths within the loaded
-configuration file are resolved relative to the project root.
-
-For example, to indicate that `bar` above is a namespace package (it isn't, but let's run with it),
-the `pyproject.toml` would list `namespace-packages = ["./src/bar"]`, which would resolve
-to `my_project/src/bar`.
-
-The same logic applies when providing a configuration file via `--config`. In that case, the
-_current working directory_ is used as the project root, and so all paths in that configuration file
-are resolved relative to the current working directory. (As a general rule, we want to avoid relying
-on the current working directory as much as possible, to ensure that Ruff exhibits the same behavior
-regardless of where and how you invoke it — but that's hard to avoid in this case.)
-
-Additionally, if a `pyproject.toml` file _extends_ another configuration file, Ruff will still use
-the directory containing that `pyproject.toml` file as the project root. For example, if
-`./my_project/pyproject.toml` contains:
-
-```toml
-[tool.ruff]
-extend = "/path/to/pyproject.toml"
-```
-
-Then Ruff will use `./my_project` as the project root, even though the configuration file extends
-`/path/to/pyproject.toml`. As such, if the configuration file at `/path/to/pyproject.toml` contains
-any relative paths, they will be resolved relative to `./my_project`.
-
-If a project uses nested configuration files, then Ruff would detect multiple project roots, one for
-each configuration file.
-
-#### Package root
-
-The package root is used to determine a file's "module path". Consider, again, `baz.py`. In that
-case, `./my_project/src/foo` was identified as the package root, so the module path for `baz.py`
-would resolve to  `foo.bar.baz` — as computed by taking the relative path from the package root
-(inclusive of the root itself). The module path can be thought of as "the path you would use to
-import the module" (e.g., `import foo.bar.baz`).
-
-The package root and module path are used to, e.g., convert relative to absolute imports, and for
-import categorization, as described below.
-
-#### Import categorization
-
-When sorting and formatting import blocks, Ruff categorizes every import into one of five
-categories:
-
-1. **"Future"**: the import is a `__future__` import. That's easy: just look at the name of the
-    imported module!
-1. **"Standard library"**: the import comes from the Python standard library (e.g., `import os`).
-    This is easy too: we include a list of all known standard library modules in Ruff itself, so it's
-    a simple lookup.
-1. **"Local folder"**: the import is a relative import (e.g., `from .foo import bar`). This is easy
-    too: just check if the import includes a `level` (i.e., a dot-prefix).
-1. **"First party"**: the import is part of the current project. (More on this below.)
-1. **"Third party"**: everything else.
-
-The real challenge lies in determining whether an import is first-party — everything else is either
-trivial, or (as in the case of third-party) merely defined as "not first-party".
-
-There are three ways in which an import can be categorized as "first-party":
-
-1. **Explicit settings**: the import is marked as such via the `known-first-party` setting. (This
-    should generally be seen as an escape hatch.)
-1. **Same-package**: the imported module is in the same package as the current file. This gets back
-    to the importance of the "package root" and the file's "module path". Imagine that we're
-    analyzing `baz.py` above. If `baz.py` contains any imports that appear to come from the `foo`
-    package (e.g., `from foo import bar` or `import foo.bar`), they'll be classified as first-party
-    automatically. This check is as simple as comparing the first segment of the current file's
-    module path to the first segment of the import.
-1. **Source roots**: Ruff supports a [`src`](https://docs.astral.sh/ruff/settings/#src) setting, which
-    sets the directories to scan when identifying first-party imports. The algorithm is
-    straightforward: given an import, like `import foo`, iterate over the directories enumerated in
-    the `src` setting and, for each directory, check for the existence of a subdirectory `foo` or a
-    file `foo.py`.
-
-By default, `src` is set to the project root, along with `"src"` subdirectory in the project root.
-This ensures that Ruff supports both flat and "src" layouts out of the box.

Cargo.toml

@@ -1,230 +1,75 @@
 [workspace]
-members = ["crates/*"]
-resolver = "2"
+members = [
+  "flake8_to_ruff",
+  "ruff_dev",
+]
 
-[workspace.package]
+[package]
+name = "ruff"
+version = "0.0.107"
 edition = "2021"
-rust-version = "1.80"
-homepage = "https://docs.astral.sh/ruff"
-documentation = "https://docs.astral.sh/ruff"
-repository = "https://github.com/astral-sh/ruff"
-authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
-license = "MIT"
 
-[workspace.dependencies]
-ruff = { path = "crates/ruff" }
-ruff_cache = { path = "crates/ruff_cache" }
-ruff_db = { path = "crates/ruff_db", default-features = false }
-ruff_diagnostics = { path = "crates/ruff_diagnostics" }
-ruff_formatter = { path = "crates/ruff_formatter" }
-ruff_graph = { path = "crates/ruff_graph" }
-ruff_index = { path = "crates/ruff_index" }
-ruff_linter = { path = "crates/ruff_linter" }
-ruff_macros = { path = "crates/ruff_macros" }
-ruff_notebook = { path = "crates/ruff_notebook" }
-ruff_python_ast = { path = "crates/ruff_python_ast" }
-ruff_python_codegen = { path = "crates/ruff_python_codegen" }
-ruff_python_formatter = { path = "crates/ruff_python_formatter" }
-ruff_python_index = { path = "crates/ruff_python_index" }
-ruff_python_literal = { path = "crates/ruff_python_literal" }
-ruff_python_parser = { path = "crates/ruff_python_parser" }
-ruff_python_semantic = { path = "crates/ruff_python_semantic" }
-ruff_python_stdlib = { path = "crates/ruff_python_stdlib" }
-ruff_python_trivia = { path = "crates/ruff_python_trivia" }
-ruff_server = { path = "crates/ruff_server" }
-ruff_source_file = { path = "crates/ruff_source_file" }
-ruff_text_size = { path = "crates/ruff_text_size" }
-red_knot_vendored = { path = "crates/red_knot_vendored" }
-ruff_workspace = { path = "crates/ruff_workspace" }
+[lib]
+name = "ruff"
 
-red_knot_python_semantic = { path = "crates/red_knot_python_semantic" }
-red_knot_server = { path = "crates/red_knot_server" }
-red_knot_test = { path = "crates/red_knot_test" }
-red_knot_workspace = { path = "crates/red_knot_workspace", default-features = false }
-
-aho-corasick = { version = "1.1.3" }
-annotate-snippets = { version = "0.9.2", features = ["color"] }
-anyhow = { version = "1.0.80" }
-assert_fs = { version = "1.1.0" }
-argfile = { version = "0.2.0" }
+[dependencies]
+anyhow = { version = "1.0.60" }
 bincode = { version = "1.3.3" }
-bitflags = { version = "2.5.0" }
-bstr = { version = "1.9.1" }
-cachedir = { version = "0.3.1" }
-camino = { version = "1.1.7" }
-chrono = { version = "0.4.35", default-features = false, features = ["clock"] }
-clap = { version = "4.5.3", features = ["derive"] }
-clap_complete_command = { version = "0.6.0" }
-clearscreen = { version = "3.0.0" }
-codspeed-criterion-compat = { version = "2.6.0", default-features = false }
-colored = { version = "2.1.0" }
-console_error_panic_hook = { version = "0.1.7" }
-console_log = { version = "1.0.0" }
-countme = { version = "3.0.1" }
-compact_str = "0.8.0"
-criterion = { version = "0.5.1", default-features = false }
-crossbeam = { version = "0.8.4" }
-dashmap = { version = "6.0.1" }
-dir-test = { version = "0.3.0" }
-drop_bomb = { version = "0.1.5" }
-env_logger = { version = "0.11.0" }
-etcetera = { version = "0.8.0" }
-fern = { version = "0.7.0" }
-filetime = { version = "0.2.23" }
-glob = { version = "0.3.1" }
-globset = { version = "0.4.14" }
-globwalk = { version = "0.9.1" }
-hashbrown = { version = "0.15.0", default-features = false, features = [
-    "raw-entry",
-    "inline-more",
-] }
-ignore = { version = "0.4.22" }
-imara-diff = { version = "0.1.5" }
-imperative = { version = "1.0.4" }
-indexmap = {version = "2.6.0" }
-indicatif = { version = "0.17.8" }
-indoc = { version = "2.0.4" }
-insta = { version = "1.35.1" }
-insta-cmd = { version = "0.6.0" }
-is-macro = { version = "0.3.5" }
-is-wsl = { version = "0.4.0" }
-itertools = { version = "0.13.0" }
-js-sys = { version = "0.3.69" }
-jod-thread = { version = "0.1.2" }
-libc = { version = "0.2.153" }
-libcst = { version = "1.1.0", default-features = false }
+chrono = { version = "0.4.21" }
+clap = { version = "4.0.1", features = ["derive"] }
+colored = { version = "2.0.0" }
+common-path = { version = "1.0.0" }
+dirs = { version = "4.0.0" }
+fern = { version = "0.6.1" }
+filetime = { version = "0.2.17" }
+glob = { version = "0.3.0" }
+itertools = { version = "0.10.5" }
+libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "32a044c127668df44582f85699358e67803b0d73" }
 log = { version = "0.4.17" }
-lsp-server = { version = "0.7.6" }
-lsp-types = { git = "https://github.com/astral-sh/lsp-types.git", rev = "3512a9f", features = [
-    "proposed",
-] }
-matchit = { version = "0.8.1" }
-memchr = { version = "2.7.1" }
-mimalloc = { version = "0.1.39" }
-natord = { version = "1.0.9" }
-notify = { version = "7.0.0" }
-ordermap = { version = "0.5.0" }
-path-absolutize = { version = "3.1.1" }
-path-slash = { version = "0.2.1" }
-pathdiff = { version = "0.2.1" }
-pep440_rs = { version = "0.7.1" }
-pretty_assertions = "1.3.0"
-proc-macro2 = { version = "1.0.79" }
-pyproject-toml = { version = "0.9.0" }
-quick-junit = { version = "0.5.0" }
-quote = { version = "1.0.23" }
-rand = { version = "0.8.5" }
-rayon = { version = "1.10.0" }
-regex = { version = "1.10.2" }
-rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "254c749b02cde2fd29852a7463a33e800b771758" }
-schemars = { version = "0.8.16" }
-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" }
-similar = { version = "2.4.0", features = ["inline"] }
-smallvec = { version = "1.13.2" }
-static_assertions = "1.1.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.58" }
-tikv-jemallocator = { version = "0.6.0" }
-toml = { version = "0.8.11" }
-tracing = { version = "0.1.40" }
-tracing-flame = { version = "0.2.0" }
-tracing-indicatif = { version = "0.3.6" }
-tracing-subscriber = { version = "0.3.18", default-features = false, features = [
-    "env-filter",
-    "fmt",
-] }
-tracing-tree = { version = "0.4.0" }
-typed-arena = { version = "2.0.2" }
-unic-ucd-category = { version = "0.9" }
-unicode-ident = { version = "1.0.12" }
-unicode-width = { version = "0.1.11" }
-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",
-] }
+notify = { version = "4.0.17" }
+num-bigint = { version = "0.4.3" }
+once_cell = { version = "1.13.1" }
+path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
+rayon = { version = "1.5.3" }
+regex = { version = "1.6.0" }
+ropey = { version = "1.5.0" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+serde = { version = "1.0.143", features = ["derive"] }
+serde_json = { version = "1.0.83" }
+strum = { version = "0.24.1", features = ["strum_macros"] }
+strum_macros = { version = "0.24.3" }
+textwrap = { version = "0.15.1" }
+titlecase = { version = "2.2.1" }
+toml = { version = "0.5.9" }
+update-informer = { version = "0.5.0", default_features = false, features = ["pypi"], optional = true }
 walkdir = { version = "2.3.2" }
-wasm-bindgen = { version = "0.2.92" }
-wasm-bindgen-test = { version = "0.3.42" }
-wild = { version = "2" }
-zip = { version = "0.6.6", default-features = false }
 
-[workspace.lints.rust]
-unsafe_code = "warn"
-unreachable_pub = "warn"
-unexpected_cfgs = { level = "warn", check-cfg = [
-    "cfg(fuzzing)",
-    "cfg(codspeed)",
-] }
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+cacache = { version = "10.0.1" } # uses async-std
+clearscreen = { version = "1.0.10" } # uses which
 
-[workspace.lints.clippy]
-pedantic = { level = "warn", priority = -2 }
-# Allowed pedantic lints
-char_lit_as_u8 = "allow"
-collapsible_else_if = "allow"
-collapsible_if = "allow"
-implicit_hasher = "allow"
-map_unwrap_or = "allow"
-match_same_arms = "allow"
-missing_errors_doc = "allow"
-missing_panics_doc = "allow"
-module_name_repetitions = "allow"
-must_use_candidate = "allow"
-similar_names = "allow"
-single_match_else = "allow"
-too_many_lines = "allow"
-# Without the hashes we run into a `rustfmt` bug in some snapshot tests, see #13250
-needless_raw_string_hashes = "allow"
-# Disallowed restriction lints
-print_stdout = "warn"
-print_stderr = "warn"
-dbg_macro = "warn"
-empty_drop = "warn"
-empty_structs_with_brackets = "warn"
-exit = "warn"
-get_unwrap = "warn"
-rc_buffer = "warn"
-rc_mutex = "warn"
-rest_pat_in_fully_bound_structs = "warn"
-# nursery rules
-redundant_clone = "warn"
-debug_assert_with_mut_call = "warn"
-unused_peekable = "warn"
+# https://docs.rs/getrandom/0.2.7/getrandom/#webassembly-support
+# For (future) wasm-pack support
+[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
+getrandom = { version = "0.2.7", features = ["js"] }
+
+[dev-dependencies]
+assert_cmd = { version = "2.0.4" }
+criterion = { version = "0.4.0" }
+insta = { version = "1.19.1", features = ["yaml"] }
+test-case = { version = "2.2.2" }
+
+[features]
+default = ["update-informer"]
+update-informer = ["dep:update-informer"]
 
 [profile.release]
-# Note that we set these explicitly, and these values
-# were chosen based on a trade-off between compile times
-# and runtime performance[1].
-#
-# [1]: https://github.com/astral-sh/ruff/pull/9031
+panic = "abort"
 lto = "thin"
-codegen-units = 16
-
-# Some crates don't change as much but benefit more from
-# more expensive optimization passes, so we selectively
-# decrease codegen-units in some cases.
-[profile.release.package.ruff_python_parser]
-codegen-units = 1
-[profile.release.package.ruff_python_ast]
 codegen-units = 1
+opt-level = 3
 
 [profile.dev.package.insta]
 opt-level = 3
@@ -232,78 +77,6 @@ opt-level = 3
 [profile.dev.package.similar]
 opt-level = 3
 
-# Reduce complexity of a parser function that would trigger a locals limit in a wasm tool.
-# https://github.com/bytecodealliance/wasm-tools/blob/b5c3d98e40590512a3b12470ef358d5c7b983b15/crates/wasmparser/src/limits.rs#L29
-[profile.dev.package.ruff_python_parser]
-opt-level = 1
-
-# Use the `--profile profiling` flag to show symbols in release mode.
-# e.g. `cargo build --profile profiling`
-[profile.profiling]
-inherits = "release"
-debug = 1
-
-# The profile that 'cargo dist' will build with.
-[profile.dist]
-inherits = "release"
-
-# Config for 'cargo dist'
-[workspace.metadata.dist]
-# The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax)
-cargo-dist-version = "0.22.1"
-# CI backends to support
-ci = "github"
-# The installers to generate for each app
-installers = ["shell", "powershell"]
-# The archive format to use for windows builds (defaults .zip)
-windows-archive = ".zip"
-# The archive format to use for non-windows builds (defaults .tar.xz)
-unix-archive = ".tar.gz"
-# Target platforms to build apps for (Rust target-triple syntax)
-targets = [
-    "aarch64-apple-darwin",
-    "aarch64-pc-windows-msvc",
-    "aarch64-unknown-linux-gnu",
-    "aarch64-unknown-linux-musl",
-    "arm-unknown-linux-musleabihf",
-    "armv7-unknown-linux-gnueabihf",
-    "armv7-unknown-linux-musleabihf",
-    "i686-pc-windows-msvc",
-    "i686-unknown-linux-gnu",
-    "i686-unknown-linux-musl",
-    "powerpc64-unknown-linux-gnu",
-    "powerpc64le-unknown-linux-gnu",
-    "s390x-unknown-linux-gnu",
-    "x86_64-apple-darwin",
-    "x86_64-pc-windows-msvc",
-    "x86_64-unknown-linux-gnu",
-    "x86_64-unknown-linux-musl",
-]
-# Whether to auto-include files like READMEs, LICENSEs, and CHANGELOGs (default true)
-auto-includes = false
-# Whether cargo-dist should create a GitHub Release or use an existing draft
-create-release = true
-# Which actions to run on pull requests
-pr-run-mode = "skip"
-# Whether CI should trigger releases with dispatches instead of tag pushes
-dispatch-releases = true
-# Which phase cargo-dist should use to create the GitHub release
-github-release = "announce"
-# Whether CI should include auto-generated code to build local artifacts
-build-local-artifacts = false
-# Local artifacts jobs to run in CI
-local-artifacts-jobs = ["./build-binaries", "./build-docker"]
-# Publish jobs to run in CI
-publish-jobs = ["./publish-pypi", "./publish-wasm"]
-# Post-announce jobs to run in CI
-post-announce-jobs = [
-    "./notify-dependents",
-    "./publish-docs",
-    "./publish-playground",
-]
-# Custom permissions for GitHub Jobs
-github-custom-job-permissions = { "build-docker" = { packages = "write", contents = "read" }, "publish-wasm" = { contents = "read", id-token = "write", packages = "write" } }
-# Whether to install an updater program
-install-updater = false
-# Path that installers should place binaries in
-install-path = "CARGO_HOME"
+[[bench]]
+name = "source_code_locator"
+harness = false

Dockerfile

@@ -1,38 +0,0 @@
-FROM --platform=$BUILDPLATFORM ubuntu AS build
-ENV HOME="/root"
-WORKDIR $HOME
-
-RUN apt update && apt install -y build-essential curl python3-venv
-
-# Setup zig as cross compiling linker
-RUN python3 -m venv $HOME/.venv
-RUN .venv/bin/pip install cargo-zigbuild
-ENV PATH="$HOME/.venv/bin:$PATH"
-
-# Install rust
-ARG TARGETPLATFORM
-RUN case "$TARGETPLATFORM" in \
-    "linux/arm64") echo "aarch64-unknown-linux-musl" > rust_target.txt ;; \
-    "linux/amd64") echo "x86_64-unknown-linux-musl" > rust_target.txt ;; \
-    *) exit 1 ;; \
-    esac
-# Update rustup whenever we bump the rust version
-COPY rust-toolchain.toml rust-toolchain.toml
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --target $(cat rust_target.txt) --profile minimal --default-toolchain none
-ENV PATH="$HOME/.cargo/bin:$PATH"
-# Installs the correct toolchain version from rust-toolchain.toml and then the musl target
-RUN rustup target add $(cat rust_target.txt)
-
-# Build
-COPY crates crates
-COPY Cargo.toml Cargo.toml
-COPY Cargo.lock Cargo.lock
-RUN cargo zigbuild --bin ruff --target $(cat rust_target.txt) --release
-RUN cp target/$(cat rust_target.txt)/release/ruff /ruff
-# TODO: Optimize binary size, with a version that also works when cross compiling
-# RUN strip --strip-all /ruff
-
-FROM scratch
-COPY --from=build /ruff /ruff
-WORKDIR /io
-ENTRYPOINT ["/ruff"]

_typos.toml

@@ -1,22 +0,0 @@
-[files]
-# https://github.com/crate-ci/typos/issues/868
-extend-exclude = ["crates/red_knot_vendored/vendor/**/*", "**/resources/**/*", "**/snapshots/**/*"]
-
-[default.extend-words]
-"arange" = "arange"  # e.g. `numpy.arange`
-hel = "hel"
-whos = "whos"
-spawnve = "spawnve"
-ned = "ned"
-pn = "pn"  # `import panel as pn` is a thing
-poit = "poit"
-BA = "BA" # acronym for "Bad Allowed", used in testing.
-jod = "jod" # e.g., `jod-thread`
-Numer = "Numer" # Library name 'NumerBlox' in "Who's Using Ruff?"
-
-[default]
-extend-ignore-re = [
-  # Line ignore with trailing "spellchecker:disable-line"
-  "(?Rm)^.*#\\s*spellchecker:disable-line$",
-  "LICENSEs",
-]

assets/badge/format.json

@@ -1,8 +0,0 @@
-{
-  "label": "code style",
-  "message": "Ruff",
-  "logoSvg": "<svg width=\"510\" height=\"622\" viewBox=\"0 0 510 622\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path fill-rule=\"evenodd\" clip-rule=\"evenodd\" d=\"M206.701 0C200.964 0 196.314 4.64131 196.314 10.3667V41.4667C196.314 47.192 191.663 51.8333 185.927 51.8333H156.843C151.107 51.8333 146.456 56.4746 146.456 62.2V145.133C146.456 150.859 141.806 155.5 136.069 155.5H106.986C101.249 155.5 96.5988 160.141 96.5988 165.867V222.883C96.5988 228.609 91.9484 233.25 86.2118 233.25H57.1283C51.3917 233.25 46.7413 237.891 46.7413 243.617V300.633C46.7413 306.359 42.0909 311 36.3544 311H10.387C4.6504 311 0 315.641 0 321.367V352.467C0 358.192 4.6504 362.833 10.387 362.833H145.418C151.154 362.833 155.804 367.475 155.804 373.2V430.217C155.804 435.942 151.154 440.583 145.418 440.583H116.334C110.597 440.583 105.947 445.225 105.947 450.95V507.967C105.947 513.692 101.297 518.333 95.5601 518.333H66.4766C60.74 518.333 56.0896 522.975 56.0896 528.7V611.633C56.0896 617.359 60.74 622 66.4766 622H149.572C155.309 622 159.959 617.359 159.959 611.633V570.167H201.507C207.244 570.167 211.894 565.525 211.894 559.8V528.7C211.894 522.975 216.544 518.333 222.281 518.333H251.365C257.101 518.333 261.752 513.692 261.752 507.967V476.867C261.752 471.141 266.402 466.5 272.138 466.5H301.222C306.959 466.5 311.609 461.859 311.609 456.133V425.033C311.609 419.308 316.259 414.667 321.996 414.667H351.079C356.816 414.667 361.466 410.025 361.466 404.3V373.2C361.466 367.475 366.117 362.833 371.853 362.833H400.937C406.673 362.833 411.324 358.192 411.324 352.467V321.367C411.324 315.641 415.974 311 421.711 311H450.794C456.531 311 461.181 306.359 461.181 300.633V217.7C461.181 211.975 456.531 207.333 450.794 207.333H420.672C414.936 207.333 410.285 202.692 410.285 196.967V165.867C410.285 160.141 414.936 155.5 420.672 155.5H449.756C455.492 155.5 460.143 150.859 460.143 145.133V114.033C460.143 108.308 464.793 103.667 470.53 103.667H499.613C505.35 103.667 510 99.0253 510 93.3V10.3667C510 4.64132 505.35 0 499.613 0H206.701ZM168.269 440.583C162.532 440.583 157.882 445.225 157.882 450.95V507.967C157.882 513.692 153.231 518.333 147.495 518.333H118.411C112.675 518.333 108.024 522.975 108.024 528.7V559.8C108.024 565.525 112.675 570.167 118.411 570.167H159.959V528.7C159.959 522.975 164.61 518.333 170.346 518.333H199.43C205.166 518.333 209.817 513.692 209.817 507.967V476.867C209.817 471.141 214.467 466.5 220.204 466.5H249.287C255.024 466.5 259.674 461.859 259.674 456.133V425.033C259.674 419.308 264.325 414.667 270.061 414.667H299.145C304.881 414.667 309.532 410.025 309.532 404.3V373.2C309.532 367.475 314.182 362.833 319.919 362.833H349.002C354.739 362.833 359.389 358.192 359.389 352.467V321.367C359.389 315.641 364.039 311 369.776 311H398.859C404.596 311 409.246 306.359 409.246 300.633V269.533C409.246 263.808 404.596 259.167 398.859 259.167H318.88C313.143 259.167 308.493 254.525 308.493 248.8V217.7C308.493 211.975 313.143 207.333 318.88 207.333H347.963C353.7 207.333 358.35 202.692 358.35 196.967V165.867C358.35 160.141 363.001 155.5 368.737 155.5H397.821C403.557 155.5 408.208 150.859 408.208 145.133V114.033C408.208 108.308 412.858 103.667 418.595 103.667H447.678C453.415 103.667 458.065 99.0253 458.065 93.3V62.2C458.065 56.4746 453.415 51.8333 447.678 51.8333H208.778C203.041 51.8333 198.391 56.4746 198.391 62.2V145.133C198.391 150.859 193.741 155.5 188.004 155.5H158.921C153.184 155.5 148.534 160.141 148.534 165.867V222.883C148.534 228.609 143.883 233.25 138.147 233.25H109.063C103.327 233.25 98.6762 237.891 98.6762 243.617V300.633C98.6762 306.359 103.327 311 109.063 311H197.352C203.089 311 207.739 315.641 207.739 321.367V430.217C207.739 435.942 203.089 440.583 197.352 440.583H168.269Z\" fill=\"#D7FF64\"/></svg>",
-  "logoWidth": 10,
-  "labelColor": "grey",
-  "color": "#261230"
-}

assets/badge/v0.json

@@ -1,8 +0,0 @@
-{
-  "label": "",
-  "message": "Ruff",
-  "logoSvg": "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"128\" height=\"128\"><path d=\"M115.36 61.84 70.22 50.49 114.45 2.4a1.222 1.222 0 0 0-1.54-1.87L12.3 61.98c-.41.25-.64.72-.57 1.2.06.48.4.87.87 1.01l45.07 13.25-44.29 48.16c-.42.46-.44 1.15-.04 1.61.24.29.58.44.94.44.22 0 .45-.06.65-.19l100.78-63.41c.42-.26.64-.75.56-1.22-.08-.49-.43-.88-.91-.99z\" style=\"fill:#fcc21b\"/></svg>",
-  "logoWidth": 10,
-  "labelColor": "grey",
-  "color": "#E15759"
-}

assets/badge/v1.json

@@ -1,8 +0,0 @@
-{
-  "label": "",
-  "message": "Ruff",
-  "logoSvg": "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"109\" height=\"132\" fill=\"none\"><g filter=\"url(#a)\"><path fill=\"#FCC21B\" d=\"m103.642 61.492-45.14-11.35 44.23-48.09a1.222 1.222 0 0 0-1.54-1.87L.582 61.632c-.41.25-.64.72-.57 1.2.06.48.4.87.87 1.01l45.07 13.25-44.29 48.16c-.42.46-.44 1.15-.04 1.61.24.29.58.44.94.44.22 0 .45-.06.65-.19l100.78-63.41c.42-.26.64-.75.56-1.22-.08-.49-.43-.88-.91-.99Z\"/></g><defs><filter id=\"a\" width=\"108.569\" height=\"131.302\" x=\"0\" y=\"0\" color-interpolation-filters=\"sRGB\" filterUnits=\"userSpaceOnUse\"><feFlood flood-opacity=\"0\" result=\"BackgroundImageFix\"/><feColorMatrix in=\"SourceAlpha\" result=\"hardAlpha\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0\"/><feOffset dx=\"4\" dy=\"4\"/><feComposite in2=\"hardAlpha\" operator=\"out\"/><feColorMatrix values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0\"/><feBlend in2=\"BackgroundImageFix\" result=\"effect1_dropShadow_7_4\"/><feBlend in=\"SourceGraphic\" in2=\"effect1_dropShadow_7_4\" result=\"shape\"/></filter></defs></svg>",
-  "logoWidth": 10,
-  "labelColor": "grey",
-  "color": "#E15759"
-}

assets/badge/v2.json

@@ -1,8 +0,0 @@
-{
-  "label": "",
-  "message": "Ruff",
-  "logoSvg": "<svg width=\"510\" height=\"622\" viewBox=\"0 0 510 622\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path fill-rule=\"evenodd\" clip-rule=\"evenodd\" d=\"M206.701 0C200.964 0 196.314 4.64131 196.314 10.3667V41.4667C196.314 47.192 191.663 51.8333 185.927 51.8333H156.843C151.107 51.8333 146.456 56.4746 146.456 62.2V145.133C146.456 150.859 141.806 155.5 136.069 155.5H106.986C101.249 155.5 96.5988 160.141 96.5988 165.867V222.883C96.5988 228.609 91.9484 233.25 86.2118 233.25H57.1283C51.3917 233.25 46.7413 237.891 46.7413 243.617V300.633C46.7413 306.359 42.0909 311 36.3544 311H10.387C4.6504 311 0 315.641 0 321.367V352.467C0 358.192 4.6504 362.833 10.387 362.833H145.418C151.154 362.833 155.804 367.475 155.804 373.2V430.217C155.804 435.942 151.154 440.583 145.418 440.583H116.334C110.597 440.583 105.947 445.225 105.947 450.95V507.967C105.947 513.692 101.297 518.333 95.5601 518.333H66.4766C60.74 518.333 56.0896 522.975 56.0896 528.7V611.633C56.0896 617.359 60.74 622 66.4766 622H149.572C155.309 622 159.959 617.359 159.959 611.633V570.167H201.507C207.244 570.167 211.894 565.525 211.894 559.8V528.7C211.894 522.975 216.544 518.333 222.281 518.333H251.365C257.101 518.333 261.752 513.692 261.752 507.967V476.867C261.752 471.141 266.402 466.5 272.138 466.5H301.222C306.959 466.5 311.609 461.859 311.609 456.133V425.033C311.609 419.308 316.259 414.667 321.996 414.667H351.079C356.816 414.667 361.466 410.025 361.466 404.3V373.2C361.466 367.475 366.117 362.833 371.853 362.833H400.937C406.673 362.833 411.324 358.192 411.324 352.467V321.367C411.324 315.641 415.974 311 421.711 311H450.794C456.531 311 461.181 306.359 461.181 300.633V217.7C461.181 211.975 456.531 207.333 450.794 207.333H420.672C414.936 207.333 410.285 202.692 410.285 196.967V165.867C410.285 160.141 414.936 155.5 420.672 155.5H449.756C455.492 155.5 460.143 150.859 460.143 145.133V114.033C460.143 108.308 464.793 103.667 470.53 103.667H499.613C505.35 103.667 510 99.0253 510 93.3V10.3667C510 4.64132 505.35 0 499.613 0H206.701ZM168.269 440.583C162.532 440.583 157.882 445.225 157.882 450.95V507.967C157.882 513.692 153.231 518.333 147.495 518.333H118.411C112.675 518.333 108.024 522.975 108.024 528.7V559.8C108.024 565.525 112.675 570.167 118.411 570.167H159.959V528.7C159.959 522.975 164.61 518.333 170.346 518.333H199.43C205.166 518.333 209.817 513.692 209.817 507.967V476.867C209.817 471.141 214.467 466.5 220.204 466.5H249.287C255.024 466.5 259.674 461.859 259.674 456.133V425.033C259.674 419.308 264.325 414.667 270.061 414.667H299.145C304.881 414.667 309.532 410.025 309.532 404.3V373.2C309.532 367.475 314.182 362.833 319.919 362.833H349.002C354.739 362.833 359.389 358.192 359.389 352.467V321.367C359.389 315.641 364.039 311 369.776 311H398.859C404.596 311 409.246 306.359 409.246 300.633V269.533C409.246 263.808 404.596 259.167 398.859 259.167H318.88C313.143 259.167 308.493 254.525 308.493 248.8V217.7C308.493 211.975 313.143 207.333 318.88 207.333H347.963C353.7 207.333 358.35 202.692 358.35 196.967V165.867C358.35 160.141 363.001 155.5 368.737 155.5H397.821C403.557 155.5 408.208 150.859 408.208 145.133V114.033C408.208 108.308 412.858 103.667 418.595 103.667H447.678C453.415 103.667 458.065 99.0253 458.065 93.3V62.2C458.065 56.4746 453.415 51.8333 447.678 51.8333H208.778C203.041 51.8333 198.391 56.4746 198.391 62.2V145.133C198.391 150.859 193.741 155.5 188.004 155.5H158.921C153.184 155.5 148.534 160.141 148.534 165.867V222.883C148.534 228.609 143.883 233.25 138.147 233.25H109.063C103.327 233.25 98.6762 237.891 98.6762 243.617V300.633C98.6762 306.359 103.327 311 109.063 311H197.352C203.089 311 207.739 315.641 207.739 321.367V430.217C207.739 435.942 203.089 440.583 197.352 440.583H168.269Z\" fill=\"#D7FF64\"/></svg>",
-  "logoWidth": 10,
-  "labelColor": "grey",
-  "color": "#261230"
-}

assets/svg/Astral.svg

@@ -1,24 +0,0 @@
-<svg width="139" height="24" viewBox="0 0 139 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <rect width="138.764" height="24" rx="2.18182" fill="#261230"/>
-  <path
-    d="M8.72798 15.2726H9.91316V11.8697L9.6887 10.4062L9.8952 10.3343L12.1309 15.1649L14.3486 10.3343L14.5461 10.4062L14.3486 11.8607V15.2726H15.5248V8.72714H13.9535L12.2117 12.7137H12.0142L10.2723 8.72714H8.72798V15.2726Z"
-    fill="#D7FF64"/>
-  <path
-    d="M22.3432 15.2726H23.6631L21.3017 8.72714H19.7574L17.4589 15.2726H18.7069L19.1558 13.9797H21.9033L22.3432 15.2726ZM19.497 13.0279L19.901 11.8607L20.4308 10.0021H20.6463L21.176 11.8607L21.5711 13.0279H19.497Z"
-    fill="#D7FF64"/>
-  <path
-    d="M25.4209 15.2726H28.1234C30.1077 15.2726 30.9876 14.1413 30.9876 12.0044C30.9876 9.92131 30.1706 8.72714 28.1234 8.72714H25.4209V15.2726ZM26.624 14.2131V9.77765H28.0965C29.147 9.77765 29.7306 10.1907 29.7306 11.4477V12.5521C29.7306 13.6923 29.2817 14.2131 28.0965 14.2131H26.624Z"
-    fill="#D7FF64"/>
-  <path
-    d="M33.079 15.2726H37.6491V14.2131H34.2822V12.3815H37.2002V11.3938H34.2822V9.77765H37.6491V8.72714H33.079V15.2726Z"
-    fill="#D7FF64"/>
-  <path
-    d="M42.923 15.2726H46.2451C47.4572 15.2726 48.2025 14.5812 48.2025 13.5487C48.2025 12.7675 47.8343 12.175 47.0532 11.9954V11.7799C47.6637 11.5734 48.0319 11.0436 48.0319 10.3433C48.0319 9.38259 47.4572 8.72714 46.281 8.72714H42.923V15.2726ZM44.0992 11.4746V9.65195H45.9578C46.4875 9.65195 46.7928 9.92131 46.7928 10.3523V10.7653C46.7928 11.1873 46.4965 11.4746 45.9758 11.4746H44.0992ZM44.0992 14.3388V12.3904H46.0296C46.5863 12.3904 46.9365 12.6418 46.9365 13.1806V13.5666C46.9365 14.0425 46.5684 14.3388 45.9309 14.3388H44.0992Z"
-    fill="#D7FF64"/>
-  <path
-    d="M49.6959 8.72714L52.174 12.579V14.1952H50.1898V15.2726H53.3772V12.579L55.8553 8.72714H54.4456L53.5119 10.2535L52.8744 11.3759H52.6679L52.0483 10.2715L51.1056 8.72714H49.6959Z"
-    fill="#D7FF64"/>
-  <path fill-rule="evenodd" clip-rule="evenodd"
-    d="M74.1824 7.63626C74.1824 7.03377 74.6708 6.54535 75.2733 6.54535H84.0006C84.6031 6.54535 85.0915 7.03377 85.0915 7.63626V9.81808H80.0733V8.94535H79.2006V10.6908H84.0006C84.6031 10.6908 85.0915 11.1792 85.0915 11.7817V16.3635C85.0915 16.966 84.6031 17.4544 84.0006 17.4544H75.2733C74.6708 17.4544 74.1824 16.966 74.1824 16.3635V14.1817L79.2006 14.1817V15.0544H80.0733V13.309L75.2733 13.309C74.6708 13.309 74.1824 12.8206 74.1824 12.2181V7.63626ZM63.4912 6.54545C62.8887 6.54545 62.4003 7.03387 62.4003 7.63636V17.4545H67.4185V14.1818H68.2912V17.4545H73.3094V7.63636C73.3094 7.03387 72.821 6.54545 72.2185 6.54545H63.4912ZM69.164 10.6909V11.5636H66.5458V10.6909H69.164ZM110.619 6.54545C110.016 6.54545 109.528 7.03387 109.528 7.63636V17.4545H114.546V14.1818H115.419V17.4545H120.437V7.63636C120.437 7.03387 119.948 6.54545 119.346 6.54545H110.619ZM116.291 10.6909V11.5636H113.673V10.6909H116.291ZM91.8549 8.29091H96.8731V11.3455C96.8731 11.9479 96.3847 12.4364 95.7822 12.4364H91.8549V13.3091H96.8731V17.4545H87.9276C87.3251 17.4545 86.8367 16.9661 86.8367 16.3636V12.4364H85.964V8.29091H86.8367V6.54545H91.8549V8.29091ZM108.655 7.63636C108.655 7.03387 108.166 6.54545 107.564 6.54545H97.7458V17.4545H102.764V14.1818H103.637V17.4545H108.655V13.3091H106.473V12.4364H107.564C108.166 12.4364 108.655 11.9479 108.655 11.3455V7.63636ZM104.509 10.6909V11.5636H101.891V10.6909H104.509ZM132.218 13.3091L126.327 13.3091V6.54547L121.309 6.54547V17.4546H132.218V13.3091Z"
-    fill="#D7FF64"/>
-</svg>

benches/source_code_locator.rs

@@ -0,0 +1,18 @@
+use std::path::Path;
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use ropey::Rope;
+use ruff::fs;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let contents = fs::read_file(Path::new("resources/test/fixtures/D.py")).unwrap();
+    c.bench_function("rope", |b| {
+        b.iter(|| {
+            let rope = Rope::from_str(black_box(&contents));
+            rope.line_to_char(black_box(4));
+        })
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

clippy.toml

@@ -1,21 +0,0 @@
-doc-valid-idents = [
-  "..",
-  "CodeQL",
-  "FastAPI",
-  "IPython",
-  "LangChain",
-  "LibCST",
-  "McCabe",
-  "NumPy",
-  "SCREAMING_SNAKE_CASE",
-  "SQLAlchemy",
-  "StackOverflow",
-  "PyCharm",
-]
-
-ignore-interior-mutability = [
-  # Interned is read-only. The wrapped `Rc` never gets updated.
-  "ruff_formatter::format_element::Interned",
-  # The expression is read-only.
-  "ruff_python_ast::hashable::HashableExpr",
-]

crates/red_knot/Cargo.toml

@@ -1,39 +0,0 @@
-[package]
-name = "red_knot"
-version = "0.0.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]
-red_knot_python_semantic = { workspace = true }
-red_knot_workspace = { workspace = true, features = ["zstd"] }
-red_knot_server = { workspace = true }
-ruff_db = { workspace = true, features = ["os", "cache"] }
-
-anyhow = { workspace = true }
-chrono = { workspace = true }
-clap = { workspace = true, features = ["wrap_help"] }
-colored = { workspace = true }
-countme = { workspace = true, features = ["enable"] }
-crossbeam = { workspace = true }
-ctrlc = { version = "3.4.4" }
-rayon = { workspace = true }
-salsa = { workspace = true }
-tracing = { workspace = true, features = ["release_max_level_debug"] }
-tracing-subscriber = { workspace = true, features = ["env-filter", "fmt"] }
-tracing-flame = { workspace = true }
-tracing-tree = { workspace = true }
-
-[dev-dependencies]
-filetime = { workspace = true }
-tempfile = { workspace = true }
-
-[lints]
-workspace = true

crates/red_knot/docs/tracing.md

@@ -1,128 +0,0 @@
-# Tracing
-
-Traces are a useful tool to narrow down the location of a bug or, at least, to understand why the compiler is doing a particular thing.
-Note, tracing messages with severity `debug` or greater are user-facing. They should be phrased accordingly.
-Tracing spans are only shown when using `-vvv`.
-
-## Verbosity levels
-
-The CLI supports different verbosity levels.
-
-- default: Only show errors and warnings.
-- `-v` activates `info!`: Show generally useful information such as paths of configuration files, detected platform, etc., but it's not a lot of messages, it's something you'll activate in CI by default. cargo build e.g. shows you which packages are fresh.
-- `-vv` activates `debug!` and timestamps: This should be enough information to get to the bottom of bug reports. When you're processing many packages or files, you'll get pages and pages of output, but each line is link to a specific action or state change.
-- `-vvv` activates `trace!` (only in debug builds) and shows tracing-spans: At this level, you're logging everything. Most of this is wasted, it's really slow, we dump e.g. the entire resolution graph. Only useful to developers, and you almost certainly want to use `RED_KNOT_LOG` to filter it down to the area your investigating.
-
-## Better logging with `RED_KNOT_LOG` and `RAYON_NUM_THREADS`
-
-By default, the CLI shows messages from the `ruff` and `red_knot` crates. Tracing messages from other crates are not shown.
-The `RED_KNOT_LOG` environment variable allows you to customize which messages are shown by specifying one
-or more [filter directives](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#directives).
-
-The `RAYON_NUM_THREADS` environment variable, meanwhile, can be used to control the level of concurrency red-knot uses.
-By default, red-knot will attempt to parallelize its work so that multiple files are checked simultaneously,
-but this can result in a confused logging output where messages from different threads are intertwined.
-To switch off concurrency entirely and have more readable logs, use `RAYON_NUM_THREADS=1`.
-
-### Examples
-
-#### Show all debug messages
-
-Shows debug messages from all crates.
-
-```bash
-RED_KNOT_LOG=debug
-```
-
-#### Show salsa query execution messages
-
-Show the salsa `execute: my_query` messages in addition to all red knot messages.
-
-```bash
-RED_KNOT_LOG=ruff=trace,red_knot=trace,salsa=info
-```
-
-#### Show typing traces
-
-Only show traces for the `red_knot_python_semantic::types` module.
-
-```bash
-RED_KNOT_LOG="red_knot_python_semantic::types"
-```
-
-Note: Ensure that you use `-vvv` to see tracing spans.
-
-#### Show messages for a single file
-
-Shows all messages that are inside of a span for a specific file.
-
-```bash
-RED_KNOT_LOG=red_knot[{file=/home/micha/astral/test/x.py}]=trace
-```
-
-**Note**: Tracing still shows all spans because tracing can't know at the time of entering the span
-whether one if its children has the file `x.py`.
-
-**Note**: Salsa currently logs the entire memoized values. In our case, the source text and parsed AST.
-This very quickly leads to extremely long outputs.
-
-## Tracing and Salsa
-
-Be mindful about using `tracing` in Salsa queries, especially when using `warn` or `error` because it isn't guaranteed
-that the query will execute after restoring from a persistent cache. In which case the user won't see the message.
-
-For example, don't use `tracing` to show the user a message when generating a lint violation failed
-because the message would only be shown when linting the file the first time, but not on subsequent analysis
-runs or when restoring from a persistent cache. This can be confusing for users because they
-don't understand why a specific lint violation isn't raised. Instead, change your
-query to return the failure as part of the query's result or use a Salsa accumulator.
-
-## Tracing in tests
-
-You can use `ruff_db::testing::setup_logging` or `ruff_db::testing::setup_logging_with_filter` to set up logging in tests.
-
-```rust
-use ruff_db::testing::setup_logging;
-
-#[test]
-fn test() {
-  let _logging = setup_logging();
-
-  tracing::info!("This message will be printed to stderr");
-}
-```
-
-Note: Most test runners capture stderr and only show its output when a test fails.
-
-Note also that `setup_logging` only sets up logging for the current thread because [`set_global_default`](https://docs.rs/tracing/latest/tracing/subscriber/fn.set_global_default.html) can only be
-called **once**.
-
-## Release builds
-
-`trace!` events are removed in release builds.
-
-## Profiling
-
-Red Knot generates a folded stack trace  to the current directory named `tracing.folded` when setting the environment variable `RED_KNOT_LOG_PROFILE` to `1` or `true`.
-
-```bash
-RED_KNOT_LOG_PROFILE=1 red_knot -- --current-directory=../test -vvv
-```
-
-You can convert the textual representation into a visual one using `inferno`.
-
-```shell
-cargo install inferno
-```
-
-```shell
-# flamegraph
-cat tracing.folded | inferno-flamegraph > tracing-flamegraph.svg
-
-# flamechart
-cat tracing.folded | inferno-flamegraph --flamechart > tracing-flamechart.svg
-```
-
-![Example flamegraph](./tracing-flamegraph.png)
-
-See [`tracing-flame`](https://crates.io/crates/tracing-flame) for more details.

crates/red_knot/src/logging.rs

@@ -1,254 +0,0 @@
-//! Sets up logging for Red Knot
-
-use anyhow::Context;
-use colored::Colorize;
-use std::fmt;
-use std::fs::File;
-use std::io::BufWriter;
-use tracing::{Event, Subscriber};
-use tracing_subscriber::filter::LevelFilter;
-use tracing_subscriber::fmt::format::Writer;
-use tracing_subscriber::fmt::{FmtContext, FormatEvent, FormatFields};
-use tracing_subscriber::registry::LookupSpan;
-use tracing_subscriber::EnvFilter;
-
-/// Logging flags to `#[command(flatten)]` into your CLI
-#[derive(clap::Args, Debug, Clone, Default)]
-#[command(about = None, long_about = None)]
-pub(crate) struct Verbosity {
-    #[arg(
-        long,
-        short = 'v',
-        help = "Use verbose output (or `-vv` and `-vvv` for more verbose output)",
-        action = clap::ArgAction::Count,
-        global = true,
-    )]
-    verbose: u8,
-}
-
-impl Verbosity {
-    /// Returns the verbosity level based on the number of `-v` flags.
-    ///
-    /// Returns `None` if the user did not specify any verbosity flags.
-    pub(crate) fn level(&self) -> VerbosityLevel {
-        match self.verbose {
-            0 => VerbosityLevel::Default,
-            1 => VerbosityLevel::Verbose,
-            2 => VerbosityLevel::ExtraVerbose,
-            _ => VerbosityLevel::Trace,
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
-pub(crate) enum VerbosityLevel {
-    /// Default output level. Only shows Ruff and Red Knot events up to the [`WARN`](tracing::Level::WARN).
-    Default,
-
-    /// Enables verbose output. Emits Ruff and Red Knot events up to the [`INFO`](tracing::Level::INFO).
-    /// Corresponds to `-v`.
-    Verbose,
-
-    /// Enables a more verbose tracing format and emits Ruff and Red Knot events up to [`DEBUG`](tracing::Level::DEBUG).
-    /// Corresponds to `-vv`
-    ExtraVerbose,
-
-    /// Enables all tracing events and uses a tree-like output format. Corresponds to `-vvv`.
-    Trace,
-}
-
-impl VerbosityLevel {
-    const fn level_filter(self) -> LevelFilter {
-        match self {
-            VerbosityLevel::Default => LevelFilter::WARN,
-            VerbosityLevel::Verbose => LevelFilter::INFO,
-            VerbosityLevel::ExtraVerbose => LevelFilter::DEBUG,
-            VerbosityLevel::Trace => LevelFilter::TRACE,
-        }
-    }
-
-    pub(crate) const fn is_trace(self) -> bool {
-        matches!(self, VerbosityLevel::Trace)
-    }
-
-    pub(crate) const fn is_extra_verbose(self) -> bool {
-        matches!(self, VerbosityLevel::ExtraVerbose)
-    }
-}
-
-pub(crate) fn setup_tracing(level: VerbosityLevel) -> anyhow::Result<TracingGuard> {
-    use tracing_subscriber::prelude::*;
-
-    // The `RED_KNOT_LOG` environment variable overrides the default log level.
-    let filter = if let Ok(log_env_variable) = std::env::var("RED_KNOT_LOG") {
-        EnvFilter::builder()
-            .parse(log_env_variable)
-            .context("Failed to parse directives specified in RED_KNOT_LOG environment variable.")?
-    } else {
-        match level {
-            VerbosityLevel::Default => {
-                // Show warning traces
-                EnvFilter::default().add_directive(LevelFilter::WARN.into())
-            }
-            level => {
-                let level_filter = level.level_filter();
-
-                // Show info|debug|trace events, but allow `RED_KNOT_LOG` to override
-                let filter = EnvFilter::default().add_directive(
-                    format!("red_knot={level_filter}")
-                        .parse()
-                        .expect("Hardcoded directive to be valid"),
-                );
-
-                filter.add_directive(
-                    format!("ruff={level_filter}")
-                        .parse()
-                        .expect("Hardcoded directive to be valid"),
-                )
-            }
-        }
-    };
-
-    let (profiling_layer, guard) = setup_profile();
-
-    let registry = tracing_subscriber::registry()
-        .with(filter)
-        .with(profiling_layer);
-
-    if level.is_trace() {
-        let subscriber = registry.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(std::io::stderr)
-                .with_timer(tracing_tree::time::Uptime::default()),
-        );
-
-        subscriber.init();
-    } else {
-        let subscriber = registry.with(
-            tracing_subscriber::fmt::layer()
-                .event_format(RedKnotFormat {
-                    display_level: true,
-                    display_timestamp: level.is_extra_verbose(),
-                    show_spans: false,
-                })
-                .with_writer(std::io::stderr),
-        );
-
-        subscriber.init();
-    }
-
-    Ok(TracingGuard {
-        _flame_guard: guard,
-    })
-}
-
-#[allow(clippy::type_complexity)]
-fn setup_profile<S>() -> (
-    Option<tracing_flame::FlameLayer<S, BufWriter<File>>>,
-    Option<tracing_flame::FlushGuard<BufWriter<File>>>,
-)
-where
-    S: Subscriber + for<'span> LookupSpan<'span>,
-{
-    if let Ok("1" | "true") = std::env::var("RED_KNOT_LOG_PROFILE").as_deref() {
-        let (layer, guard) = tracing_flame::FlameLayer::with_file("tracing.folded")
-            .expect("Flame layer to be created");
-        (Some(layer), Some(guard))
-    } else {
-        (None, None)
-    }
-}
-
-pub(crate) struct TracingGuard {
-    _flame_guard: Option<tracing_flame::FlushGuard<BufWriter<File>>>,
-}
-
-struct RedKnotFormat {
-    display_timestamp: bool,
-    display_level: bool,
-    show_spans: bool,
-}
-
-/// See <https://docs.rs/tracing-subscriber/0.3.18/src/tracing_subscriber/fmt/format/mod.rs.html#1026-1156>
-impl<S, N> FormatEvent<S, N> for RedKnotFormat
-where
-    S: Subscriber + for<'a> LookupSpan<'a>,
-    N: for<'a> FormatFields<'a> + 'static,
-{
-    fn format_event(
-        &self,
-        ctx: &FmtContext<'_, S, N>,
-        mut writer: Writer<'_>,
-        event: &Event<'_>,
-    ) -> fmt::Result {
-        let meta = event.metadata();
-        let ansi = writer.has_ansi_escapes();
-
-        if self.display_timestamp {
-            let timestamp = chrono::Local::now()
-                .format("%Y-%m-%d %H:%M:%S.%f")
-                .to_string();
-            if ansi {
-                write!(writer, "{} ", timestamp.dimmed())?;
-            } else {
-                write!(
-                    writer,
-                    "{} ",
-                    chrono::Local::now().format("%Y-%m-%d %H:%M:%S.%f")
-                )?;
-            }
-        }
-
-        if self.display_level {
-            let level = meta.level();
-            // Same colors as tracing
-            if ansi {
-                let formatted_level = level.to_string();
-                match *level {
-                    tracing::Level::TRACE => {
-                        write!(writer, "{} ", formatted_level.purple().bold())?;
-                    }
-                    tracing::Level::DEBUG => write!(writer, "{} ", formatted_level.blue().bold())?,
-                    tracing::Level::INFO => write!(writer, "{} ", formatted_level.green().bold())?,
-                    tracing::Level::WARN => write!(writer, "{} ", formatted_level.yellow().bold())?,
-                    tracing::Level::ERROR => write!(writer, "{} ", level.to_string().red().bold())?,
-                }
-            } else {
-                write!(writer, "{level} ")?;
-            }
-        }
-
-        if self.show_spans {
-            let span = event.parent();
-            let mut seen = false;
-
-            let span = span
-                .and_then(|id| ctx.span(id))
-                .or_else(|| ctx.lookup_current());
-
-            let scope = span.into_iter().flat_map(|span| span.scope().from_root());
-
-            for span in scope {
-                seen = true;
-                if ansi {
-                    write!(writer, "{}:", span.metadata().name().bold())?;
-                } else {
-                    write!(writer, "{}:", span.metadata().name())?;
-                }
-            }
-
-            if seen {
-                writer.write_char(' ')?;
-            }
-        }
-
-        ctx.field_format().format_fields(writer.by_ref(), event)?;
-
-        writeln!(writer)
-    }
-}

crates/red_knot/src/main.rs

@@ -1,388 +0,0 @@
-use std::process::{ExitCode, Termination};
-use std::sync::Mutex;
-
-use anyhow::{anyhow, Context};
-use clap::Parser;
-use colored::Colorize;
-use crossbeam::channel as crossbeam_channel;
-use red_knot_python_semantic::SitePackages;
-use red_knot_server::run_server;
-use red_knot_workspace::db::RootDatabase;
-use red_knot_workspace::watch;
-use red_knot_workspace::watch::WorkspaceWatcher;
-use red_knot_workspace::workspace::settings::Configuration;
-use red_knot_workspace::workspace::WorkspaceMetadata;
-use ruff_db::diagnostic::Diagnostic;
-use ruff_db::system::{OsSystem, System, SystemPath, SystemPathBuf};
-use salsa::plumbing::ZalsaDatabase;
-use target_version::TargetVersion;
-
-use crate::logging::{setup_tracing, Verbosity};
-
-mod logging;
-mod target_version;
-mod verbosity;
-
-#[derive(Debug, Parser)]
-#[command(
-    author,
-    name = "red-knot",
-    about = "An extremely fast Python type checker."
-)]
-#[command(version)]
-struct Args {
-    #[command(subcommand)]
-    pub(crate) command: Option<Command>,
-
-    #[arg(
-        long,
-        help = "Changes the current working directory.",
-        long_help = "Changes the current working directory before any specified operations. This affects the workspace and configuration discovery.",
-        value_name = "PATH"
-    )]
-    current_directory: Option<SystemPathBuf>,
-
-    #[arg(
-        long,
-        help = "Path to the virtual environment the project uses",
-        long_help = "\
-Path to the virtual environment the project uses. \
-If provided, red-knot will use the `site-packages` directory of this virtual environment \
-to resolve type information for the project's third-party dependencies.",
-        value_name = "PATH"
-    )]
-    venv_path: Option<SystemPathBuf>,
-
-    #[arg(
-        long,
-        value_name = "DIRECTORY",
-        help = "Custom directory to use for stdlib typeshed stubs"
-    )]
-    custom_typeshed_dir: Option<SystemPathBuf>,
-
-    #[arg(
-        long,
-        value_name = "PATH",
-        help = "Additional path to use as a module-resolution source (can be passed multiple times)"
-    )]
-    extra_search_path: Option<Vec<SystemPathBuf>>,
-
-    #[arg(
-        long,
-        help = "Python version to assume when resolving types",
-        value_name = "VERSION"
-    )]
-    target_version: Option<TargetVersion>,
-
-    #[clap(flatten)]
-    verbosity: Verbosity,
-
-    #[arg(
-        long,
-        help = "Run in watch mode by re-running whenever files change",
-        short = 'W'
-    )]
-    watch: bool,
-}
-
-impl Args {
-    fn to_configuration(&self, cli_cwd: &SystemPath) -> Configuration {
-        let mut configuration = Configuration::default();
-
-        if let Some(target_version) = self.target_version {
-            configuration.target_version = Some(target_version.into());
-        }
-
-        if let Some(venv_path) = &self.venv_path {
-            configuration.search_paths.site_packages = Some(SitePackages::Derived {
-                venv_path: SystemPath::absolute(venv_path, cli_cwd),
-            });
-        }
-
-        if let Some(custom_typeshed_dir) = &self.custom_typeshed_dir {
-            configuration.search_paths.custom_typeshed =
-                Some(SystemPath::absolute(custom_typeshed_dir, cli_cwd));
-        }
-
-        if let Some(extra_search_paths) = &self.extra_search_path {
-            configuration.search_paths.extra_paths = extra_search_paths
-                .iter()
-                .map(|path| Some(SystemPath::absolute(path, cli_cwd)))
-                .collect();
-        }
-
-        configuration
-    }
-}
-
-#[derive(Debug, clap::Subcommand)]
-pub enum Command {
-    /// Start the language server
-    Server,
-}
-
-#[allow(clippy::print_stdout, clippy::unnecessary_wraps, clippy::print_stderr)]
-pub fn main() -> ExitStatus {
-    run().unwrap_or_else(|error| {
-        use std::io::Write;
-
-        // Use `writeln` instead of `eprintln` to avoid panicking when the stderr pipe is broken.
-        let mut stderr = std::io::stderr().lock();
-
-        // This communicates that this isn't a linter error but Red Knot itself hard-errored for
-        // some reason (e.g. failed to resolve the configuration)
-        writeln!(stderr, "{}", "Red Knot failed".red().bold()).ok();
-        // Currently we generally only see one error, but e.g. with io errors when resolving
-        // the configuration it is help to chain errors ("resolving configuration failed" ->
-        // "failed to read file: subdir/pyproject.toml")
-        for cause in error.chain() {
-            writeln!(stderr, "  {} {cause}", "Cause:".bold()).ok();
-        }
-
-        ExitStatus::Error
-    })
-}
-
-fn run() -> anyhow::Result<ExitStatus> {
-    let args = Args::parse_from(std::env::args());
-
-    if matches!(args.command, Some(Command::Server)) {
-        return run_server().map(|()| ExitStatus::Success);
-    }
-
-    let verbosity = args.verbosity.level();
-    countme::enable(verbosity.is_trace());
-    let _guard = setup_tracing(verbosity)?;
-
-    // The base path to which all CLI arguments are relative to.
-    let cli_base_path = {
-        let cwd = std::env::current_dir().context("Failed to get the current working directory")?;
-        SystemPathBuf::from_path_buf(cwd)
-            .map_err(|path| {
-                anyhow!(
-                    "The current working directory `{}` contains non-Unicode characters. Red Knot only supports Unicode paths.",
-                    path.display()
-                )
-            })?
-    };
-
-    let cwd = args
-        .current_directory
-        .as_ref()
-        .map(|cwd| {
-            if cwd.as_std_path().is_dir() {
-                Ok(SystemPath::absolute(cwd, &cli_base_path))
-            } else {
-                Err(anyhow!(
-                    "Provided current-directory path `{cwd}` is not a directory"
-                ))
-            }
-        })
-        .transpose()?
-        .unwrap_or_else(|| cli_base_path.clone());
-
-    let system = OsSystem::new(cwd.clone());
-    let cli_configuration = args.to_configuration(&cwd);
-    let workspace_metadata = WorkspaceMetadata::from_path(
-        system.current_directory(),
-        &system,
-        Some(cli_configuration.clone()),
-    )?;
-
-    // TODO: Use the `program_settings` to compute the key for the database's persistent
-    //   cache and load the cache if it exists.
-    let mut db = RootDatabase::new(workspace_metadata, system)?;
-
-    let (main_loop, main_loop_cancellation_token) = MainLoop::new(cli_configuration);
-
-    // 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 exit_status = if args.watch {
-        main_loop.watch(&mut db)?
-    } else {
-        main_loop.run(&mut db)
-    };
-
-    tracing::trace!("Counts for entire CLI run:\n{}", countme::get_all());
-
-    std::mem::forget(db);
-
-    Ok(exit_status)
-}
-
-#[derive(Copy, Clone)]
-pub enum ExitStatus {
-    /// Checking was successful and there were no errors.
-    Success = 0,
-
-    /// Checking was successful but there were errors.
-    Failure = 1,
-
-    /// Checking failed.
-    Error = 2,
-}
-
-impl Termination for ExitStatus {
-    fn report(self) -> ExitCode {
-        ExitCode::from(self as u8)
-    }
-}
-
-struct MainLoop {
-    /// Sender that can be used to send messages to the main loop.
-    sender: crossbeam_channel::Sender<MainLoopMessage>,
-
-    /// Receiver for the messages sent **to** the main loop.
-    receiver: crossbeam_channel::Receiver<MainLoopMessage>,
-
-    /// The file system watcher, if running in watch mode.
-    watcher: Option<WorkspaceWatcher>,
-
-    cli_configuration: Configuration,
-}
-
-impl MainLoop {
-    fn new(cli_configuration: Configuration) -> (Self, MainLoopCancellationToken) {
-        let (sender, receiver) = crossbeam_channel::bounded(10);
-
-        (
-            Self {
-                sender: sender.clone(),
-                receiver,
-                watcher: None,
-                cli_configuration,
-            },
-            MainLoopCancellationToken { sender },
-        )
-    }
-
-    fn watch(mut self, db: &mut RootDatabase) -> anyhow::Result<ExitStatus> {
-        tracing::debug!("Starting watch mode");
-        let sender = self.sender.clone();
-        let watcher = watch::directory_watcher(move |event| {
-            sender.send(MainLoopMessage::ApplyChanges(event)).unwrap();
-        })?;
-
-        self.watcher = Some(WorkspaceWatcher::new(watcher, db));
-
-        self.run(db);
-
-        Ok(ExitStatus::Success)
-    }
-
-    fn run(mut self, db: &mut RootDatabase) -> ExitStatus {
-        self.sender.send(MainLoopMessage::CheckWorkspace).unwrap();
-
-        let result = self.main_loop(db);
-
-        tracing::debug!("Exiting main loop");
-
-        result
-    }
-
-    fn main_loop(&mut self, db: &mut RootDatabase) -> ExitStatus {
-        // Schedule the first check.
-        tracing::debug!("Starting main loop");
-
-        let mut revision = 0u64;
-
-        while let Ok(message) = self.receiver.recv() {
-            match message {
-                MainLoopMessage::CheckWorkspace => {
-                    let db = db.snapshot();
-                    let sender = self.sender.clone();
-
-                    // Spawn a new task that checks the workspace. This needs to be done in a separate thread
-                    // to prevent blocking the main loop here.
-                    rayon::spawn(move || {
-                        if let Ok(result) = db.check() {
-                            // Send the result back to the main loop for printing.
-                            sender
-                                .send(MainLoopMessage::CheckCompleted { result, revision })
-                                .unwrap();
-                        }
-                    });
-                }
-
-                MainLoopMessage::CheckCompleted {
-                    result,
-                    revision: check_revision,
-                } => {
-                    let has_diagnostics = !result.is_empty();
-                    if check_revision == revision {
-                        #[allow(clippy::print_stdout)]
-                        for diagnostic in result {
-                            println!("{}", diagnostic.display(db));
-                        }
-                    } else {
-                        tracing::debug!(
-                            "Discarding check result for outdated revision: current: {revision}, result revision: {check_revision}"
-                        );
-                    }
-
-                    if self.watcher.is_none() {
-                        return if has_diagnostics {
-                            ExitStatus::Failure
-                        } else {
-                            ExitStatus::Success
-                        };
-                    }
-
-                    tracing::trace!("Counts after last check:\n{}", countme::get_all());
-                }
-
-                MainLoopMessage::ApplyChanges(changes) => {
-                    revision += 1;
-                    // Automatically cancels any pending queries and waits for them to complete.
-                    db.apply_changes(changes, Some(&self.cli_configuration));
-                    if let Some(watcher) = self.watcher.as_mut() {
-                        watcher.update(db);
-                    }
-                    self.sender.send(MainLoopMessage::CheckWorkspace).unwrap();
-                }
-                MainLoopMessage::Exit => {
-                    // Cancel any pending queries and wait for them to complete.
-                    // TODO: Don't use Salsa internal APIs
-                    //  [Zulip-Thread](https://salsa.zulipchat.com/#narrow/stream/333573-salsa-3.2E0/topic/Expose.20an.20API.20to.20cancel.20other.20queries)
-                    let _ = db.zalsa_mut();
-                    return ExitStatus::Success;
-                }
-            }
-
-            tracing::debug!("Waiting for next main loop message.");
-        }
-
-        ExitStatus::Success
-    }
-}
-
-#[derive(Debug)]
-struct MainLoopCancellationToken {
-    sender: crossbeam_channel::Sender<MainLoopMessage>,
-}
-
-impl MainLoopCancellationToken {
-    fn stop(self) {
-        self.sender.send(MainLoopMessage::Exit).unwrap();
-    }
-}
-
-/// Message sent from the orchestrator to the main loop.
-#[derive(Debug)]
-enum MainLoopMessage {
-    CheckWorkspace,
-    CheckCompleted {
-        result: Vec<Box<dyn Diagnostic>>,
-        revision: u64,
-    },
-    ApplyChanges(Vec<watch::ChangeEvent>),
-    Exit,
-}

crates/red_knot/src/target_version.rs

@@ -1,48 +0,0 @@
-/// Enumeration of all supported Python versions
-///
-/// TODO: unify with the `PythonVersion` enum in the linter/formatter crates?
-#[derive(Copy, Clone, Hash, Debug, PartialEq, Eq, PartialOrd, Ord, Default, clap::ValueEnum)]
-pub enum TargetVersion {
-    Py37,
-    #[default]
-    Py38,
-    Py39,
-    Py310,
-    Py311,
-    Py312,
-    Py313,
-}
-
-impl TargetVersion {
-    const fn as_str(self) -> &'static str {
-        match self {
-            Self::Py37 => "py37",
-            Self::Py38 => "py38",
-            Self::Py39 => "py39",
-            Self::Py310 => "py310",
-            Self::Py311 => "py311",
-            Self::Py312 => "py312",
-            Self::Py313 => "py313",
-        }
-    }
-}
-
-impl std::fmt::Display for TargetVersion {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.as_str())
-    }
-}
-
-impl From<TargetVersion> for red_knot_python_semantic::PythonVersion {
-    fn from(value: TargetVersion) -> Self {
-        match value {
-            TargetVersion::Py37 => Self::PY37,
-            TargetVersion::Py38 => Self::PY38,
-            TargetVersion::Py39 => Self::PY39,
-            TargetVersion::Py310 => Self::PY310,
-            TargetVersion::Py311 => Self::PY311,
-            TargetVersion::Py312 => Self::PY312,
-            TargetVersion::Py313 => Self::PY313,
-        }
-    }
-}

crates/red_knot/src/verbosity.rs

@@ -1 +0,0 @@
-

crates/red_knot_python_semantic/Cargo.toml

@@ -1,52 +0,0 @@
-[package]
-name = "red_knot_python_semantic"
-version = "0.0.0"
-publish = false
-authors = { workspace = true }
-edition = { workspace = true }
-rust-version = { workspace = true }
-homepage = { workspace = true }
-documentation = { workspace = true }
-repository = { workspace = true }
-license = { workspace = true }
-
-[dependencies]
-ruff_db = { workspace = true }
-ruff_index = { workspace = true }
-ruff_python_ast = { workspace = true, features = ["salsa"] }
-ruff_python_stdlib = { workspace = true }
-ruff_source_file = { workspace = true }
-ruff_text_size = { workspace = true }
-ruff_python_literal = { workspace = true }
-
-anyhow = { workspace = true }
-bitflags = { workspace = true }
-camino = { workspace = true }
-compact_str = { workspace = true }
-countme = { workspace = true }
-indexmap = { workspace = true }
-itertools = { workspace = true }
-ordermap = { workspace = true }
-salsa = { workspace = true }
-thiserror = { workspace = true }
-tracing = { workspace = true }
-rustc-hash = { workspace = true }
-hashbrown = { workspace = true }
-smallvec = { workspace = true }
-static_assertions = { workspace = true }
-test-case = { workspace = true }
-memchr = { workspace = true }
-
-[dev-dependencies]
-ruff_db = { workspace = true, features = ["os", "testing"] }
-ruff_python_parser = { workspace = true }
-red_knot_test = { workspace = true }
-red_knot_vendored = { workspace = true }
-
-anyhow = { workspace = true }
-dir-test = { workspace = true }
-insta = { workspace = true }
-tempfile = { workspace = true }
-
-[lints]
-workspace = true

crates/red_knot_python_semantic/build.rs

@@ -1,4 +0,0 @@
-/// Rebuild the crate if a test file is added or removed from
-pub fn main() {
-    println!("cargo::rerun-if-changed=resources/mdtest");
-}

crates/red_knot_python_semantic/resources/README.md

@@ -1,4 +0,0 @@
-Markdown files within the `mdtest/` subdirectory are tests of type inference and type checking;
-executed by the `tests/mdtest.rs` integration test.
-
-See `crates/red_knot_test/README.md` for documentation of this test format.

crates/red_knot_python_semantic/resources/mdtest/.mdformat.toml

@@ -1 +0,0 @@
-wrap = 100

crates/red_knot_python_semantic/resources/mdtest/annotations/starred_expressions.md

@@ -1,18 +0,0 @@
-# Starred expression annotations
-
-Type annotations for `*args` can be starred expressions themselves:
-
-```py
-from typing_extensions import TypeVarTuple
-
-Ts = TypeVarTuple("Ts")
-
-def append_int(*args: *Ts) -> tuple[*Ts, int]:
-    # TODO: should show some representation of the variadic generic type
-    reveal_type(args)  # revealed: @Todo
-
-    return (*args, 1)
-
-# TODO should be tuple[Literal[True], Literal["a"], int]
-reveal_type(append_int(True, "a"))  # revealed: @Todo
-```

crates/red_knot_python_semantic/resources/mdtest/annotations/string_annotations.md

@@ -1,9 +0,0 @@
-# String annotations
-
-```py
-def f() -> "int":
-    return 1
-
-# TODO: We do not support string annotations, but we should not panic if we encounter them
-reveal_type(f())  # revealed: @Todo
-```

crates/red_knot_python_semantic/resources/mdtest/assignment/annotations.md

@@ -1,112 +0,0 @@
-# Assignment with annotations
-
-## Annotation only transparent to local inference
-
-```py
-x = 1
-x: int
-y = x
-
-reveal_type(y)  # revealed: Literal[1]
-```
-
-## Violates own annotation
-
-```py
-x: int = "foo"  # error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `int`"
-```
-
-## Violates previous annotation
-
-```py
-x: int
-x = "foo"  # error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `int`"
-```
-
-## Tuple annotations are understood
-
-```py path=module.py
-from typing_extensions import Unpack
-
-a: tuple[()] = ()
-b: tuple[int] = (42,)
-c: tuple[str, int] = ("42", 42)
-d: tuple[tuple[str, str], tuple[int, int]] = (("foo", "foo"), (42, 42))
-e: tuple[str, ...] = ()
-# TODO: we should not emit this error
-# error: [call-possibly-unbound-method] "Method `__class_getitem__` of type `Literal[tuple]` is possibly unbound"
-f: tuple[str, *tuple[int, ...], bytes] = ("42", b"42")
-g: tuple[str, Unpack[tuple[int, ...]], bytes] = ("42", b"42")
-h: tuple[list[int], list[int]] = ([], [])
-i: tuple[str | int, str | int] = (42, 42)
-j: tuple[str | int] = (42,)
-```
-
-```py path=script.py
-from module import a, b, c, d, e, f, g, h, i, j
-
-reveal_type(a)  # revealed: tuple[()]
-reveal_type(b)  # revealed: tuple[int]
-reveal_type(c)  # revealed: tuple[str, int]
-reveal_type(d)  # revealed: tuple[tuple[str, str], tuple[int, int]]
-
-# TODO: homogenous tuples, PEP-646 tuples
-reveal_type(e)  # revealed: @Todo
-reveal_type(f)  # revealed: @Todo
-reveal_type(g)  # revealed: @Todo
-
-# TODO: support more kinds of type expressions in annotations
-reveal_type(h)  # revealed: @Todo
-
-reveal_type(i)  # revealed: tuple[str | int, str | int]
-reveal_type(j)  # revealed: tuple[str | int]
-```
-
-## Incorrect tuple assignments are complained about
-
-```py
-# error: [invalid-assignment] "Object of type `tuple[Literal[1], Literal[2]]` is not assignable to `tuple[()]`"
-a: tuple[()] = (1, 2)
-
-# error: [invalid-assignment] "Object of type `tuple[Literal["foo"]]` is not assignable to `tuple[int]`"
-b: tuple[int] = ("foo",)
-
-# error: [invalid-assignment] "Object of type `tuple[list, Literal["foo"]]` is not assignable to `tuple[str | int, str]`"
-c: tuple[str | int, str] = ([], "foo")
-```
-
-## PEP-604 annotations are supported
-
-```py
-def foo() -> str | int | None:
-    return None
-
-reveal_type(foo())  # revealed: str | int | None
-
-def bar() -> str | str | None:
-    return None
-
-reveal_type(bar())  # revealed: str | None
-
-def baz() -> str | str:
-    return "Hello, world!"
-
-reveal_type(baz())  # revealed: str
-```
-
-## Attribute expressions in type annotations are understood
-
-```py
-import builtins
-
-int = "foo"
-a: builtins.int = 42
-
-# error: [invalid-assignment] "Object of type `Literal["bar"]` is not assignable to `int`"
-b: builtins.int = "bar"
-
-c: builtins.tuple[builtins.tuple[builtins.int, builtins.int], builtins.int] = ((42, 42), 42)
-
-# error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `tuple[tuple[int, int], int]`"
-c: builtins.tuple[builtins.tuple[builtins.int, builtins.int], builtins.int] = "foo"
-```

crates/red_knot_python_semantic/resources/mdtest/assignment/augmented.md

@@ -1,182 +0,0 @@
-# Augmented assignment
-
-## Basic
-
-```py
-x = 3
-x -= 1
-reveal_type(x)  # revealed: Literal[2]
-
-x = 1.0
-x /= 2
-reveal_type(x)  # revealed: float
-```
-
-## Dunder methods
-
-```py
-class C:
-    def __isub__(self, other: int) -> str:
-        return "Hello, world!"
-
-x = C()
-x -= 1
-reveal_type(x)  # revealed: str
-
-class C:
-    def __iadd__(self, other: str) -> float:
-        return 1.0
-
-x = C()
-x += "Hello"
-reveal_type(x)  # revealed: float
-```
-
-## Unsupported types
-
-```py
-class C:
-    def __isub__(self, other: str) -> int:
-        return 42
-
-x = C()
-x -= 1
-
-# TODO: should error, once operand type check is implemented
-reveal_type(x)  # revealed: int
-```
-
-## Method union
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-class Foo:
-    if bool_instance():
-        def __iadd__(self, other: int) -> str:
-            return "Hello, world!"
-    else:
-        def __iadd__(self, other: int) -> int:
-            return 42
-
-f = Foo()
-f += 12
-
-reveal_type(f)  # revealed: str | int
-```
-
-## Partially bound `__iadd__`
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class Foo:
-    if bool_instance():
-        def __iadd__(self, other: str) -> int:
-            return 42
-
-f = Foo()
-
-# TODO: We should emit an `unsupported-operator` error here, possibly with the information
-# that `Foo.__iadd__` may be unbound as additional context.
-f += "Hello, world!"
-
-reveal_type(f)  # revealed: int | Unknown
-```
-
-## Partially bound with `__add__`
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class Foo:
-    def __add__(self, other: str) -> str:
-        return "Hello, world!"
-    if bool_instance():
-        def __iadd__(self, other: str) -> int:
-            return 42
-
-f = Foo()
-f += "Hello, world!"
-
-reveal_type(f)  # revealed: int | str
-```
-
-## Partially bound target union
-
-```py
-def bool_instance() -> bool:
-    return True
-
-class Foo:
-    def __add__(self, other: int) -> str:
-        return "Hello, world!"
-    if bool_instance():
-        def __iadd__(self, other: int) -> int:
-            return 42
-
-if bool_instance():
-    f = Foo()
-else:
-    f = 42.0
-f += 12
-
-reveal_type(f)  # revealed: int | str | float
-```
-
-## Target union
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-class Foo:
-    def __iadd__(self, other: int) -> str:
-        return "Hello, world!"
-
-if flag:
-    f = Foo()
-else:
-    f = 42.0
-f += 12
-
-reveal_type(f)  # revealed: str | float
-```
-
-## Partially bound target union with `__add__`
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-class Foo:
-    def __add__(self, other: int) -> str:
-        return "Hello, world!"
-    if bool_instance():
-        def __iadd__(self, other: int) -> int:
-            return 42
-
-class Bar:
-    def __add__(self, other: int) -> bytes:
-        return b"Hello, world!"
-
-    def __iadd__(self, other: int) -> float:
-        return 42.0
-
-if flag:
-    f = Foo()
-else:
-    f = Bar()
-f += 12
-
-reveal_type(f)  # revealed: int | str | float
-```

crates/red_knot_python_semantic/resources/mdtest/assignment/multi_target.md

@@ -1,9 +0,0 @@
-# Multi-target assignment
-
-## Basic
-
-```py
-x = y = 1
-reveal_type(x)  # revealed: Literal[1]
-reveal_type(y)  # revealed: Literal[1]
-```

crates/red_knot_python_semantic/resources/mdtest/assignment/unbound.md

@@ -1,59 +0,0 @@
-# Unbound
-
-## Unbound
-
-```py
-x = foo  # error: [unresolved-reference] "Name `foo` used when not defined"
-foo = 1
-
-# No error `unresolved-reference` diagnostic is reported for `x`. This is
-# desirable because we would get a lot of cascading errors even though there
-# is only one root cause (the unbound variable `foo`).
-
-# revealed: Unknown
-reveal_type(x)
-```
-
-Note: in this particular example, one could argue that the most likely error would be a wrong order
-of the `x`/`foo` definitions, and so it could be desirable to infer `Literal[1]` for the type of
-`x`. On the other hand, there might be a variable `fob` a little higher up in this file, and the
-actual error might have been just a typo. Inferring `Unknown` thus seems like the safest option.
-
-## Unbound class variable
-
-Name lookups within a class scope fall back to globals, but lookups of class attributes don't.
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-x = 1
-
-class C:
-    y = x
-    if flag:
-        x = 2
-
-reveal_type(C.x)  # revealed: Literal[2]
-reveal_type(C.y)  # revealed: Literal[1]
-```
-
-## Possibly unbound in class and global scope
-
-```py
-def bool_instance() -> bool:
-    return True
-
-if bool_instance():
-    x = "abc"
-
-class C:
-    if bool_instance():
-        x = 1
-
-    # error: [possibly-unresolved-reference]
-    y = x
-
-reveal_type(C.y)  # revealed: Literal[1] | Literal["abc"]
-```

crates/red_knot_python_semantic/resources/mdtest/assignment/walrus.md

@@ -1,17 +0,0 @@
-# Walrus operator
-
-## Basic
-
-```py
-x = (y := 1) + 1
-reveal_type(x)  # revealed: Literal[2]
-reveal_type(y)  # revealed: Literal[1]
-```
-
-## Walrus self-addition
-
-```py
-x = 0
-(x := x + 1)
-reveal_type(x)  # revealed: Literal[1]
-```

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -1,55 +0,0 @@
-# Class attributes
-
-## Union of attributes
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-if flag:
-    class C:
-        x = 1
-
-else:
-    class C:
-        x = 2
-
-reveal_type(C.x)  # revealed: Literal[1, 2]
-```
-
-## Inherited attributes
-
-```py
-class A:
-    X = "foo"
-
-class B(A): ...
-class C(B): ...
-
-reveal_type(C.X)  # revealed: Literal["foo"]
-```
-
-## Inherited attributes (multiple inheritance)
-
-```py
-class O: ...
-
-class F(O):
-    X = 56
-
-class E(O):
-    X = 42
-
-class D(O): ...
-class C(D, F): ...
-class B(E, D): ...
-class A(B, C): ...
-
-# revealed: tuple[Literal[A], Literal[B], Literal[E], Literal[C], Literal[D], Literal[F], Literal[O], Literal[object]]
-reveal_type(A.__mro__)
-
-# `E` is earlier in the MRO than `F`, so we should use the type of `E.X`
-reveal_type(A.X)  # revealed: Literal[42]
-```

crates/red_knot_python_semantic/resources/mdtest/binary/booleans.md

@@ -1,48 +0,0 @@
-## Binary operations on booleans
-
-## Basic Arithmetic
-
-We try to be precise and all operations except for division will result in Literal type.
-
-```py
-a = True
-b = False
-
-reveal_type(a + a)  # revealed: Literal[2]
-reveal_type(a + b)  # revealed: Literal[1]
-reveal_type(b + a)  # revealed: Literal[1]
-reveal_type(b + b)  # revealed: Literal[0]
-
-reveal_type(a - a)  # revealed: Literal[0]
-reveal_type(a - b)  # revealed: Literal[1]
-reveal_type(b - a)  # revealed: Literal[-1]
-reveal_type(b - b)  # revealed: Literal[0]
-
-reveal_type(a * a)  # revealed: Literal[1]
-reveal_type(a * b)  # revealed: Literal[0]
-reveal_type(b * a)  # revealed: Literal[0]
-reveal_type(b * b)  # revealed: Literal[0]
-
-reveal_type(a % a)  # revealed: Literal[0]
-reveal_type(b % a)  # revealed: Literal[0]
-
-reveal_type(a // a)  # revealed: Literal[1]
-reveal_type(b // a)  # revealed: Literal[0]
-
-reveal_type(a**a)  # revealed: Literal[1]
-reveal_type(a**b)  # revealed: Literal[1]
-reveal_type(b**a)  # revealed: Literal[0]
-reveal_type(b**b)  # revealed: Literal[1]
-
-# Division
-reveal_type(a / a)  # revealed: float
-reveal_type(b / a)  # revealed: float
-b / b  # error: [division-by-zero] "Cannot divide object of type `Literal[False]` by zero"
-a / b  # error: [division-by-zero] "Cannot divide object of type `Literal[True]` by zero"
-
-# bitwise OR
-reveal_type(a | a)  # revealed: Literal[True]
-reveal_type(a | b)  # revealed: Literal[True]
-reveal_type(b | a)  # revealed: Literal[True]
-reveal_type(b | b)  # revealed: Literal[False]
-```

crates/red_knot_python_semantic/resources/mdtest/binary/instances.md

@@ -1,435 +0,0 @@
-# Binary operations on instances
-
-Binary operations in Python are implemented by means of magic double-underscore methods.
-
-For references, see:
-
-- <https://snarky.ca/unravelling-binary-arithmetic-operations-in-python/>
-- <https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types>
-
-## Operations
-
-We support inference for all Python's binary operators: `+`, `-`, `*`, `@`, `/`, `//`, `%`, `**`,
-`<<`, `>>`, `&`, `^`, and `|`.
-
-```py
-class A:
-    def __add__(self, other) -> A:
-        return self
-
-    def __sub__(self, other) -> A:
-        return self
-
-    def __mul__(self, other) -> A:
-        return self
-
-    def __matmul__(self, other) -> A:
-        return self
-
-    def __truediv__(self, other) -> A:
-        return self
-
-    def __floordiv__(self, other) -> A:
-        return self
-
-    def __mod__(self, other) -> A:
-        return self
-
-    def __pow__(self, other) -> A:
-        return self
-
-    def __lshift__(self, other) -> A:
-        return self
-
-    def __rshift__(self, other) -> A:
-        return self
-
-    def __and__(self, other) -> A:
-        return self
-
-    def __xor__(self, other) -> A:
-        return self
-
-    def __or__(self, other) -> A:
-        return self
-
-class B: ...
-
-reveal_type(A() + B())  # revealed: A
-reveal_type(A() - B())  # revealed: A
-reveal_type(A() * B())  # revealed: A
-reveal_type(A() @ B())  # revealed: A
-reveal_type(A() / B())  # revealed: A
-reveal_type(A() // B())  # revealed: A
-reveal_type(A() % B())  # revealed: A
-reveal_type(A() ** B())  # revealed: A
-reveal_type(A() << B())  # revealed: A
-reveal_type(A() >> B())  # revealed: A
-reveal_type(A() & B())  # revealed: A
-reveal_type(A() ^ B())  # revealed: A
-reveal_type(A() | B())  # revealed: A
-```
-
-## Reflected
-
-We also support inference for reflected operations:
-
-```py
-class A:
-    def __radd__(self, other) -> A:
-        return self
-
-    def __rsub__(self, other) -> A:
-        return self
-
-    def __rmul__(self, other) -> A:
-        return self
-
-    def __rmatmul__(self, other) -> A:
-        return self
-
-    def __rtruediv__(self, other) -> A:
-        return self
-
-    def __rfloordiv__(self, other) -> A:
-        return self
-
-    def __rmod__(self, other) -> A:
-        return self
-
-    def __rpow__(self, other) -> A:
-        return self
-
-    def __rlshift__(self, other) -> A:
-        return self
-
-    def __rrshift__(self, other) -> A:
-        return self
-
-    def __rand__(self, other) -> A:
-        return self
-
-    def __rxor__(self, other) -> A:
-        return self
-
-    def __ror__(self, other) -> A:
-        return self
-
-class B: ...
-
-reveal_type(B() + A())  # revealed: A
-reveal_type(B() - A())  # revealed: A
-reveal_type(B() * A())  # revealed: A
-reveal_type(B() @ A())  # revealed: A
-reveal_type(B() / A())  # revealed: A
-reveal_type(B() // A())  # revealed: A
-reveal_type(B() % A())  # revealed: A
-reveal_type(B() ** A())  # revealed: A
-reveal_type(B() << A())  # revealed: A
-reveal_type(B() >> A())  # revealed: A
-reveal_type(B() & A())  # revealed: A
-reveal_type(B() ^ A())  # revealed: A
-reveal_type(B() | A())  # revealed: A
-```
-
-## Returning a different type
-
-The magic methods aren't required to return the type of `self`:
-
-```py
-class A:
-    def __add__(self, other) -> int:
-        return 1
-
-    def __rsub__(self, other) -> int:
-        return 1
-
-class B: ...
-
-reveal_type(A() + B())  # revealed: int
-reveal_type(B() - A())  # revealed: int
-```
-
-## Non-reflected precedence in general
-
-In general, if the left-hand side defines `__add__` and the right-hand side defines `__radd__` and
-the right-hand side is not a subtype of the left-hand side, `lhs.__add__` will take precedence:
-
-```py
-class A:
-    def __add__(self, other: B) -> int:
-        return 42
-
-class B:
-    def __radd__(self, other: A) -> str:
-        return "foo"
-
-reveal_type(A() + B())  # revealed:  int
-
-# Edge case: C is a subtype of C, *but* if the two sides are of *equal* types,
-# the lhs *still* takes precedence
-class C:
-    def __add__(self, other: C) -> int:
-        return 42
-
-    def __radd__(self, other: C) -> str:
-        return "foo"
-
-reveal_type(C() + C())  # revealed: int
-```
-
-## Reflected precedence for subtypes (in some cases)
-
-If the right-hand operand is a subtype of the left-hand operand and has a different implementation
-of the reflected method, the reflected method on the right-hand operand takes precedence.
-
-```py
-class A:
-    def __add__(self, other) -> str:
-        return "foo"
-
-    def __radd__(self, other) -> str:
-        return "foo"
-
-class MyString(str): ...
-
-class B(A):
-    def __radd__(self, other) -> MyString:
-        return MyString()
-
-reveal_type(A() + B())  # revealed: MyString
-
-# N.B. Still a subtype of `A`, even though `A` does not appear directly in the class's `__bases__`
-class C(B): ...
-
-reveal_type(A() + C())  # revealed: MyString
-```
-
-## Reflected precedence 2
-
-If the right-hand operand is a subtype of the left-hand operand, but does not override the reflected
-method, the left-hand operand's non-reflected method still takes precedence:
-
-```py
-class A:
-    def __add__(self, other) -> str:
-        return "foo"
-
-    def __radd__(self, other) -> int:
-        return 42
-
-class B(A): ...
-
-reveal_type(A() + B())  # revealed: str
-```
-
-## Only reflected supported
-
-For example, at runtime, `(1).__add__(1.2)` is `NotImplemented`, but `(1.2).__radd__(1) == 2.2`,
-meaning that `1 + 1.2` succeeds at runtime (producing `2.2`). The runtime tries the second one only
-if the first one returns `NotImplemented` to signal failure.
-
-Typeshed and other stubs annotate dunder-method calls that would return `NotImplemented` as being
-"illegal" calls. `int.__add__` is annotated as only "accepting" `int`s, even though it
-strictly-speaking "accepts" any other object without raising an exception -- it will simply return
-`NotImplemented`, allowing the runtime to try the `__radd__` method of the right-hand operand as
-well.
-
-```py
-class A:
-    def __sub__(self, other: A) -> A:
-        return A()
-
-class B:
-    def __rsub__(self, other: A) -> B:
-        return B()
-
-# TODO: this should be `B` (the return annotation of `B.__rsub__`),
-# because `A.__sub__` is annotated as only accepting `A`,
-# but `B.__rsub__` will accept `A`.
-reveal_type(A() - B())  # revealed: A
-```
-
-## Callable instances as dunders
-
-Believe it or not, this is supported at runtime:
-
-```py
-class A:
-    def __call__(self, other) -> int:
-        return 42
-
-class B:
-    __add__ = A()
-
-reveal_type(B() + B())  # revealed: int
-```
-
-## Integration test: numbers from typeshed
-
-```py
-reveal_type(3j + 3.14)  # revealed: complex
-reveal_type(4.2 + 42)  # revealed: float
-reveal_type(3j + 3)  # revealed: complex
-
-# TODO should be complex, need to check arg type and fall back to `rhs.__radd__`
-reveal_type(3.14 + 3j)  # revealed: float
-
-# TODO should be float, need to check arg type and fall back to `rhs.__radd__`
-reveal_type(42 + 4.2)  # revealed: int
-
-# TODO should be complex, need to check arg type and fall back to `rhs.__radd__`
-reveal_type(3 + 3j)  # revealed: int
-
-def returns_int() -> int:
-    return 42
-
-def returns_bool() -> bool:
-    return True
-
-x = returns_bool()
-y = returns_int()
-
-reveal_type(x + y)  # revealed: int
-reveal_type(4.2 + x)  # revealed: float
-
-# TODO should be float, need to check arg type and fall back to `rhs.__radd__`
-reveal_type(y + 4.12)  # revealed: int
-```
-
-## With literal types
-
-When we have a literal type for one operand, we're able to fall back to the instance handling for
-its instance super-type.
-
-```py
-class A:
-    def __add__(self, other) -> A:
-        return self
-
-    def __radd__(self, other) -> A:
-        return self
-
-reveal_type(A() + 1)  # revealed: A
-# TODO should be `A` since `int.__add__` doesn't support `A` instances
-reveal_type(1 + A())  # revealed: int
-
-reveal_type(A() + "foo")  # revealed: A
-# TODO should be `A` since `str.__add__` doesn't support `A` instances
-# TODO overloads
-reveal_type("foo" + A())  # revealed: @Todo
-
-reveal_type(A() + b"foo")  # revealed: A
-# TODO should be `A` since `bytes.__add__` doesn't support `A` instances
-reveal_type(b"foo" + A())  # revealed: bytes
-
-reveal_type(A() + ())  # revealed: A
-# TODO this should be `A`, since `tuple.__add__` doesn't support `A` instances
-reveal_type(() + A())  # revealed: @Todo
-
-literal_string_instance = "foo" * 1_000_000_000
-# the test is not testing what it's meant to be testing if this isn't a `LiteralString`:
-reveal_type(literal_string_instance)  # revealed: LiteralString
-
-reveal_type(A() + literal_string_instance)  # revealed: A
-# TODO should be `A` since `str.__add__` doesn't support `A` instances
-# TODO overloads
-reveal_type(literal_string_instance + A())  # revealed: @Todo
-```
-
-## Operations involving instances of classes inheriting from `Any`
-
-`Any` and `Unknown` represent a set of possible runtime objects, wherein the bounds of the set are
-unknown. Whether the left-hand operand's dunder or the right-hand operand's reflected dunder depends
-on whether the right-hand operand is an instance of a class that is a subclass of the left-hand
-operand's class and overrides the reflected dunder. In the following example, because of the
-unknowable nature of `Any`/`Unknown`, we must consider both possibilities: `Any`/`Unknown` might
-resolve to an unknown third class that inherits from `X` and overrides `__radd__`; but it also might
-not. Thus, the correct answer here for the `reveal_type` is `int | Unknown`.
-
-```py
-from does_not_exist import Foo  # error: [unresolved-import]
-
-reveal_type(Foo)  # revealed: Unknown
-
-class X:
-    def __add__(self, other: object) -> int:
-        return 42
-
-class Y(Foo): ...
-
-# TODO: Should be `int | Unknown`; see above discussion.
-reveal_type(X() + Y())  # revealed: int
-```
-
-## Unsupported
-
-### Dunder as instance attribute
-
-The magic method must exist on the class, not just on the instance:
-
-```py
-def add_impl(self, other) -> int:
-    return 1
-
-class A:
-    def __init__(self):
-        self.__add__ = add_impl
-
-# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `A` and `A`"
-# revealed: Unknown
-reveal_type(A() + A())
-```
-
-### Missing dunder
-
-```py
-class A: ...
-
-# error: [unsupported-operator]
-# revealed: Unknown
-reveal_type(A() + A())
-```
-
-### Wrong position
-
-A left-hand dunder method doesn't apply for the right-hand operand, or vice versa:
-
-```py
-class A:
-    def __add__(self, other) -> int: ...
-
-class B:
-    def __radd__(self, other) -> int: ...
-
-class C: ...
-
-# error: [unsupported-operator]
-# revealed: Unknown
-reveal_type(C() + A())
-
-# error: [unsupported-operator]
-# revealed: Unknown
-reveal_type(B() + C())
-```
-
-### Reflected dunder is not tried between two objects of the same type
-
-For the specific case where the left-hand operand is the exact same type as the right-hand operand,
-the reflected dunder of the right-hand operand is not tried; the runtime short-circuits after trying
-the unreflected dunder of the left-hand operand. For context, see
-[this mailing list discussion](https://mail.python.org/archives/list/python-dev@python.org/thread/7NZUCODEAPQFMRFXYRMGJXDSIS3WJYIV/).
-
-```py
-class Foo:
-    def __radd__(self, other: Foo) -> Foo:
-        return self
-
-# error: [unsupported-operator]
-# revealed: Unknown
-reveal_type(Foo() + Foo())
-```
-
-### Wrong type
-
-TODO: check signature and error if `other` is the wrong type

crates/red_knot_python_semantic/resources/mdtest/binary/integers.md

@@ -1,70 +0,0 @@
-# Binary operations on integers
-
-## Basic Arithmetic
-
-```py
-reveal_type(2 + 1)  # revealed: Literal[3]
-reveal_type(3 - 4)  # revealed: Literal[-1]
-reveal_type(3 * -1)  # revealed: Literal[-3]
-reveal_type(-3 // 3)  # revealed: Literal[-1]
-reveal_type(-3 / 3)  # revealed: float
-reveal_type(5 % 3)  # revealed: Literal[2]
-```
-
-## Power
-
-For power if the result fits in the int literal type it will be a Literal type. Otherwise the
-outcome is int.
-
-```py
-largest_u32 = 4_294_967_295
-reveal_type(2**2)  # revealed: Literal[4]
-reveal_type(1 ** (largest_u32 + 1))  # revealed: int
-reveal_type(2**largest_u32)  # revealed: int
-```
-
-## Division by Zero
-
-This error is really outside the current Python type system, because e.g. `int.__truediv__` and
-friends are not annotated to indicate that it's an error, and we don't even have a facility to
-permit such an annotation. So arguably divide-by-zero should be a lint error rather than a type
-checker error. But we choose to go ahead and error in the cases that are very likely to be an error:
-dividing something typed as `int` or `float` by something known to be `Literal[0]`.
-
-This isn't _definitely_ an error, because the object typed as `int` or `float` could be an instance
-of a custom subclass which overrides division behavior to handle zero without error. But if this
-unusual case occurs, the error can be avoided by explicitly typing the dividend as that safe custom
-subclass; we only emit the error if the LHS type is exactly `int` or `float`, not if its a subclass.
-
-```py
-a = 1 / 0  # error: "Cannot divide object of type `Literal[1]` by zero"
-reveal_type(a)  # revealed: float
-
-b = 2 // 0  # error: "Cannot floor divide object of type `Literal[2]` by zero"
-reveal_type(b)  # revealed: int
-
-c = 3 % 0  # error: "Cannot reduce object of type `Literal[3]` modulo zero"
-reveal_type(c)  # revealed: int
-
-# error: "Cannot divide object of type `int` by zero"
-# revealed: float
-reveal_type(int() / 0)
-
-# error: "Cannot divide object of type `Literal[1]` by zero"
-# revealed: float
-reveal_type(1 / False)
-# error: [division-by-zero] "Cannot divide object of type `Literal[True]` by zero"
-True / False
-# error: [division-by-zero] "Cannot divide object of type `Literal[True]` by zero"
-bool(1) / False
-
-# error: "Cannot divide object of type `float` by zero"
-# revealed: float
-reveal_type(1.0 / 0)
-
-class MyInt(int): ...
-
-# No error for a subclass of int
-# revealed: float
-reveal_type(MyInt(3) / 0)
-```

crates/red_knot_python_semantic/resources/mdtest/boolean/short_circuit.md

@@ -1,78 +0,0 @@
-# Short-Circuit Evaluation
-
-## Not all boolean expressions must be evaluated
-
-In `or` expressions, if the left-hand side is truthy, the right-hand side is not evaluated.
-Similarly, in `and` expressions, if the left-hand side is falsy, the right-hand side is not
-evaluated.
-
-```py
-def bool_instance() -> bool:
-    return True
-
-if bool_instance() or (x := 1):
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-
-if bool_instance() and (x := 1):
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-```
-
-## First expression is always evaluated
-
-```py
-def bool_instance() -> bool:
-    return True
-
-if (x := 1) or bool_instance():
-    reveal_type(x)  # revealed: Literal[1]
-
-if (x := 1) and bool_instance():
-    reveal_type(x)  # revealed: Literal[1]
-```
-
-## Statically known truthiness
-
-```py
-if True or (x := 1):
-    # TODO: infer that the second arm is never executed, and raise `unresolved-reference`.
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-
-if True and (x := 1):
-    # TODO: infer that the second arm is always executed, do not raise a diagnostic
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-```
-
-## Later expressions can always use variables from earlier expressions
-
-```py
-def bool_instance() -> bool:
-    return True
-
-bool_instance() or (x := 1) or reveal_type(x)  # revealed: Literal[1]
-
-# error: [unresolved-reference]
-bool_instance() or reveal_type(y) or (y := 1)  # revealed: Unknown
-```
-
-## Nested expressions
-
-```py
-def bool_instance() -> bool:
-    return True
-
-if bool_instance() or ((x := 1) and bool_instance()):
-    # error: [possibly-unresolved-reference]
-    reveal_type(x)  # revealed: Literal[1]
-
-if ((y := 1) and bool_instance()) or bool_instance():
-    reveal_type(y)  # revealed: Literal[1]
-
-# error: [possibly-unresolved-reference]
-if (bool_instance() and (z := 1)) or reveal_type(z):  # revealed: Literal[1]
-    # error: [possibly-unresolved-reference]
-    reveal_type(z)  # revealed: Literal[1]
-```

crates/red_knot_python_semantic/resources/mdtest/call/callable_instance.md

@@ -1,75 +0,0 @@
-# Callable instance
-
-## Dunder call
-
-```py
-class Multiplier:
-    def __init__(self, factor: float):
-        self.factor = factor
-
-    def __call__(self, number: float) -> float:
-        return number * self.factor
-
-a = Multiplier(2.0)(3.0)
-reveal_type(a)  # revealed: float
-
-class Unit: ...
-
-b = Unit()(3.0)  # error: "Object of type `Unit` is not callable"
-reveal_type(b)  # revealed: Unknown
-```
-
-## Possibly unbound `__call__` method
-
-```py
-def flag() -> bool: ...
-
-class PossiblyNotCallable:
-    if flag():
-        def __call__(self) -> int: ...
-
-a = PossiblyNotCallable()
-result = a()  # error: "Object of type `PossiblyNotCallable` is not callable (possibly unbound `__call__` method)"
-reveal_type(result)  # revealed: int
-```
-
-## Possibly unbound callable
-
-```py
-def flag() -> bool: ...
-
-if flag():
-    class PossiblyUnbound:
-        def __call__(self) -> int: ...
-
-# error: [possibly-unresolved-reference]
-a = PossiblyUnbound()
-reveal_type(a())  # revealed: int
-```
-
-## Non-callable `__call__`
-
-```py
-class NonCallable:
-    __call__ = 1
-
-a = NonCallable()
-# error: "Object of type `NonCallable` is not callable"
-reveal_type(a())  # revealed: Unknown
-```
-
-## Possibly non-callable `__call__`
-
-```py
-def flag() -> bool: ...
-
-class NonCallable:
-    if flag():
-        __call__ = 1
-    else:
-        def __call__(self) -> int: ...
-
-a = NonCallable()
-# error: "Object of type `Literal[1] | Literal[__call__]` is not callable (due to union element `Literal[1]`)"
-reveal_type(a())  # revealed: Unknown | int
-```

crates/red_knot_python_semantic/resources/mdtest/call/constructor.md

@@ -1,7 +0,0 @@
-# Constructor
-
-```py
-class Foo: ...
-
-reveal_type(Foo())  # revealed: Foo
-```

crates/red_knot_python_semantic/resources/mdtest/call/function.md

@@ -1,59 +0,0 @@
-# Call expression
-
-## Simple
-
-```py
-def get_int() -> int:
-    return 42
-
-reveal_type(get_int())  # revealed: int
-```
-
-## Async
-
-```py
-async def get_int_async() -> int:
-    return 42
-
-# TODO: we don't yet support `types.CoroutineType`, should be generic `Coroutine[Any, Any, int]`
-reveal_type(get_int_async())  # revealed: @Todo
-```
-
-## Decorated
-
-```py
-from typing import Callable
-
-def foo() -> int:
-    return 42
-
-def decorator(func) -> Callable[[], int]:
-    return foo
-
-@decorator
-def bar() -> str:
-    return "bar"
-
-# TODO: should reveal `int`, as the decorator replaces `bar` with `foo`
-reveal_type(bar())  # revealed: @Todo
-```
-
-## Invalid callable
-
-```py
-nonsense = 123
-x = nonsense()  # error: "Object of type `Literal[123]` is not callable"
-```
-
-## Potentially unbound function
-
-```py
-def flag() -> bool: ...
-
-if flag():
-    def foo() -> int:
-        return 42
-
-# error: [possibly-unresolved-reference]
-reveal_type(foo())  # revealed: int
-```

crates/red_knot_python_semantic/resources/mdtest/call/union.md

@@ -1,104 +0,0 @@
-# Unions in calls
-
-## Union of return types
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-if flag:
-
-    def f() -> int:
-        return 1
-
-else:
-
-    def f() -> str:
-        return "foo"
-
-reveal_type(f())  # revealed: int | str
-```
-
-## Calling with an unknown union
-
-```py
-from nonexistent import f  # error: [unresolved-import] "Cannot resolve import `nonexistent`"
-
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-if flag:
-
-    def f() -> int:
-        return 1
-
-reveal_type(f())  # revealed: Unknown | int
-```
-
-## Non-callable elements in a union
-
-Calling a union with a non-callable element should emit a diagnostic.
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-if flag:
-    f = 1
-else:
-
-    def f() -> int:
-        return 1
-
-x = f()  # error: "Object of type `Literal[1] | Literal[f]` is not callable (due to union element `Literal[1]`)"
-reveal_type(x)  # revealed: Unknown | int
-```
-
-## Multiple non-callable elements in a union
-
-Calling a union with multiple non-callable elements should mention all of them in the diagnostic.
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-
-if flag:
-    f = 1
-elif flag2:
-    f = "foo"
-else:
-
-    def f() -> int:
-        return 1
-
-# error: "Object of type `Literal[1] | Literal["foo"] | Literal[f]` is not callable (due to union elements Literal[1], Literal["foo"])"
-# revealed: Unknown | int
-reveal_type(f())
-```
-
-## All non-callable union elements
-
-Calling a union with no callable elements can emit a simpler diagnostic.
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-
-if flag:
-    f = 1
-else:
-    f = "foo"
-
-x = f()  # error: "Object of type `Literal[1] | Literal["foo"]` is not callable"
-reveal_type(x)  # revealed: Unknown
-```

crates/red_knot_python_semantic/resources/mdtest/comparison/byte_literals.md

@@ -1,43 +0,0 @@
-# Comparison: Byte literals
-
-These tests assert that we infer precise `Literal` types for comparisons between objects inferred as
-having `Literal` bytes types:
-
-```py
-reveal_type(b"abc" == b"abc")  # revealed: Literal[True]
-reveal_type(b"abc" == b"ab")  # revealed: Literal[False]
-
-reveal_type(b"abc" != b"abc")  # revealed: Literal[False]
-reveal_type(b"abc" != b"ab")  # revealed: Literal[True]
-
-reveal_type(b"abc" < b"abd")  # revealed: Literal[True]
-reveal_type(b"abc" < b"abb")  # revealed: Literal[False]
-
-reveal_type(b"abc" <= b"abc")  # revealed: Literal[True]
-reveal_type(b"abc" <= b"abb")  # revealed: Literal[False]
-
-reveal_type(b"abc" > b"abd")  # revealed: Literal[False]
-reveal_type(b"abc" > b"abb")  # revealed: Literal[True]
-
-reveal_type(b"abc" >= b"abc")  # revealed: Literal[True]
-reveal_type(b"abc" >= b"abd")  # revealed: Literal[False]
-
-reveal_type(b"" in b"")  # revealed: Literal[True]
-reveal_type(b"" in b"abc")  # revealed: Literal[True]
-reveal_type(b"abc" in b"")  # revealed: Literal[False]
-reveal_type(b"ab" in b"abc")  # revealed: Literal[True]
-reveal_type(b"abc" in b"abc")  # revealed: Literal[True]
-reveal_type(b"d" in b"abc")  # revealed: Literal[False]
-reveal_type(b"ac" in b"abc")  # revealed: Literal[False]
-reveal_type(b"\x81\x82" in b"\x80\x81\x82")  # revealed: Literal[True]
-reveal_type(b"\x82\x83" in b"\x80\x81\x82")  # revealed: Literal[False]
-
-reveal_type(b"ab" not in b"abc")  # revealed: Literal[False]
-reveal_type(b"ac" not in b"abc")  # revealed: Literal[True]
-
-reveal_type(b"abc" is b"abc")  # revealed: bool
-reveal_type(b"abc" is b"ab")  # revealed: Literal[False]
-
-reveal_type(b"abc" is not b"abc")  # revealed: bool
-reveal_type(b"abc" is not b"ab")  # revealed: Literal[True]
-```

crates/red_knot_python_semantic/resources/mdtest/comparison/identity_tests.md

@@ -1,40 +0,0 @@
-# Identity tests
-
-```py
-class A: ...
-
-def get_a() -> A: ...
-def get_object() -> object: ...
-
-a1 = get_a()
-a2 = get_a()
-
-n1 = None
-n2 = None
-
-o = get_object()
-
-reveal_type(a1 is a1)  # revealed: bool
-reveal_type(a1 is a2)  # revealed: bool
-
-reveal_type(n1 is n1)  # revealed: Literal[True]
-reveal_type(n1 is n2)  # revealed: Literal[True]
-
-reveal_type(a1 is n1)  # revealed: Literal[False]
-reveal_type(n1 is a1)  # revealed: Literal[False]
-
-reveal_type(a1 is o)  # revealed: bool
-reveal_type(n1 is o)  # revealed: bool
-
-reveal_type(a1 is not a1)  # revealed: bool
-reveal_type(a1 is not a2)  # revealed: bool
-
-reveal_type(n1 is not n1)  # revealed: Literal[False]
-reveal_type(n1 is not n2)  # revealed: Literal[False]
-
-reveal_type(a1 is not n1)  # revealed: Literal[True]
-reveal_type(n1 is not a1)  # revealed: Literal[True]
-
-reveal_type(a1 is not o)  # revealed: bool
-reveal_type(n1 is not o)  # revealed: bool
-```

crates/red_knot_python_semantic/resources/mdtest/comparison/instances/membership_test.md

@@ -1,160 +0,0 @@
-# Comparison: Membership Test
-
-In Python, the term "membership test operators" refers to the operators `in` and `not in`. To
-customize their behavior, classes can implement one of the special methods `__contains__`,
-`__iter__`, or `__getitem__`.
-
-For references, see:
-
-- <https://docs.python.org/3/reference/expressions.html#membership-test-details>
-- <https://docs.python.org/3/reference/datamodel.html#object.__contains__>
-- <https://snarky.ca/unravelling-membership-testing/>
-
-## Implements `__contains__`
-
-Classes can support membership tests by implementing the `__contains__` method:
-
-```py
-class A:
-    def __contains__(self, item: str) -> bool:
-        return True
-
-reveal_type("hello" in A())  # revealed: bool
-reveal_type("hello" not in A())  # revealed: bool
-# TODO: should emit diagnostic, need to check arg type, will fail
-reveal_type(42 in A())  # revealed: bool
-reveal_type(42 not in A())  # revealed: bool
-```
-
-## Implements `__iter__`
-
-Classes that don't implement `__contains__`, but do implement `__iter__`, also support containment
-checks; the needle will be sought in their iterated items:
-
-```py
-class StringIterator:
-    def __next__(self) -> str:
-        return "foo"
-
-class A:
-    def __iter__(self) -> StringIterator:
-        return StringIterator()
-
-reveal_type("hello" in A())  # revealed: bool
-reveal_type("hello" not in A())  # revealed: bool
-reveal_type(42 in A())  # revealed: bool
-reveal_type(42 not in A())  # revealed: bool
-```
-
-## Implements `__getitems__`
-
-The final fallback is to implement `__getitem__` for integer keys. Python will call `__getitem__`
-with `0`, `1`, `2`... until either the needle is found (leading the membership test to evaluate to
-`True`) or `__getitem__` raises `IndexError` (the raised exception is swallowed, but results in the
-membership test evaluating to `False`).
-
-```py
-class A:
-    def __getitem__(self, key: int) -> str:
-        return "foo"
-
-reveal_type("hello" in A())  # revealed: bool
-reveal_type("hello" not in A())  # revealed: bool
-reveal_type(42 in A())  # revealed: bool
-reveal_type(42 not in A())  # revealed: bool
-```
-
-## Wrong Return Type
-
-Python coerces the results of containment checks to `bool`, even if `__contains__` returns a
-non-bool:
-
-```py
-class A:
-    def __contains__(self, item: str) -> str:
-        return "foo"
-
-reveal_type("hello" in A())  # revealed: bool
-reveal_type("hello" not in A())  # revealed: bool
-```
-
-## Literal Result for `in` and `not in`
-
-`__contains__` with a literal return type may result in a `BooleanLiteral` outcome.
-
-```py
-from typing import Literal
-
-class AlwaysTrue:
-    def __contains__(self, item: int) -> Literal[1]:
-        return 1
-
-class AlwaysFalse:
-    def __contains__(self, item: int) -> Literal[""]:
-        return ""
-
-reveal_type(42 in AlwaysTrue())  # revealed: Literal[True]
-reveal_type(42 not in AlwaysTrue())  # revealed: Literal[False]
-
-reveal_type(42 in AlwaysFalse())  # revealed: Literal[False]
-reveal_type(42 not in AlwaysFalse())  # revealed: Literal[True]
-```
-
-## No Fallback for `__contains__`
-
-If `__contains__` is implemented, checking membership of a type it doesn't accept is an error; it
-doesn't result in a fallback to `__iter__` or `__getitem__`:
-
-```py
-class CheckContains: ...
-class CheckIter: ...
-class CheckGetItem: ...
-
-class CheckIterIterator:
-    def __next__(self) -> CheckIter:
-        return CheckIter()
-
-class A:
-    def __contains__(self, item: CheckContains) -> bool:
-        return True
-
-    def __iter__(self) -> CheckIterIterator:
-        return CheckIterIterator()
-
-    def __getitem__(self, key: int) -> CheckGetItem:
-        return CheckGetItem()
-
-reveal_type(CheckContains() in A())  # revealed: bool
-
-# TODO: should emit diagnostic, need to check arg type,
-# should not fall back to __iter__ or __getitem__
-reveal_type(CheckIter() in A())  # revealed: bool
-reveal_type(CheckGetItem() in A())  # revealed: bool
-
-class B:
-    def __iter__(self) -> CheckIterIterator:
-        return CheckIterIterator()
-
-    def __getitem__(self, key: int) -> CheckGetItem:
-        return CheckGetItem()
-
-reveal_type(CheckIter() in B())  # revealed: bool
-# Always use `__iter__`, regardless of iterated type; there's no NotImplemented
-# in this case, so there's no fallback to `__getitem__`
-reveal_type(CheckGetItem() in B())  # revealed: bool
-```
-
-## Invalid Old-Style Iteration
-
-If `__getitem__` is implemented but does not accept integer arguments, then the membership test is
-not supported and should trigger a diagnostic.
-
-```py
-class A:
-    def __getitem__(self, key: str) -> str:
-        return "foo"
-
-# TODO should emit a diagnostic
-reveal_type(42 in A())  # revealed: bool
-reveal_type("hello" in A())  # revealed: bool
-```

crates/red_knot_python_semantic/resources/mdtest/comparison/instances/rich_comparison.md

@@ -1,328 +0,0 @@
-# Comparison: Rich Comparison
-
-Rich comparison operations (`==`, `!=`, `<`, `<=`, `>`, `>=`) in Python are implemented through
-double-underscore methods that allow customization of comparison behavior.
-
-For references, see:
-
-- <https://docs.python.org/3/reference/datamodel.html#object.__lt__>
-- <https://snarky.ca/unravelling-rich-comparison-operators/>
-
-## Rich Comparison Dunder Implementations For Same Class
-
-Classes can support rich comparison by implementing dunder methods like `__eq__`, `__ne__`, etc. The
-most common case involves implementing these methods for the same type:
-
-```py
-from __future__ import annotations
-
-class A:
-    def __eq__(self, other: A) -> int:
-        return 42
-
-    def __ne__(self, other: A) -> float:
-        return 42.0
-
-    def __lt__(self, other: A) -> str:
-        return "42"
-
-    def __le__(self, other: A) -> bytes:
-        return b"42"
-
-    def __gt__(self, other: A) -> list:
-        return [42]
-
-    def __ge__(self, other: A) -> set:
-        return {42}
-
-reveal_type(A() == A())  # revealed: int
-reveal_type(A() != A())  # revealed: float
-reveal_type(A() < A())  # revealed: str
-reveal_type(A() <= A())  # revealed: bytes
-reveal_type(A() > A())  # revealed: list
-reveal_type(A() >= A())  # revealed: set
-```
-
-## Rich Comparison Dunder Implementations for Other Class
-
-In some cases, classes may implement rich comparison dunder methods for comparisons with a different
-type:
-
-```py
-from __future__ import annotations
-
-class A:
-    def __eq__(self, other: B) -> int:
-        return 42
-
-    def __ne__(self, other: B) -> float:
-        return 42.0
-
-    def __lt__(self, other: B) -> str:
-        return "42"
-
-    def __le__(self, other: B) -> bytes:
-        return b"42"
-
-    def __gt__(self, other: B) -> list:
-        return [42]
-
-    def __ge__(self, other: B) -> set:
-        return {42}
-
-class B: ...
-
-reveal_type(A() == B())  # revealed: int
-reveal_type(A() != B())  # revealed: float
-reveal_type(A() < B())  # revealed: str
-reveal_type(A() <= B())  # revealed: bytes
-reveal_type(A() > B())  # revealed: list
-reveal_type(A() >= B())  # revealed: set
-```
-
-## Reflected Comparisons
-
-Fallback to the right-hand side’s comparison methods occurs when the left-hand side does not define
-them. Note: class `B` has its own `__eq__` and `__ne__` methods to override those of `object`, but
-these methods will be ignored here because they require a mismatched operand type.
-
-```py
-from __future__ import annotations
-
-class A:
-    def __eq__(self, other: B) -> int:
-        return 42
-
-    def __ne__(self, other: B) -> float:
-        return 42.0
-
-    def __lt__(self, other: B) -> str:
-        return "42"
-
-    def __le__(self, other: B) -> bytes:
-        return b"42"
-
-    def __gt__(self, other: B) -> list:
-        return [42]
-
-    def __ge__(self, other: B) -> set:
-        return {42}
-
-class B:
-    # To override builtins.object.__eq__ and builtins.object.__ne__
-    # TODO these should emit an invalid override diagnostic
-    def __eq__(self, other: str) -> B:
-        return B()
-
-    def __ne__(self, other: str) -> B:
-        return B()
-
-# TODO: should be `int` and `float`.
-# Need to check arg type and fall back to `rhs.__eq__` and `rhs.__ne__`.
-#
-# Because `object.__eq__` and `object.__ne__` accept `object` in typeshed,
-# this can only happen with an invalid override of these methods,
-# but we still support it.
-reveal_type(B() == A())  # revealed: B
-reveal_type(B() != A())  # revealed: B
-
-reveal_type(B() < A())  # revealed: list
-reveal_type(B() <= A())  # revealed: set
-
-reveal_type(B() > A())  # revealed: str
-reveal_type(B() >= A())  # revealed: bytes
-
-class C:
-    def __gt__(self, other: C) -> int:
-        return 42
-
-    def __ge__(self, other: C) -> float:
-        return 42.0
-
-reveal_type(C() < C())  # revealed: int
-reveal_type(C() <= C())  # revealed: float
-```
-
-## Reflected Comparisons with Subclasses
-
-When subclasses override comparison methods, these overridden methods take precedence over those in
-the parent class. Class `B` inherits from `A` and redefines comparison methods to return types other
-than `A`.
-
-```py
-from __future__ import annotations
-
-class A:
-    def __eq__(self, other: A) -> A:
-        return A()
-
-    def __ne__(self, other: A) -> A:
-        return A()
-
-    def __lt__(self, other: A) -> A:
-        return A()
-
-    def __le__(self, other: A) -> A:
-        return A()
-
-    def __gt__(self, other: A) -> A:
-        return A()
-
-    def __ge__(self, other: A) -> A:
-        return A()
-
-class B(A):
-    def __eq__(self, other: A) -> int:
-        return 42
-
-    def __ne__(self, other: A) -> float:
-        return 42.0
-
-    def __lt__(self, other: A) -> str:
-        return "42"
-
-    def __le__(self, other: A) -> bytes:
-        return b"42"
-
-    def __gt__(self, other: A) -> list:
-        return [42]
-
-    def __ge__(self, other: A) -> set:
-        return {42}
-
-reveal_type(A() == B())  # revealed: int
-reveal_type(A() != B())  # revealed: float
-
-reveal_type(A() < B())  # revealed: list
-reveal_type(A() <= B())  # revealed: set
-
-reveal_type(A() > B())  # revealed: str
-reveal_type(A() >= B())  # revealed: bytes
-```
-
-## Reflected Comparisons with Subclass But Falls Back to LHS
-
-In the case of a subclass, the right-hand side has priority. However, if the overridden dunder
-method has an mismatched type to operand, the comparison will fall back to the left-hand side.
-
-```py
-from __future__ import annotations
-
-class A:
-    def __lt__(self, other: A) -> A:
-        return A()
-
-    def __gt__(self, other: A) -> A:
-        return A()
-
-class B(A):
-    def __lt__(self, other: int) -> B:
-        return B()
-
-    def __gt__(self, other: int) -> B:
-        return B()
-
-# TODO: should be `A`, need to check argument type and fall back to LHS method
-reveal_type(A() < B())  # revealed: B
-reveal_type(A() > B())  # revealed: B
-```
-
-## Operations involving instances of classes inheriting from `Any`
-
-`Any` and `Unknown` represent a set of possible runtime objects, wherein the bounds of the set are
-unknown. Whether the left-hand operand's dunder or the right-hand operand's reflected dunder depends
-on whether the right-hand operand is an instance of a class that is a subclass of the left-hand
-operand's class and overrides the reflected dunder. In the following example, because of the
-unknowable nature of `Any`/`Unknown`, we must consider both possibilities: `Any`/`Unknown` might
-resolve to an unknown third class that inherits from `X` and overrides `__gt__`; but it also might
-not. Thus, the correct answer here for the `reveal_type` is `int | Unknown`.
-
-(This test is referenced from `mdtest/binary/instances.md`)
-
-```py
-from does_not_exist import Foo  # error: [unresolved-import]
-
-reveal_type(Foo)  # revealed: Unknown
-
-class X:
-    def __lt__(self, other: object) -> int:
-        return 42
-
-class Y(Foo): ...
-
-# TODO: Should be `int | Unknown`; see above discussion.
-reveal_type(X() < Y())  # revealed: int
-```
-
-## Equality and Inequality Fallback
-
-This test confirms that `==` and `!=` comparisons default to identity comparisons (`is`, `is not`)
-when argument types do not match the method signature.
-
-Please refer to the [docs](https://docs.python.org/3/reference/datamodel.html#object.__eq__)
-
-```py
-from __future__ import annotations
-
-class A:
-    # TODO both these overrides should emit invalid-override diagnostic
-    def __eq__(self, other: int) -> A:
-        return A()
-
-    def __ne__(self, other: int) -> A:
-        return A()
-
-# TODO: it should be `bool`, need to check arg type and fall back to `is` and `is not`
-reveal_type(A() == A())  # revealed: A
-reveal_type(A() != A())  # revealed: A
-```
-
-## Object Comparisons with Typeshed
-
-```py
-class A: ...
-
-reveal_type(A() == object())  # revealed: bool
-reveal_type(A() != object())  # revealed: bool
-reveal_type(object() == A())  # revealed: bool
-reveal_type(object() != A())  # revealed: bool
-
-# error: [unsupported-operator] "Operator `<` is not supported for types `A` and `object`"
-# revealed: Unknown
-reveal_type(A() < object())
-```
-
-## Numbers Comparison with typeshed
-
-```py
-reveal_type(1 == 1.0)  # revealed: bool
-reveal_type(1 != 1.0)  # revealed: bool
-reveal_type(1 < 1.0)  # revealed: bool
-reveal_type(1 <= 1.0)  # revealed: bool
-reveal_type(1 > 1.0)  # revealed: bool
-reveal_type(1 >= 1.0)  # revealed: bool
-
-reveal_type(1 == 2j)  # revealed: bool
-reveal_type(1 != 2j)  # revealed: bool
-
-# TODO: should be Unknown and emit diagnostic,
-# need to check arg type and should be failed
-reveal_type(1 < 2j)  # revealed: bool
-reveal_type(1 <= 2j)  # revealed: bool
-reveal_type(1 > 2j)  # revealed: bool
-reveal_type(1 >= 2j)  # revealed: bool
-
-def bool_instance() -> bool:
-    return True
-
-def int_instance() -> int:
-    return 42
-
-x = bool_instance()
-y = int_instance()
-
-reveal_type(x < y)  # revealed: bool
-reveal_type(y < x)  # revealed: bool
-reveal_type(4.2 < x)  # revealed: bool
-reveal_type(x < 4.2)  # revealed: bool
-```

crates/red_knot_python_semantic/resources/mdtest/comparison/integers.md

@@ -1,29 +0,0 @@
-# Comparison: Integers
-
-## Integer literals
-
-```py
-reveal_type(1 == 1 == True)  # revealed: Literal[True]
-reveal_type(1 == 1 == 2 == 4)  # revealed: Literal[False]
-reveal_type(False < True <= 2 < 3 != 6)  # revealed: Literal[True]
-reveal_type(1 < 1)  # revealed: Literal[False]
-reveal_type(1 > 1)  # revealed: Literal[False]
-reveal_type(1 is 1)  # revealed: bool
-reveal_type(1 is not 1)  # revealed: bool
-reveal_type(1 is 2)  # revealed: Literal[False]
-reveal_type(1 is not 7)  # revealed: Literal[True]
-# TODO: should be Unknown, and emit diagnostic, once we check call argument types
-reveal_type(1 <= "" and 0 < 1)  # revealed: bool
-```
-
-## Integer instance
-
-```py
-# TODO: implement lookup of `__eq__` on typeshed `int` stub.
-def int_instance() -> int:
-    return 42
-
-reveal_type(1 == int_instance())  # revealed: bool
-reveal_type(9 < int_instance())  # revealed: bool
-reveal_type(int_instance() < int_instance())  # revealed: bool
-```

crates/red_knot_python_semantic/resources/mdtest/comparison/intersections.md

@@ -1,155 +0,0 @@
-# Comparison: Intersections
-
-## Positive contributions
-
-If we have an intersection type `A & B` and we get a definitive true/false answer for one of the
-types, we can infer that the result for the intersection type is also true/false:
-
-```py
-class Base: ...
-
-class Child1(Base):
-    def __eq__(self, other) -> Literal[True]:
-        return True
-
-class Child2(Base): ...
-
-def get_base() -> Base: ...
-
-x = get_base()
-c1 = Child1()
-
-# Create an intersection type through narrowing:
-if isinstance(x, Child1):
-    if isinstance(x, Child2):
-        reveal_type(x)  # revealed: Child1 & Child2
-
-        reveal_type(x == 1)  # revealed: Literal[True]
-
-        # Other comparison operators fall back to the base type:
-        reveal_type(x > 1)  # revealed: bool
-        reveal_type(x is c1)  # revealed: bool
-```
-
-## Negative contributions
-
-Negative contributions to the intersection type only allow simplifications in a few special cases
-(equality and identity comparisons).
-
-### Equality comparisons
-
-#### Literal strings
-
-```py
-x = "x" * 1_000_000_000
-y = "y" * 1_000_000_000
-reveal_type(x)  # revealed: LiteralString
-
-if x != "abc":
-    reveal_type(x)  # revealed: LiteralString & ~Literal["abc"]
-
-    reveal_type(x == "abc")  # revealed: Literal[False]
-    reveal_type("abc" == x)  # revealed: Literal[False]
-    reveal_type(x == "something else")  # revealed: bool
-    reveal_type("something else" == x)  # revealed: bool
-
-    reveal_type(x != "abc")  # revealed: Literal[True]
-    reveal_type("abc" != x)  # revealed: Literal[True]
-    reveal_type(x != "something else")  # revealed: bool
-    reveal_type("something else" != x)  # revealed: bool
-
-    reveal_type(x == y)  # revealed: bool
-    reveal_type(y == x)  # revealed: bool
-    reveal_type(x != y)  # revealed: bool
-    reveal_type(y != x)  # revealed: bool
-
-    reveal_type(x >= "abc")  # revealed: bool
-    reveal_type("abc" >= x)  # revealed: bool
-
-    reveal_type(x in "abc")  # revealed: bool
-    reveal_type("abc" in x)  # revealed: bool
-```
-
-#### Integers
-
-```py
-def get_int() -> int: ...
-
-x = get_int()
-
-if x != 1:
-    reveal_type(x)  # revealed: int & ~Literal[1]
-
-    reveal_type(x != 1)  # revealed: Literal[True]
-    reveal_type(x != 2)  # revealed: bool
-
-    reveal_type(x == 1)  # revealed: Literal[False]
-    reveal_type(x == 2)  # revealed: bool
-```
-
-### Identity comparisons
-
-```py
-class A: ...
-
-def get_object() -> object: ...
-
-o = object()
-
-a = A()
-n = None
-
-if o is not None:
-    reveal_type(o)  # revealed: object & ~None
-
-    reveal_type(o is n)  # revealed: Literal[False]
-    reveal_type(o is not n)  # revealed: Literal[True]
-```
-
-## Diagnostics
-
-### Unsupported operators for positive contributions
-
-Raise an error if any of the positive contributions to the intersection type are unsupported for the
-given operator:
-
-```py
-class Container:
-    def __contains__(self, x) -> bool: ...
-
-class NonContainer: ...
-
-def get_object() -> object: ...
-
-x = get_object()
-
-if isinstance(x, Container):
-    if isinstance(x, NonContainer):
-        reveal_type(x)  # revealed: Container & NonContainer
-
-        # error: [unsupported-operator] "Operator `in` is not supported for types `int` and `NonContainer`"
-        reveal_type(2 in x)  # revealed: bool
-```
-
-### Unsupported operators for negative contributions
-
-Do *not* raise an error if any of the negative contributions to the intersection type are
-unsupported for the given operator:
-
-```py
-class Container:
-    def __contains__(self, x) -> bool: ...
-
-class NonContainer: ...
-
-def get_object() -> object: ...
-
-x = get_object()
-
-if isinstance(x, Container):
-    if not isinstance(x, NonContainer):
-        reveal_type(x)  # revealed: Container & ~NonContainer
-
-        # No error here!
-        reveal_type(2 in x)  # revealed: bool
-```

crates/red_knot_python_semantic/resources/mdtest/comparison/non_boolean_returns.md

@@ -1,41 +0,0 @@
-# Comparison: Non boolean returns
-
-Walking through examples:
-
-- `a = A() < B() < C()`
-
-    1. `A() < B() and B() < C()` - split in N comparison
-    1. `A()` and `B()` - evaluate outcome types
-    1. `bool` and `bool` - evaluate truthiness
-    1. `A | B` - union of "first true" types
-
-- `b = 0 < 1 < A() < 3`
-
-    1. `0 < 1 and 1 < A() and A() < 3` - split in N comparison
-    1. `True` and `bool` and `A` - evaluate outcome types
-    1. `True` and `bool` and `bool` - evaluate truthiness
-    1. `bool | A` - union of "true" types
-
-- `c = 10 < 0 < A() < B() < C()` short-circuit to False
-
-```py
-from __future__ import annotations
-
-class A:
-    def __lt__(self, other) -> A: ...
-
-class B:
-    def __lt__(self, other) -> B: ...
-
-class C:
-    def __lt__(self, other) -> C: ...
-
-x = A() < B() < C()
-reveal_type(x)  # revealed: A | B
-
-y = 0 < 1 < A() < 3
-reveal_type(y)  # revealed: bool | A
-
-z = 10 < 0 < A() < B() < C()
-reveal_type(z)  # revealed: Literal[False]
-```

crates/red_knot_python_semantic/resources/mdtest/comparison/strings.md

@@ -1,20 +0,0 @@
-# Comparison: Strings
-
-## String literals
-
-```py
-def str_instance() -> str: ...
-
-reveal_type("abc" == "abc")  # revealed: Literal[True]
-reveal_type("ab_cd" <= "ab_ce")  # revealed: Literal[True]
-reveal_type("abc" in "ab cd")  # revealed: Literal[False]
-reveal_type("" not in "hello")  # revealed: Literal[False]
-reveal_type("--" is "--")  # revealed: bool
-reveal_type("A" is "B")  # revealed: Literal[False]
-reveal_type("--" is not "--")  # revealed: bool
-reveal_type("A" is not "B")  # revealed: Literal[True]
-reveal_type(str_instance() < "...")  # revealed: bool
-
-# ensure we're not comparing the interned salsa symbols, which compare by order of declaration.
-reveal_type("ab" < "ab_cd")  # revealed: Literal[True]
-```

crates/red_knot_python_semantic/resources/mdtest/comparison/tuples.md

@@ -1,204 +0,0 @@
-# Comparison: Tuples
-
-## Heterogeneous
-
-For tuples like `tuple[int, str, Literal[1]]`
-
-### Value Comparisons
-
-"Value Comparisons" refers to the operators: `==`, `!=`, `<`, `<=`, `>`, `>=`
-
-#### Results without Ambiguity
-
-Cases where the result can be definitively inferred as a `BooleanLiteral`.
-
-```py
-a = (1, "test", (3, 13), True)
-b = (1, "test", (3, 14), False)
-
-reveal_type(a == a)  # revealed: Literal[True]
-reveal_type(a != a)  # revealed: Literal[False]
-reveal_type(a < a)  # revealed: Literal[False]
-reveal_type(a <= a)  # revealed: Literal[True]
-reveal_type(a > a)  # revealed: Literal[False]
-reveal_type(a >= a)  # revealed: Literal[True]
-
-reveal_type(a == b)  # revealed: Literal[False]
-reveal_type(a != b)  # revealed: Literal[True]
-reveal_type(a < b)  # revealed: Literal[True]
-reveal_type(a <= b)  # revealed: Literal[True]
-reveal_type(a > b)  # revealed: Literal[False]
-reveal_type(a >= b)  # revealed: Literal[False]
-```
-
-Even when tuples have different lengths, comparisons should be handled appropriately.
-
-```py path=different_length.py
-a = (1, 2, 3)
-b = (1, 2, 3, 4)
-
-reveal_type(a == b)  # revealed: Literal[False]
-reveal_type(a != b)  # revealed: Literal[True]
-reveal_type(a < b)  # revealed: Literal[True]
-reveal_type(a <= b)  # revealed: Literal[True]
-reveal_type(a > b)  # revealed: Literal[False]
-reveal_type(a >= b)  # revealed: Literal[False]
-
-c = ("a", "b", "c", "d")
-d = ("a", "b", "c")
-
-reveal_type(c == d)  # revealed: Literal[False]
-reveal_type(c != d)  # revealed: Literal[True]
-reveal_type(c < d)  # revealed: Literal[False]
-reveal_type(c <= d)  # revealed: Literal[False]
-reveal_type(c > d)  # revealed: Literal[True]
-reveal_type(c >= d)  # revealed: Literal[True]
-```
-
-#### Results with Ambiguity
-
-```py
-def bool_instance() -> bool: ...
-def int_instance() -> int:
-    return 42
-
-a = (bool_instance(),)
-b = (int_instance(),)
-
-reveal_type(a == a)  # revealed: bool
-reveal_type(a != a)  # revealed: bool
-reveal_type(a < a)  # revealed: bool
-reveal_type(a <= a)  # revealed: bool
-reveal_type(a > a)  # revealed: bool
-reveal_type(a >= a)  # revealed: bool
-
-reveal_type(a == b)  # revealed: bool
-reveal_type(a != b)  # revealed: bool
-reveal_type(a < b)  # revealed: bool
-reveal_type(a <= b)  # revealed: bool
-reveal_type(a > b)  # revealed: bool
-reveal_type(a >= b)  # revealed: bool
-```
-
-#### Comparison Unsupported
-
-If two tuples contain types that do not support comparison, the result may be `Unknown`. However,
-`==` and `!=` are exceptions and can still provide definite results.
-
-```py
-a = (1, 2)
-b = (1, "hello")
-
-# TODO: should be Literal[False], once we implement (in)equality for mismatched literals
-reveal_type(a == b)  # revealed: bool
-
-# TODO: should be Literal[True], once we implement (in)equality for mismatched literals
-reveal_type(a != b)  # revealed: bool
-
-# TODO: should be Unknown and add more informative diagnostics
-reveal_type(a < b)  # revealed: bool
-reveal_type(a <= b)  # revealed: bool
-reveal_type(a > b)  # revealed: bool
-reveal_type(a >= b)  # revealed: bool
-```
-
-However, if the lexicographic comparison completes without reaching a point where str and int are
-compared, Python will still produce a result based on the prior elements.
-
-```py path=short_circuit.py
-a = (1, 2)
-b = (999999, "hello")
-
-reveal_type(a == b)  # revealed: Literal[False]
-reveal_type(a != b)  # revealed: Literal[True]
-reveal_type(a < b)  # revealed: Literal[True]
-reveal_type(a <= b)  # revealed: Literal[True]
-reveal_type(a > b)  # revealed: Literal[False]
-reveal_type(a >= b)  # revealed: Literal[False]
-```
-
-#### Matryoshka Tuples
-
-```py
-a = (1, True, "Hello")
-b = (a, a, a)
-c = (b, b, b)
-
-reveal_type(c == c)  # revealed: Literal[True]
-reveal_type(c != c)  # revealed: Literal[False]
-reveal_type(c < c)  # revealed: Literal[False]
-reveal_type(c <= c)  # revealed: Literal[True]
-reveal_type(c > c)  # revealed: Literal[False]
-reveal_type(c >= c)  # revealed: Literal[True]
-```
-
-#### Non Boolean Rich Comparisons
-
-```py
-class A:
-    def __eq__(self, o) -> str: ...
-    def __ne__(self, o) -> int: ...
-    def __lt__(self, o) -> float: ...
-    def __le__(self, o) -> object: ...
-    def __gt__(self, o) -> tuple: ...
-    def __ge__(self, o) -> list: ...
-
-a = (A(), A())
-
-reveal_type(a == a)  # revealed: bool
-reveal_type(a != a)  # revealed: bool
-reveal_type(a < a)  # revealed: bool
-reveal_type(a <= a)  # revealed: bool
-reveal_type(a > a)  # revealed: bool
-reveal_type(a >= a)  # revealed: bool
-```
-
-### Membership Test Comparisons
-
-"Membership Test Comparisons" refers to the operators `in` and `not in`.
-
-```py
-def int_instance() -> int:
-    return 42
-
-a = (1, 2)
-b = ((3, 4), (1, 2))
-c = ((1, 2, 3), (4, 5, 6))
-d = ((int_instance(), int_instance()), (int_instance(), int_instance()))
-
-reveal_type(a in b)  # revealed: Literal[True]
-reveal_type(a not in b)  # revealed: Literal[False]
-
-reveal_type(a in c)  # revealed: Literal[False]
-reveal_type(a not in c)  # revealed: Literal[True]
-
-reveal_type(a in d)  # revealed: bool
-reveal_type(a not in d)  # revealed: bool
-```
-
-### Identity Comparisons
-
-"Identity Comparisons" refers to `is` and `is not`.
-
-```py
-a = (1, 2)
-b = ("a", "b")
-c = (1, 2, 3)
-
-reveal_type(a is (1, 2))  # revealed: bool
-reveal_type(a is not (1, 2))  # revealed: bool
-
-# TODO should be Literal[False] once we implement comparison of mismatched literal types
-reveal_type(a is b)  # revealed: bool
-# TODO should be Literal[True] once we implement comparison of mismatched literal types
-reveal_type(a is not b)  # revealed: bool
-
-reveal_type(a is c)  # revealed: Literal[False]
-reveal_type(a is not c)  # revealed: Literal[True]
-```
-
-## Homogeneous
-
-For tuples like `tuple[int, ...]`, `tuple[Any, ...]`
-
-// TODO

crates/red_knot_python_semantic/resources/mdtest/comparison/unions.md

@@ -1,88 +0,0 @@
-# Comparison: Unions
-
-## Union on one side of the comparison
-
-Comparisons on union types need to consider all possible cases:
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-one_or_two = 1 if flag else 2
-
-reveal_type(one_or_two <= 2)  # revealed: Literal[True]
-reveal_type(one_or_two <= 1)  # revealed: bool
-reveal_type(one_or_two <= 0)  # revealed: Literal[False]
-
-reveal_type(2 >= one_or_two)  # revealed: Literal[True]
-reveal_type(1 >= one_or_two)  # revealed: bool
-reveal_type(0 >= one_or_two)  # revealed: Literal[False]
-
-reveal_type(one_or_two < 1)  # revealed: Literal[False]
-reveal_type(one_or_two < 2)  # revealed: bool
-reveal_type(one_or_two < 3)  # revealed: Literal[True]
-
-reveal_type(one_or_two > 0)  # revealed: Literal[True]
-reveal_type(one_or_two > 1)  # revealed: bool
-reveal_type(one_or_two > 2)  # revealed: Literal[False]
-
-reveal_type(one_or_two == 3)  # revealed: Literal[False]
-reveal_type(one_or_two == 1)  # revealed: bool
-
-reveal_type(one_or_two != 3)  # revealed: Literal[True]
-reveal_type(one_or_two != 1)  # revealed: bool
-
-a_or_ab = "a" if flag else "ab"
-
-reveal_type(a_or_ab in "ab")  # revealed: Literal[True]
-reveal_type("a" in a_or_ab)  # revealed: Literal[True]
-
-reveal_type("c" not in a_or_ab)  # revealed: Literal[True]
-reveal_type("a" not in a_or_ab)  # revealed: Literal[False]
-
-reveal_type("b" in a_or_ab)  # revealed: bool
-reveal_type("b" not in a_or_ab)  # revealed: bool
-
-one_or_none = 1 if flag else None
-
-reveal_type(one_or_none is None)  # revealed: bool
-reveal_type(one_or_none is not None)  # revealed: bool
-```
-
-## Union on both sides of the comparison
-
-With unions on both sides, we need to consider the full cross product of options when building the
-resulting (union) type:
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag_s, flag_l = bool_instance(), bool_instance()
-small = 1 if flag_s else 2
-large = 2 if flag_l else 3
-
-reveal_type(small <= large)  # revealed: Literal[True]
-reveal_type(small >= large)  # revealed: bool
-
-reveal_type(small < large)  # revealed: bool
-reveal_type(small > large)  # revealed: Literal[False]
-```
-
-## Unsupported operations
-
-Make sure we emit a diagnostic if *any* of the possible comparisons is unsupported. For now, we fall
-back to `bool` for the result type instead of trying to infer something more precise from the other
-(supported) variants:
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-x = [1, 2] if flag else 1
-
-result = 1 in x  # error: "Operator `in` is not supported"
-reveal_type(result)  # revealed: bool
-```

crates/red_knot_python_semantic/resources/mdtest/comparison/unsupported.md

@@ -1,36 +0,0 @@
-# Comparison: Unsupported operators
-
-```py
-def bool_instance() -> bool:
-    return True
-
-a = 1 in 7  # error: "Operator `in` is not supported for types `Literal[1]` and `Literal[7]`"
-reveal_type(a)  # revealed: bool
-
-b = 0 not in 10  # error: "Operator `not in` is not supported for types `Literal[0]` and `Literal[10]`"
-reveal_type(b)  # revealed: bool
-
-# TODO: should error, once operand type check is implemented
-# ("Operator `<` is not supported for types `object` and `int`")
-c = object() < 5
-# TODO: should be Unknown, once operand type check is implemented
-reveal_type(c)  # revealed: bool
-
-# TODO: should error, once operand type check is implemented
-# ("Operator `<` is not supported for types `int` and `object`")
-d = 5 < object()
-# TODO: should be Unknown, once operand type check is implemented
-reveal_type(d)  # revealed: bool
-
-flag = bool_instance()
-int_literal_or_str_literal = 1 if flag else "foo"
-# error: "Operator `in` is not supported for types `Literal[42]` and `Literal[1]`, in comparing `Literal[42]` with `Literal[1] | Literal["foo"]`"
-e = 42 in int_literal_or_str_literal
-reveal_type(e)  # revealed: bool
-
-# TODO: should error, need to check if __lt__ signature is valid for right operand
-# error may be "Operator `<` is not supported for types `int` and `str`, in comparing `tuple[Literal[1], Literal[2]]` with `tuple[Literal[1], Literal["hello"]]`
-f = (1, 2) < (1, "hello")
-# TODO: should be Unknown, once operand type check is implemented
-reveal_type(f)  # revealed: bool
-```

crates/red_knot_python_semantic/resources/mdtest/conditional/if_expression.md

@@ -1,49 +0,0 @@
-# If expressions
-
-## Simple if-expression
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-x = 1 if flag else 2
-reveal_type(x)  # revealed: Literal[1, 2]
-```
-
-## If-expression with walrus operator
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-y = 0
-z = 0
-x = (y := 1) if flag else (z := 2)
-reveal_type(x)  # revealed: Literal[1, 2]
-reveal_type(y)  # revealed: Literal[0, 1]
-reveal_type(z)  # revealed: Literal[0, 2]
-```
-
-## Nested if-expression
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-x = 1 if flag else 2 if flag2 else 3
-reveal_type(x)  # revealed: Literal[1, 2, 3]
-```
-
-## None
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-x = 1 if flag else None
-reveal_type(x)  # revealed: Literal[1] | None
-```

crates/red_knot_python_semantic/resources/mdtest/conditional/if_statement.md

@@ -1,130 +0,0 @@
-# If statements
-
-## Simple if
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-y = 1
-y = 2
-
-if flag:
-    y = 3
-
-reveal_type(y)  # revealed: Literal[2, 3]
-```
-
-## Simple if-elif-else
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-y = 1
-y = 2
-if flag:
-    y = 3
-elif flag2:
-    y = 4
-else:
-    r = y
-    y = 5
-    s = y
-x = y
-
-reveal_type(x)  # revealed: Literal[3, 4, 5]
-
-# revealed: Literal[2]
-# error: [possibly-unresolved-reference]
-reveal_type(r)
-
-# revealed: Literal[5]
-# error: [possibly-unresolved-reference]
-reveal_type(s)
-```
-
-## Single symbol across if-elif-else
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-
-if flag:
-    y = 1
-elif flag2:
-    y = 2
-else:
-    y = 3
-reveal_type(y)  # revealed: Literal[1, 2, 3]
-```
-
-## if-elif-else without else assignment
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-y = 0
-if flag:
-    y = 1
-elif flag2:
-    y = 2
-else:
-    pass
-reveal_type(y)  # revealed: Literal[0, 1, 2]
-```
-
-## if-elif-else with intervening assignment
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-y = 0
-if flag:
-    y = 1
-    z = 3
-elif flag2:
-    y = 2
-else:
-    pass
-reveal_type(y)  # revealed: Literal[0, 1, 2]
-```
-
-## Nested if statement
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-y = 0
-if flag:
-    if flag2:
-        y = 1
-reveal_type(y)  # revealed: Literal[0, 1]
-```
-
-## if-elif without else
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag, flag2 = bool_instance(), bool_instance()
-y = 1
-y = 2
-if flag:
-    y = 3
-elif flag2:
-    y = 4
-
-reveal_type(y)  # revealed: Literal[2, 3, 4]
-```

crates/red_knot_python_semantic/resources/mdtest/conditional/match.md

@@ -1,41 +0,0 @@
-# Pattern matching
-
-## With wildcard
-
-```py
-match 0:
-    case 1:
-        y = 2
-    case _:
-        y = 3
-
-reveal_type(y)  # revealed: Literal[2, 3]
-```
-
-## Without wildcard
-
-```py
-match 0:
-    case 1:
-        y = 2
-    case 2:
-        y = 3
-
-# revealed: Literal[2, 3]
-# error: [possibly-unresolved-reference]
-reveal_type(y)
-```
-
-## Basic match
-
-```py
-y = 1
-y = 2
-match 0:
-    case 1:
-        y = 3
-    case 2:
-        y = 4
-
-reveal_type(y)  # revealed: Literal[2, 3, 4]
-```

crates/red_knot_python_semantic/resources/mdtest/declaration/error.md

@@ -1,51 +0,0 @@
-# Errors while declaring
-
-## Violates previous assignment
-
-```py
-x = 1
-x: str  # error: [invalid-declaration] "Cannot declare type `str` for inferred type `Literal[1]`"
-```
-
-## Incompatible declarations
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-if flag:
-    x: str
-else:
-    x: int
-x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: str, int"
-```
-
-## Partial declarations
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-if flag:
-    x: int
-x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: Unknown, int"
-```
-
-## Incompatible declarations with bad assignment
-
-```py
-def bool_instance() -> bool:
-    return True
-
-flag = bool_instance()
-if flag:
-    x: str
-else:
-    x: int
-
-# error: [conflicting-declarations]
-# error: [invalid-assignment]
-x = b"foo"
-```

crates/red_knot_python_semantic/resources/mdtest/exception/basic.md

@@ -1,61 +0,0 @@
-# Exception Handling
-
-## Single Exception
-
-```py
-import re
-
-try:
-    help()
-except NameError as e:
-    reveal_type(e)  # revealed: NameError
-except re.error as f:
-    reveal_type(f)  # revealed: error
-```
-
-## Unknown type in except handler does not cause spurious diagnostic
-
-```py
-from nonexistent_module import foo  # error: [unresolved-import]
-
-try:
-    help()
-except foo as e:
-    reveal_type(foo)  # revealed: Unknown
-    reveal_type(e)  # revealed: Unknown
-```
-
-## Multiple Exceptions in a Tuple
-
-```py
-EXCEPTIONS = (AttributeError, TypeError)
-
-try:
-    help()
-except (RuntimeError, OSError) as e:
-    reveal_type(e)  # revealed: RuntimeError | OSError
-except EXCEPTIONS as f:
-    reveal_type(f)  # revealed: AttributeError | TypeError
-```
-
-## Dynamic exception types
-
-```py
-# TODO: we should not emit these `call-possibly-unbound-method` errors for `tuple.__class_getitem__`
-def foo(
-    x: type[AttributeError],
-    y: tuple[type[OSError], type[RuntimeError]],  # error: [call-possibly-unbound-method]
-    z: tuple[type[BaseException], ...],  # error: [call-possibly-unbound-method]
-):
-    try:
-        help()
-    except x as e:
-        # TODO: should be `AttributeError`
-        reveal_type(e)  # revealed: @Todo
-    except y as f:
-        # TODO: should be `OSError | RuntimeError`
-        reveal_type(f)  # revealed: @Todo
-    except z as g:
-        # TODO: should be `BaseException`
-        reveal_type(g)  # revealed: @Todo
-```

crates/red_knot_python_semantic/resources/mdtest/exception/control_flow.md

@@ -1,622 +0,0 @@
-# Control flow for exception handlers
-
-These tests assert that we understand the possible "definition states" (which symbols might or might
-not be defined) in the various branches of a `try`/`except`/`else`/`finally` block.
-
-For a full writeup on the semantics of exception handlers, see [this document][1].
-
-The tests throughout this Markdown document use functions with names starting with `could_raise_*`
-to mark definitions that might or might not succeed (as the function could raise an exception). A
-type checker must assume that any arbitrary function call could raise an exception in Python; this
-is just a naming convention used in these tests for clarity, and to future-proof the tests against
-possible future improvements whereby certain statements or expressions could potentially be inferred
-as being incapable of causing an exception to be raised.
-
-## A single bare `except`
-
-Consider the following `try`/`except` block, with a single bare `except:`. There are different types
-for the variable `x` in the two branches of this block, and we can't determine which branch might
-have been taken from the perspective of code following this block. The inferred type after the
-block's conclusion is therefore the union of the type at the end of the `try` suite (`str`) and the
-type at the end of the `except` suite (`Literal[2]`).
-
-*Within* the `except` suite, we must infer a union of all possible "definition states" we could have
-been in at any point during the `try` suite. This is because control flow could have jumped to the
-`except` suite without any of the `try`-suite definitions successfully completing, with only *some*
-of the `try`-suite definitions successfully completing, or indeed with *all* of them successfully
-completing. The type of `x` at the beginning of the `except` suite in this example is therefore
-`Literal[1] | str`, taking into account that we might have jumped to the `except` suite before the
-`x = could_raise_returns_str()` redefinition, but we *also* could have jumped to the `except` suite
-*after* that redefinition.
-
-```py path=union_type_inferred.py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-
-reveal_type(x)  # revealed: str | Literal[2]
-```
-
-If `x` has the same type at the end of both branches, however, the branches unify and `x` is not
-inferred as having a union type following the `try`/`except` block:
-
-```py path=branches_unify_to_non_union_type.py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-x = 1
-
-try:
-    x = could_raise_returns_str()
-except:
-    x = could_raise_returns_str()
-
-reveal_type(x)  # revealed: str
-```
-
-## A non-bare `except`
-
-For simple `try`/`except` blocks, an `except TypeError:` handler has the same control flow semantics
-as an `except:` handler. An `except TypeError:` handler will not catch *all* exceptions: if this is
-the only handler, it opens up the possibility that an exception might occur that would not be
-handled. However, as described in [the document on exception-handling semantics][1], that would lead
-to termination of the scope. It's therefore irrelevant to consider this possibility when it comes to
-control-flow analysis.
-
-```py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-
-reveal_type(x)  # revealed: str | Literal[2]
-```
-
-## Multiple `except` branches
-
-If the scope reaches the final `reveal_type` call in this example, either the `try`-block suite of
-statements was executed in its entirety, or exactly one `except` suite was executed in its entirety.
-The inferred type of `x` at this point is the union of the types at the end of the three suites:
-
-- At the end of `try`, `type(x) == str`
-- At the end of `except TypeError`, `x == 2`
-- At the end of `except ValueError`, `x == 3`
-
-```py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-except ValueError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 3
-    reveal_type(x)  # revealed: Literal[3]
-
-reveal_type(x)  # revealed: str | Literal[2, 3]
-```
-
-## Exception handlers with `else` branches (but no `finally`)
-
-If we reach the `reveal_type` call at the end of this scope, either the `try` and `else` suites were
-both executed in their entireties, or the `except` suite was executed in its entirety. The type of
-`x` at this point is the union of the type at the end of the `else` suite and the type at the end of
-the `except` suite:
-
-- At the end of `else`, `x == 3`
-- At the end of `except`, `x == 2`
-
-```py path=single_except.py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-else:
-    reveal_type(x)  # revealed: str
-    x = 3
-    reveal_type(x)  # revealed: Literal[3]
-
-reveal_type(x)  # revealed: Literal[2, 3]
-```
-
-For a block that has multiple `except` branches and an `else` branch, the same principle applies. In
-order to reach the final `reveal_type` call, either exactly one of the `except` suites must have
-been executed in its entirety, or the `try` suite and the `else` suite must both have been executed
-in their entireties:
-
-```py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-except ValueError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = 3
-    reveal_type(x)  # revealed: Literal[3]
-else:
-    reveal_type(x)  # revealed: str
-    x = 4
-    reveal_type(x)  # revealed: Literal[4]
-
-reveal_type(x)  # revealed: Literal[2, 3, 4]
-```
-
-## Exception handlers with `finally` branches (but no `except` branches)
-
-A `finally` suite is *always* executed. As such, if we reach the `reveal_type` call at the end of
-this example, we know that `x` *must* have been reassigned to `2` during the `finally` suite. The
-type of `x` at the end of the example is therefore `Literal[2]`:
-
-```py path=redef_in_finally.py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-finally:
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-
-reveal_type(x)  # revealed: Literal[2]
-```
-
-If `x` was *not* redefined in the `finally` suite, however, things are somewhat more complicated. If
-we reach the final `reveal_type` call, unlike the state when we're visiting the `finally` suite, we
-know that the `try`-block suite ran to completion. This means that there are fewer possible states
-at this point than there were when we were inside the `finally` block.
-
-(Our current model does *not* correctly infer the types *inside* `finally` suites, however; this is
-still a TODO item for us.)
-
-```py path=no_redef_in_finally.py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-finally:
-    # TODO: should be Literal[1] | str
-    reveal_type(x)  # revealed: str
-
-reveal_type(x)  # revealed: str
-```
-
-## Combining an `except` branch with a `finally` branch
-
-As previously stated, we do not yet have accurate inference for types *inside* `finally` suites.
-When we do, however, we will have to take account of the following possibilities inside `finally`
-suites:
-
-- The `try` suite could have run to completion
-- Or we could have jumped from halfway through the `try` suite to an `except` suite, and the
-    `except` suite ran to completion
-- Or we could have jumped from halfway through the `try` suite straight to the `finally` suite due
-    to an unhandled exception
-- Or we could have jumped from halfway through the `try` suite to an `except` suite, only for an
-    exception raised in the `except` suite to cause us to jump to the `finally` suite before the
-    `except` suite ran to completion
-
-```py path=redef_in_finally.py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-def could_raise_returns_bytes() -> bytes:
-    return b"foo"
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_bytes()
-    reveal_type(x)  # revealed: bytes
-    x = could_raise_returns_bool()
-    reveal_type(x)  # revealed: bool
-finally:
-    # TODO: should be `Literal[1] | str | bytes | bool`
-    reveal_type(x)  # revealed: str | bool
-    x = 2
-    reveal_type(x)  # revealed: Literal[2]
-
-reveal_type(x)  # revealed: Literal[2]
-```
-
-Now for an example without a redefinition in the `finally` suite. As before, there *should* be fewer
-possibilities after completion of the `finally` suite than there were during the `finally` suite
-itself. (In some control-flow possibilities, some exceptions were merely *suspended* during the
-`finally` suite; these lead to the scope's termination following the conclusion of the `finally`
-suite.)
-
-```py path=no_redef_in_finally.py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-def could_raise_returns_bytes() -> bytes:
-    return b"foo"
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_bytes()
-    reveal_type(x)  # revealed: bytes
-    x = could_raise_returns_bool()
-    reveal_type(x)  # revealed: bool
-finally:
-    # TODO: should be `Literal[1] | str | bytes | bool`
-    reveal_type(x)  # revealed: str | bool
-
-reveal_type(x)  # revealed: str | bool
-```
-
-An example with multiple `except` branches and a `finally` branch:
-
-```py path=multiple_except_branches.py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-def could_raise_returns_bytes() -> bytes:
-    return b"foo"
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-def could_raise_returns_memoryview() -> memoryview:
-    return memoryview(b"")
-
-def could_raise_returns_float() -> float:
-    return 3.14
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_bytes()
-    reveal_type(x)  # revealed: bytes
-    x = could_raise_returns_bool()
-    reveal_type(x)  # revealed: bool
-except ValueError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_memoryview()
-    reveal_type(x)  # revealed: memoryview
-    x = could_raise_returns_float()
-    reveal_type(x)  # revealed: float
-finally:
-    # TODO: should be `Literal[1] | str | bytes | bool | memoryview | float`
-    reveal_type(x)  # revealed: str | bool | float
-
-reveal_type(x)  # revealed: str | bool | float
-```
-
-## Combining `except`, `else` and `finally` branches
-
-If the exception handler has an `else` branch, we must also take into account the possibility that
-control flow could have jumped to the `finally` suite from partway through the `else` suite due to
-an exception raised *there*.
-
-```py path=single_except_branch.py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-def could_raise_returns_bytes() -> bytes:
-    return b"foo"
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-def could_raise_returns_memoryview() -> memoryview:
-    return memoryview(b"")
-
-def could_raise_returns_float() -> float:
-    return 3.14
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_bytes()
-    reveal_type(x)  # revealed: bytes
-    x = could_raise_returns_bool()
-    reveal_type(x)  # revealed: bool
-else:
-    reveal_type(x)  # revealed: str
-    x = could_raise_returns_memoryview()
-    reveal_type(x)  # revealed: memoryview
-    x = could_raise_returns_float()
-    reveal_type(x)  # revealed: float
-finally:
-    # TODO: should be `Literal[1] | str | bytes | bool | memoryview | float`
-    reveal_type(x)  # revealed: bool | float
-
-reveal_type(x)  # revealed: bool | float
-```
-
-The same again, this time with multiple `except` branches:
-
-```py path=multiple_except_branches.py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-def could_raise_returns_bytes() -> bytes:
-    return b"foo"
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-def could_raise_returns_memoryview() -> memoryview:
-    return memoryview(b"")
-
-def could_raise_returns_float() -> float:
-    return 3.14
-
-def could_raise_returns_range() -> range:
-    return range(42)
-
-def could_raise_returns_slice() -> slice:
-    return slice(None)
-
-x = 1
-
-try:
-    reveal_type(x)  # revealed: Literal[1]
-    x = could_raise_returns_str()
-    reveal_type(x)  # revealed: str
-except TypeError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_bytes()
-    reveal_type(x)  # revealed: bytes
-    x = could_raise_returns_bool()
-    reveal_type(x)  # revealed: bool
-except ValueError:
-    reveal_type(x)  # revealed: Literal[1] | str
-    x = could_raise_returns_memoryview()
-    reveal_type(x)  # revealed: memoryview
-    x = could_raise_returns_float()
-    reveal_type(x)  # revealed: float
-else:
-    reveal_type(x)  # revealed: str
-    x = could_raise_returns_range()
-    reveal_type(x)  # revealed: range
-    x = could_raise_returns_slice()
-    reveal_type(x)  # revealed: slice
-finally:
-    # TODO: should be `Literal[1] | str | bytes | bool | memoryview | float | range | slice`
-    reveal_type(x)  # revealed: bool | float | slice
-
-reveal_type(x)  # revealed: bool | float | slice
-```
-
-## Nested `try`/`except` blocks
-
-It would take advanced analysis, which we are not yet capable of, to be able to determine that an
-exception handler always suppresses all exceptions. This is partly because it is possible for
-statements in `except`, `else` and `finally` suites to raise exceptions as well as statements in
-`try` suites. This means that if an exception handler is nested inside the `try` statement of an
-enclosing exception handler, it should (at least for now) be treated the same as any other node: as
-a suite containing statements that could possibly raise exceptions, which would lead to control flow
-jumping out of that suite prior to the suite running to completion.
-
-```py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-def could_raise_returns_bytes() -> bytes:
-    return b"foo"
-
-def could_raise_returns_bool() -> bool:
-    return True
-
-def could_raise_returns_memoryview() -> memoryview:
-    return memoryview(b"")
-
-def could_raise_returns_float() -> float:
-    return 3.14
-
-def could_raise_returns_range() -> range:
-    return range(42)
-
-def could_raise_returns_slice() -> slice:
-    return slice(None)
-
-def could_raise_returns_complex() -> complex:
-    return 3j
-
-def could_raise_returns_bytearray() -> bytearray:
-    return bytearray()
-
-class Foo: ...
-class Bar: ...
-
-def could_raise_returns_Foo() -> Foo:
-    return Foo()
-
-def could_raise_returns_Bar() -> Bar:
-    return Bar()
-
-x = 1
-
-try:
-    try:
-        reveal_type(x)  # revealed: Literal[1]
-        x = could_raise_returns_str()
-        reveal_type(x)  # revealed: str
-    except TypeError:
-        reveal_type(x)  # revealed: Literal[1] | str
-        x = could_raise_returns_bytes()
-        reveal_type(x)  # revealed: bytes
-        x = could_raise_returns_bool()
-        reveal_type(x)  # revealed: bool
-    except ValueError:
-        reveal_type(x)  # revealed: Literal[1] | str
-        x = could_raise_returns_memoryview()
-        reveal_type(x)  # revealed: memoryview
-        x = could_raise_returns_float()
-        reveal_type(x)  # revealed: float
-    else:
-        reveal_type(x)  # revealed: str
-        x = could_raise_returns_range()
-        reveal_type(x)  # revealed: range
-        x = could_raise_returns_slice()
-        reveal_type(x)  # revealed: slice
-    finally:
-        # TODO: should be `Literal[1] | str | bytes | bool | memoryview | float | range | slice`
-        reveal_type(x)  # revealed: bool | float | slice
-        x = 2
-        reveal_type(x)  # revealed: Literal[2]
-    reveal_type(x)  # revealed: Literal[2]
-except:
-    reveal_type(x)  # revealed: Literal[1, 2] | str | bytes | bool | memoryview | float | range | slice
-    x = could_raise_returns_complex()
-    reveal_type(x)  # revealed: complex
-    x = could_raise_returns_bytearray()
-    reveal_type(x)  # revealed: bytearray
-else:
-    reveal_type(x)  # revealed: Literal[2]
-    x = could_raise_returns_Foo()
-    reveal_type(x)  # revealed: Foo
-    x = could_raise_returns_Bar()
-    reveal_type(x)  # revealed: Bar
-finally:
-    # TODO: should be `Literal[1, 2] | str | bytes | bool | memoryview | float | range | slice | complex | bytearray | Foo | Bar`
-    reveal_type(x)  # revealed: bytearray | Bar
-
-# Either one `except` branch or the `else`
-# must have been taken and completed to get here:
-reveal_type(x)  # revealed: bytearray | Bar
-```
-
-## Nested scopes inside `try` blocks
-
-Shadowing a variable in an inner scope has no effect on type inference of the variable by that name
-in the outer scope:
-
-```py
-def could_raise_returns_str() -> str:
-    return "foo"
-
-def could_raise_returns_bytes() -> bytes:
-    return b"foo"
-
-def could_raise_returns_range() -> range:
-    return range(42)
-
-def could_raise_returns_bytearray() -> bytearray:
-    return bytearray()
-
-def could_raise_returns_float() -> float:
-    return 3.14
-
-x = 1
-
-try:
-
-    def foo(param=could_raise_returns_str()):
-        x = could_raise_returns_str()
-
-        try:
-            reveal_type(x)  # revealed: str
-            x = could_raise_returns_bytes()
-            reveal_type(x)  # revealed: bytes
-        except:
-            reveal_type(x)  # revealed: str | bytes
-            x = could_raise_returns_bytearray()
-            reveal_type(x)  # revealed: bytearray
-            x = could_raise_returns_float()
-            reveal_type(x)  # revealed: float
-        finally:
-            # TODO: should be `str | bytes | bytearray | float`
-            reveal_type(x)  # revealed: bytes | float
-        reveal_type(x)  # revealed: bytes | float
-    x = foo
-    reveal_type(x)  # revealed: Literal[foo]
-except:
-    reveal_type(x)  # revealed: Literal[1] | Literal[foo]
-
-    class Bar:
-        x = could_raise_returns_range()
-        reveal_type(x)  # revealed: range
-
-    x = Bar
-    reveal_type(x)  # revealed: Literal[Bar]
-finally:
-    # TODO: should be `Literal[1] | Literal[foo] | Literal[Bar]`
-    reveal_type(x)  # revealed: Literal[foo] | Literal[Bar]
-
-reveal_type(x)  # revealed: Literal[foo] | Literal[Bar]
-```
-
-[1]: https://astral-sh.notion.site/Exception-handler-control-flow-11348797e1ca80bb8ce1e9aedbbe439d

crates/red_knot_python_semantic/resources/mdtest/exception/except_star.md

@@ -1,30 +0,0 @@
-# Except star
-
-## Except\* with BaseException
-
-```py
-try:
-    help()
-except* BaseException as e:
-    reveal_type(e)  # revealed: BaseExceptionGroup
-```
-
-## Except\* with specific exception
-
-```py
-try:
-    help()
-except* OSError as e:
-    # TODO(Alex): more precise would be `ExceptionGroup[OSError]`
-    reveal_type(e)  # revealed: BaseExceptionGroup
-```
-
-## Except\* with multiple exceptions
-
-```py
-try:
-    help()
-except* (TypeError, AttributeError) as e:
-    # TODO(Alex): more precise would be `ExceptionGroup[TypeError | AttributeError]`.
-    reveal_type(e)  # revealed: BaseExceptionGroup
-```

crates/red_knot_python_semantic/resources/mdtest/exception/invalid_exception_syntax.md

@@ -1,13 +0,0 @@
-# Exception Handling
-
-## Invalid syntax
-
-```py
-from typing_extensions import reveal_type
-
-try:
-    print
-except as e:  # error: [invalid-syntax]
-    reveal_type(e)  # revealed: Unknown
-
-```

crates/red_knot_python_semantic/resources/mdtest/expression/boolean.md

@@ -1,110 +0,0 @@
-# Expressions
-
-## OR
-
-```py
-def foo() -> str:
-    pass
-
-reveal_type(True or False)  # revealed: Literal[True]
-reveal_type("x" or "y" or "z")  # revealed: Literal["x"]
-reveal_type("" or "y" or "z")  # revealed: Literal["y"]
-reveal_type(False or "z")  # revealed: Literal["z"]
-reveal_type(False or True)  # revealed: Literal[True]
-reveal_type(False or False)  # revealed: Literal[False]
-reveal_type(foo() or False)  # revealed: str | Literal[False]
-reveal_type(foo() or True)  # revealed: str | Literal[True]
-```
-
-## AND
-
-```py
-def foo() -> str:
-    pass
-
-reveal_type(True and False)  # revealed: Literal[False]
-reveal_type(False and True)  # revealed: Literal[False]
-reveal_type(foo() and False)  # revealed: str | Literal[False]
-reveal_type(foo() and True)  # revealed: str | Literal[True]
-reveal_type("x" and "y" and "z")  # revealed: Literal["z"]
-reveal_type("x" and "y" and "")  # revealed: Literal[""]
-reveal_type("" and "y")  # revealed: Literal[""]
-```
-
-## Simple function calls to bool
-
-```py
-def returns_bool() -> bool:
-    return True
-
-if returns_bool():
-    x = True
-else:
-    x = False
-
-reveal_type(x)  # revealed: bool
-```
-
-## Complex
-
-```py
-def foo() -> str:
-    pass
-
-reveal_type("x" and "y" or "z")  # revealed: Literal["y"]
-reveal_type("x" or "y" and "z")  # revealed: Literal["x"]
-reveal_type("" and "y" or "z")  # revealed: Literal["z"]
-reveal_type("" or "y" and "z")  # revealed: Literal["z"]
-reveal_type("x" and "y" or "")  # revealed: Literal["y"]
-reveal_type("x" or "y" and "")  # revealed: Literal["x"]
-```
-
-## `bool()` function
-
-## Evaluates to builtin
-
-```py path=a.py
-redefined_builtin_bool = bool
-
-def my_bool(x) -> bool:
-    return True
-```
-
-```py
-from a import redefined_builtin_bool, my_bool
-
-reveal_type(redefined_builtin_bool(0))  # revealed: Literal[False]
-reveal_type(my_bool(0))  # revealed: bool
-```
-
-## Truthy values
-
-```py
-reveal_type(bool(1))  # revealed: Literal[True]
-reveal_type(bool((0,)))  # revealed: Literal[True]
-reveal_type(bool("NON EMPTY"))  # revealed: Literal[True]
-reveal_type(bool(True))  # revealed: Literal[True]
-
-def foo(): ...
-
-reveal_type(bool(foo))  # revealed: Literal[True]
-```
-
-## Falsy values
-
-```py
-reveal_type(bool(0))  # revealed: Literal[False]
-reveal_type(bool(()))  # revealed: Literal[False]
-reveal_type(bool(None))  # revealed: Literal[False]
-reveal_type(bool(""))  # revealed: Literal[False]
-reveal_type(bool(False))  # revealed: Literal[False]
-reveal_type(bool())  # revealed: Literal[False]
-```
-
-## Ambiguous values
-
-```py
-reveal_type(bool([]))  # revealed: bool
-reveal_type(bool({}))  # revealed: bool
-reveal_type(bool(set()))  # revealed: bool
-```

crates/red_knot_python_semantic/resources/mdtest/expression/if.md

@@ -1,24 +0,0 @@
-# If expression
-
-## Union
-
-```py
-def bool_instance() -> bool:
-    return True
-
-reveal_type(1 if bool_instance() else 2)  # revealed: Literal[1, 2]
-```
-
-## Statically known branches
-
-```py
-reveal_type(1 if True else 2)  # revealed: Literal[1]
-reveal_type(1 if "not empty" else 2)  # revealed: Literal[1]
-reveal_type(1 if (1,) else 2)  # revealed: Literal[1]
-reveal_type(1 if 1 else 2)  # revealed: Literal[1]
-
-reveal_type(1 if False else 2)  # revealed: Literal[2]
-reveal_type(1 if None else 2)  # revealed: Literal[2]
-reveal_type(1 if "" else 2)  # revealed: Literal[2]
-reveal_type(1 if 0 else 2)  # revealed: Literal[2]
-```

crates/red_knot_python_semantic/resources/mdtest/generics.md

@@ -1,68 +0,0 @@
-# PEP 695 Generics
-
-## Class Declarations
-
-Basic PEP 695 generics
-
-```py
-class MyBox[T]:
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
-    data: T
-    box_model_number = 695
-
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
-    def __init__(self, data: T):
-        self.data = data
-
-box: MyBox[int] = MyBox(5)
-
-# TODO should emit a diagnostic here (str is not assignable to int)
-wrong_innards: MyBox[int] = MyBox("five")
-
-# TODO reveal int
-reveal_type(box.data)  # revealed: @Todo
-
-reveal_type(MyBox.box_model_number)  # revealed: Literal[695]
-```
-
-## Subclassing
-
-```py
-class MyBox[T]:
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
-    data: T
-
-    # TODO: `T` is defined here
-    # error: [unresolved-reference] "Name `T` used when not defined"
-    def __init__(self, data: T):
-        self.data = data
-
-# TODO not error on the subscripting or the use of type param
-# error: [unresolved-reference] "Name `T` used when not defined"
-# error: [non-subscriptable]
-class MySecureBox[T](MyBox[T]): ...
-
-secure_box: MySecureBox[int] = MySecureBox(5)
-reveal_type(secure_box)  # revealed: MySecureBox
-# TODO reveal int
-reveal_type(secure_box.data)  # revealed: @Todo
-```
-
-## Cyclical class definition
-
-In type stubs, classes can reference themselves in their base class definitions. For example, in
-`typeshed`, we have `class str(Sequence[str]): ...`.
-
-This should hold true even with generics at play.
-
-```py path=a.pyi
-class Seq[T]: ...
-
-# TODO not error on the subscripting
-class S[T](Seq[S]): ...  # error: [non-subscriptable]
-
-reveal_type(S)  # revealed: Literal[S]
-```

crates/red_knot_python_semantic/resources/mdtest/import/basic.md

@@ -1,27 +0,0 @@
-# Structures
-
-## Class import following
-
-```py
-from b import C as D
-
-E = D
-reveal_type(E)  # revealed: Literal[C]
-```
-
-```py path=b.py
-class C: ...
-```
-
-## Module member resolution
-
-```py
-import b
-
-D = b.C
-reveal_type(D)  # revealed: Literal[C]
-```
-
-```py path=b.py
-class C: ...
-```

crates/red_knot_python_semantic/resources/mdtest/import/builtins.md

@@ -1,8 +0,0 @@
-# Importing builtin module
-
-```py
-import builtins
-
-x = builtins.copyright
-reveal_type(x)  # revealed: Literal[copyright]
-```