Delete examples

Nice. Thank you

.editorconfig

@@ -12,3 +12,6 @@ indent_size = 2
 
 [*.{rs,py}]
 indent_size = 4
+
+[*.snap]
+trim_trailing_whitespace = false

.github/workflows/ci.yaml

@@ -121,15 +121,6 @@ jobs:
       - run: cargo check
       - run: cargo fmt --all --check
 
-  typos:
-    name: "spell check"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: crate-ci/typos@master
-        with:
-          files: .
-
   ecosystem:
     name: "ecosystem"
     runs-on: ubuntu-latest
@@ -230,3 +221,21 @@ jobs:
           exit_code=${PIPESTATUS[0]}
           echo '```' >> $GITHUB_STEP_SUMMARY
           exit $exit_code
+
+  docs:
+    name: "mkdocs"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - uses: Swatinem/rust-cache@v2
+      - name: "Install dependencies"
+        run: pip install -r docs/requirements.txt
+      - name: "Update README File"
+        run: python scripts/transform_readme.py --target mkdocs
+      - name: "Generate docs"
+        run: python scripts/generate_mkdocs.py
+      - name: "Build docs"
+        run: mkdocs build --strict

.gitignore

@@ -3,6 +3,7 @@
 crates/ruff/resources/test/cpython
 mkdocs.yml
 .overrides
+github_search.jsonl
 
 ###
 # Rust.gitignore

.pre-commit-config.yaml

@@ -23,6 +23,11 @@ repos:
           - MD033 # no-inline-html
           - --
 
+  - repo: https://github.com/crate-ci/typos
+    rev: v1.14.8
+    hooks:
+      - id: typos
+
   - repo: local
     hooks:
       - id: cargo-fmt

BREAKING_CHANGES.md

@@ -1,5 +1,51 @@
 # Breaking Changes
 
+## 0.0.265
+
+### `--fix-only` now exits with a zero exit code, unless `--exit-non-zero-on-fix` is specified ([#4146](https://github.com/charliermarsh/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/charliermarsh/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/charliermarsh/ruff/pull/2773))

CONTRIBUTING.md

@@ -116,8 +116,7 @@ At a high level, the steps involved in adding a new lint rule are as follows:
 To define the violation, start by creating a dedicated file for your rule under the appropriate
 rule linter (e.g., `crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs`). That file should
 contain a struct defined via `#[violation]`, along with a function that creates the violation
-based on any required inputs. (Many of the existing examples live in `crates/ruff/src/violations.rs`,
-but we're looking to place new rules in their own files.)
+based on any required inputs.
 
 To trigger the violation, you'll likely want to augment the logic in `crates/ruff/src/checkers/ast.rs`,
 which defines the Python AST visitor, responsible for iterating over the abstract syntax tree and
@@ -215,6 +214,20 @@ 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).
 
+## Ecosystem CI
+
+GitHub Actions will run your changes against a number of real-world projects from GitHub and
+report on any diagnostic differences. You can also run those checks locally via:
+
+```shell
+python scripts/check_ecosystem.py path/to/your/ruff path/to/older/ruff
+```
+
+You can also run the Ecosystem CI check in a Docker container across a larger set of projects by
+downloading the [`known-github-tomls.json`](https://github.com/akx/ruff-usage-aggregate/blob/master/data/known-github-tomls.jsonl)
+as `github_search.jsonl` and following the instructions in [scripts/Dockerfile.ecosystem](https://github.com/charliermarsh/ruff/blob/main/scripts/Dockerfile.ecosystem).
+Note that this check will take a while to run.
+
 ## Benchmarks
 
 First, clone [CPython](https://github.com/python/cpython). It's a large and diverse Python codebase,

Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 
 [workspace.package]
 edition = "2021"
-rust-version = "1.67"
+rust-version = "1.69"
 homepage = "https://beta.ruff.rs/docs/"
 documentation = "https://beta.ruff.rs/docs/"
 repository = "https://github.com/charliermarsh/ruff"
@@ -11,7 +11,7 @@ authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
 
 [workspace.dependencies]
 anyhow = { version = "1.0.69" }
-bitflags = { version = "1.3.2" }
+bitflags = { version = "2.1.0" }
 chrono = { version = "0.4.23", default-features = false, features = ["clock"] }
 clap = { version = "4.1.8", features = ["derive"] }
 colored = { version = "2.0.0" }
@@ -30,12 +30,10 @@ path-absolutize = { version = "3.0.14" }
 proc-macro2 = { version = "1.0.51" }
 quote = { version = "1.0.23" }
 regex = { version = "1.7.1" }
+ruff_text_size = { git = "https://github.com/charliermarsh/RustPython.git", rev = "c3147d2c1524ebd0e90cf1c2938d770314fd5a5a" }
 rustc-hash = { version = "1.1.0" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "c15f670f2c30cfae6b41a1874893590148c74bc4" }
-rustpython-parser = { features = [
-  "lalrpop",
-  "serde",
-], git = "https://github.com/RustPython/RustPython.git", rev = "c15f670f2c30cfae6b41a1874893590148c74bc4" }
+rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "c3147d2c1524ebd0e90cf1c2938d770314fd5a5a" }
+rustpython-parser = { git = "https://github.com/charliermarsh/RustPython.git", rev = "c3147d2c1524ebd0e90cf1c2938d770314fd5a5a" }
 schemars = { version = "0.8.12" }
 serde = { version = "1.0.152", features = ["derive"] }
 serde_json = { version = "1.0.93", features = ["preserve_order"] }
@@ -44,7 +42,7 @@ similar = { version = "2.2.1" }
 smallvec = { version = "1.10.0" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
 strum_macros = { version = "0.24.3" }
-syn = { version = "1.0.109" }
+syn = { version = "2.0.15" }
 test-case = { version = "3.0.0" }
 textwrap = { version = "0.16.0" }
 toml = { version = "0.7.2" }

README.md

@@ -47,16 +47,16 @@ all while executing tens or hundreds of times faster than any individual tool.
 
 Ruff is extremely actively developed and used in major open-source projects like:
 
-- [pandas](https://github.com/pandas-dev/pandas)
-- [FastAPI](https://github.com/tiangolo/fastapi)
-- [Transformers (Hugging Face)](https://github.com/huggingface/transformers)
 - [Apache Airflow](https://github.com/apache/airflow)
+- [FastAPI](https://github.com/tiangolo/fastapi)
+- [Hugging Face](https://github.com/huggingface/transformers)
+- [Pandas](https://github.com/pandas-dev/pandas)
 - [SciPy](https://github.com/scipy/scipy)
 
 ...and many more.
 
-Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster) or
-the most recent [project update](https://notes.crmarsh.com/ruff-the-first-200-releases).
+Ruff is backed by [Astral](https://astral.sh). Read the [launch post](https://astral.sh/blog/announcing-astral-the-company-behind-ruff),
+or the original [project announcement](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).
 
 ## Testimonials
 
@@ -137,7 +137,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com) hook:
 ```yaml
 - repo: https://github.com/charliermarsh/ruff-pre-commit
   # Ruff version.
-  rev: 'v0.0.261'
+  rev: 'v0.0.265'
   hooks:
     - id: ruff
 ```
@@ -183,6 +183,7 @@ exclude = [
     ".direnv",
     ".eggs",
     ".git",
+    ".git-rewrite",
     ".hg",
     ".mypy_cache",
     ".nox",
@@ -332,55 +333,68 @@ Ruff is released under the MIT license.
 
 ## Who's Using Ruff?
 
-Ruff is used in a number of major open-source projects, including:
+Ruff is used by a number of major open-source projects and companies, including:
 
-- [pandas](https://github.com/pandas-dev/pandas)
-- [FastAPI](https://github.com/tiangolo/fastapi)
-- [Transformers (Hugging Face)](https://github.com/huggingface/transformers)
-- [Diffusers (Hugging Face)](https://github.com/huggingface/diffusers)
+- Amazon ([AWS SAM](https://github.com/aws/serverless-application-model))
 - [Apache Airflow](https://github.com/apache/airflow)
-- [SciPy](https://github.com/scipy/scipy)
-- [Zulip](https://github.com/zulip/zulip)
-- [Bokeh](https://github.com/bokeh/bokeh)
-- [Pydantic](https://github.com/pydantic/pydantic)
-- [PostHog](https://github.com/PostHog/posthog)
-- [Dagster](https://github.com/dagster-io/dagster)
-- [Dagger](https://github.com/dagger/dagger)
-- [Sphinx](https://github.com/sphinx-doc/sphinx)
-- [Hatch](https://github.com/pypa/hatch)
-- [PDM](https://github.com/pdm-project/pdm)
-- [Jupyter](https://github.com/jupyter-server/jupyter_server)
-- [Great Expectations](https://github.com/great-expectations/great_expectations)
-- [ONNX](https://github.com/onnx/onnx)
-- [Polars](https://github.com/pola-rs/polars)
-- [Ibis](https://github.com/ibis-project/ibis)
-- [Synapse (Matrix)](https://github.com/matrix-org/synapse)
-- [SnowCLI (Snowflake)](https://github.com/Snowflake-Labs/snowcli)
-- [Dispatch (Netflix)](https://github.com/Netflix/dispatch)
-- [Saleor](https://github.com/saleor/saleor)
-- [Pynecone](https://github.com/pynecone-io/pynecone)
-- [OpenBB](https://github.com/OpenBB-finance/OpenBBTerminal)
-- [Home Assistant](https://github.com/home-assistant/core)
-- [Pylint](https://github.com/PyCQA/pylint)
-- [Cryptography (PyCA)](https://github.com/pyca/cryptography)
-- [cibuildwheel (PyPA)](https://github.com/pypa/cibuildwheel)
-- [build (PyPA)](https://github.com/pypa/build)
+- AstraZeneca ([Magnus](https://github.com/AstraZeneca/magnus-core))
+- Benchling ([Refac](https://github.com/benchling/refac))
 - [Babel](https://github.com/python-babel/babel)
-- [featuretools](https://github.com/alteryx/featuretools)
-- [meson-python](https://github.com/mesonbuild/meson-python)
-- [ZenML](https://github.com/zenml-io/zenml)
-- [delta-rs](https://github.com/delta-io/delta-rs)
-- [Starlite](https://github.com/starlite-api/starlite)
-- [telemetry-airflow (Mozilla)](https://github.com/mozilla/telemetry-airflow)
-- [Stable Baselines3](https://github.com/DLR-RM/stable-baselines3)
-- [PaddlePaddle](https://github.com/PaddlePaddle/Paddle)
-- [nox](https://github.com/wntrblm/nox)
-- [Neon](https://github.com/neondatabase/neon)
-- [The Algorithms](https://github.com/TheAlgorithms/Python)
-- [Openverse](https://github.com/WordPress/openverse)
-- [MegaLinter](https://github.com/oxsecurity/megalinter)
+- [Bokeh](https://github.com/bokeh/bokeh)
+- [Cryptography (PyCA)](https://github.com/pyca/cryptography)
+- [Dagger](https://github.com/dagger/dagger)
+- [Dagster](https://github.com/dagster-io/dagster)
+- [DVC](https://github.com/iterative/dvc)
+- [FastAPI](https://github.com/tiangolo/fastapi)
+- [Gradio](https://github.com/gradio-app/gradio)
+- [Great Expectations](https://github.com/great-expectations/great_expectations)
+- Hugging Face ([Transformers](https://github.com/huggingface/transformers), [Datasets](https://github.com/huggingface/datasets), [Diffusers](https://github.com/huggingface/diffusers))
+- [Hatch](https://github.com/pypa/hatch)
+- [Home Assistant](https://github.com/home-assistant/core)
+- [Ibis](https://github.com/ibis-project/ibis)
+- [Jupyter](https://github.com/jupyter-server/jupyter_server)
 - [LangChain](https://github.com/hwchase17/langchain)
 - [LlamaIndex](https://github.com/jerryjliu/llama_index)
+- Matrix ([Synapse](https://github.com/matrix-org/synapse))
+- Meltano ([Meltano CLI](https://github.com/meltano/meltano), [Singer SDK](https://github.com/meltano/sdk))
+- Modern Treasury ([Python SDK](https://github.com/Modern-Treasury/modern-treasury-python-sdk))
+- Mozilla ([Firefox](https://github.com/mozilla/gecko-dev))
+- [MegaLinter](https://github.com/oxsecurity/megalinter)
+- Microsoft ([Semantic Kernel](https://github.com/microsoft/semantic-kernel), [ONNX Runtime](https://github.com/microsoft/onnxruntime))
+- Netflix ([Dispatch](https://github.com/Netflix/dispatch))
+- [Neon](https://github.com/neondatabase/neon)
+- [ONNX](https://github.com/onnx/onnx)
+- [OpenBB](https://github.com/OpenBB-finance/OpenBBTerminal)
+- [PDM](https://github.com/pdm-project/pdm)
+- [PaddlePaddle](https://github.com/PaddlePaddle/Paddle)
+- [Pandas](https://github.com/pandas-dev/pandas)
+- [Poetry](https://github.com/python-poetry/poetry)
+- [Polars](https://github.com/pola-rs/polars)
+- [PostHog](https://github.com/PostHog/posthog)
+- Prefect ([Python SDK](https://github.com/PrefectHQ/prefect), [Marvin](https://github.com/PrefectHQ/marvin))
+- [Pydantic](https://github.com/pydantic/pydantic)
+- [PyInstaller](https://github.com/pyinstaller/pyinstaller)
+- [Pylint](https://github.com/PyCQA/pylint)
+- [Pynecone](https://github.com/pynecone-io/pynecone)
+- [Robyn](https://github.com/sansyrox/robyn)
+- Scale AI ([Launch SDK](https://github.com/scaleapi/launch-python-client))
+- Snowflake ([SnowCLI](https://github.com/Snowflake-Labs/snowcli))
+- [Saleor](https://github.com/saleor/saleor)
+- [SciPy](https://github.com/scipy/scipy)
+- [Sphinx](https://github.com/sphinx-doc/sphinx)
+- [Stable Baselines3](https://github.com/DLR-RM/stable-baselines3)
+- [Starlite](https://github.com/starlite-api/starlite)
+- [The Algorithms](https://github.com/TheAlgorithms/Python)
+- [Vega-Altair](https://github.com/altair-viz/altair)
+- WordPress ([Openverse](https://github.com/WordPress/openverse))
+- [ZenML](https://github.com/zenml-io/zenml)
+- [Zulip](https://github.com/zulip/zulip)
+- [build (PyPA)](https://github.com/pypa/build)
+- [cibuildwheel (PyPA)](https://github.com/pypa/cibuildwheel)
+- [delta-rs](https://github.com/delta-io/delta-rs)
+- [featuretools](https://github.com/alteryx/featuretools)
+- [meson-python](https://github.com/mesonbuild/meson-python)
+- [nox](https://github.com/wntrblm/nox)
 
 ## License
 

_typos.toml

@@ -5,3 +5,6 @@ extend-exclude = ["snapshots", "black"]
 trivias = "trivias"
 hel = "hel"
 whos = "whos"
+spawnve = "spawnve"
+ned = "ned"
+poit = "poit"

crates/flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.261"
+version = "0.0.265"
 edition = { workspace = true }
 rust-version = { workspace = true }
 

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.261"
+version = "0.0.265"
 authors.workspace = true
 edition.workspace = true
 rust-version.workspace = true
@@ -17,17 +17,19 @@ name = "ruff"
 ruff_cache = { path = "../ruff_cache" }
 ruff_diagnostics = { path = "../ruff_diagnostics", features = ["serde"] }
 ruff_macros = { path = "../ruff_macros" }
-ruff_python_ast = { path = "../ruff_python_ast" }
+ruff_python_ast = { path = "../ruff_python_ast", features = ["serde"] }
 ruff_python_semantic = { path = "../ruff_python_semantic" }
 ruff_python_stdlib = { path = "../ruff_python_stdlib" }
 ruff_rustpython = { path = "../ruff_rustpython" }
+ruff_text_size = { workspace = true }
 
+annotate-snippets = { version = "0.9.1", features = ["color"] }
 anyhow = { workspace = true }
 bitflags = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true, features = ["derive", "string"], optional = true }
 colored = { workspace = true }
-dirs = { version = "4.0.0" }
+dirs = { version = "5.0.0" }
 fern = { version = "0.6.1" }
 glob = { workspace = true }
 globset = { workspace = true }
@@ -48,6 +50,7 @@ path-absolutize = { workspace = true, features = [
 ] }
 pathdiff = { version = "0.2.1" }
 pep440_rs = { version = "0.3.1", features = ["serde"] }
+quick-junit = { version = "0.3.2" }
 regex = { workspace = true }
 result-like = { version = "0.4.6" }
 rustc-hash = { workspace = true }
@@ -57,6 +60,7 @@ schemars = { workspace = true }
 semver = { version = "1.0.16" }
 serde = { workspace = true }
 serde_json = { workspace = true }
+similar = { workspace = true, features = ["inline"] }
 shellexpand = { workspace = true }
 smallvec = { workspace = true }
 strum = { workspace = true }
@@ -68,9 +72,11 @@ typed-arena = { version = "2.0.2" }
 unicode-width = { version = "0.1.10" }
 
 [dev-dependencies]
-insta = { workspace = true, features = ["yaml", "redactions"] }
+insta = { workspace = true }
 pretty_assertions = "1.3.0"
 test-case = { workspace = true }
+# Disable colored output in tests
+colored = { workspace = true, features = ["no-color"] }
 
 [features]
 default = []

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

@@ -9,7 +9,13 @@ def foo(x, y, z):
     print(x, y, z)
 
     # This is a real comment.
+    # # This is a (nested) comment.
     #return True
     return False
 
 #import os  # noqa: ERA001
+
+
+class A():
+    pass
+    # b = c

crates/ruff/resources/test/fixtures/flake8_bandit/S101.py

@@ -1,11 +1,13 @@
-# Error
-assert True
+assert True  # S101
+
 
 def fn():
     x = 1
+    assert x == 1  # S101
+    assert x == 2  # S101
 
-    # Error
-    assert x == 1
 
-    # Error
-    assert x == 2
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    assert True  # OK

crates/ruff/resources/test/fixtures/flake8_bandit/S602.py

@@ -0,0 +1,20 @@
+from subprocess import Popen, call, check_call, check_output, run
+
+# Check different Popen wrappers are checked.
+Popen("true", shell=True)
+call("true", shell=True)
+check_call("true", shell=True)
+check_output("true", shell=True)
+run("true", shell=True)
+
+# Check values that truthy values are treated as true.
+Popen("true", shell=1)
+Popen("true", shell=[1])
+Popen("true", shell={1: 1})
+Popen("true", shell=(1,))
+
+# Check command argument looks unsafe.
+var_string = "true"
+Popen(var_string, shell=True)
+Popen([var_string], shell=True)
+Popen([var_string, ""], shell=True)

crates/ruff/resources/test/fixtures/flake8_bandit/S603.py

@@ -0,0 +1,20 @@
+from subprocess import Popen, call, check_call, check_output, run
+
+# Different Popen wrappers are checked.
+Popen("true", shell=False)
+call("true", shell=False)
+check_call("true", shell=False)
+check_output("true", shell=False)
+run("true", shell=False)
+
+# Values that falsey values are treated as false.
+Popen("true", shell=0)
+Popen("true", shell=[])
+Popen("true", shell={})
+Popen("true", shell=None)
+
+# Unknown values are treated as falsey.
+Popen("true", shell=True if True else False)
+
+# No value is also caught.
+Popen("true")

crates/ruff/resources/test/fixtures/flake8_bandit/S604.py

@@ -0,0 +1,5 @@
+def foo(shell):
+    pass
+
+
+foo(shell=True)

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

@@ -0,0 +1,25 @@
+import os
+
+import commands
+import popen2
+
+# Check all shell functions.
+os.system("true")
+os.popen("true")
+os.popen2("true")
+os.popen3("true")
+os.popen4("true")
+popen2.popen2("true")
+popen2.popen3("true")
+popen2.popen4("true")
+popen2.Popen3("true")
+popen2.Popen4("true")
+commands.getoutput("true")
+commands.getstatusoutput("true")
+
+
+# Check command argument looks unsafe.
+var_string = "true"
+os.system(var_string)
+os.system([var_string])
+os.system([var_string, ""])

crates/ruff/resources/test/fixtures/flake8_bandit/S606.py

@@ -0,0 +1,20 @@
+import os
+
+# Check all shell functions.
+os.execl("true")
+os.execle("true")
+os.execlp("true")
+os.execlpe("true")
+os.execv("true")
+os.execve("true")
+os.execvp("true")
+os.execvpe("true")
+os.spawnl("true")
+os.spawnle("true")
+os.spawnlp("true")
+os.spawnlpe("true")
+os.spawnv("true")
+os.spawnve("true")
+os.spawnvp("true")
+os.spawnvpe("true")
+os.startfile("true")

crates/ruff/resources/test/fixtures/flake8_bandit/S607.py

@@ -0,0 +1,44 @@
+import os
+
+# Check all functions.
+subprocess.Popen("true")
+subprocess.call("true")
+subprocess.check_call("true")
+subprocess.check_output("true")
+subprocess.run("true")
+os.system("true")
+os.popen("true")
+os.popen2("true")
+os.popen3("true")
+os.popen4("true")
+popen2.popen2("true")
+popen2.popen3("true")
+popen2.popen4("true")
+popen2.Popen3("true")
+popen2.Popen4("true")
+commands.getoutput("true")
+commands.getstatusoutput("true")
+os.execl("true")
+os.execle("true")
+os.execlp("true")
+os.execlpe("true")
+os.execv("true")
+os.execve("true")
+os.execvp("true")
+os.execvpe("true")
+os.spawnl("true")
+os.spawnle("true")
+os.spawnlp("true")
+os.spawnlpe("true")
+os.spawnv("true")
+os.spawnve("true")
+os.spawnvp("true")
+os.spawnvpe("true")
+os.startfile("true")
+
+# Check it does not fail for full paths.
+os.system("/bin/ls")
+os.system("./bin/ls")
+os.system(["/bin/ls"])
+os.system(["/bin/ls", "/tmp"])
+os.system(r"C:\\bin\ls")

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

@@ -1,9 +1,10 @@
 """
 Should emit:
-B017 - on lines 20
+B017 - on lines 23 and 41
 """
 import asyncio
 import unittest
+import pytest
 
 CONSTANT = True
 
@@ -34,3 +35,14 @@ class Foobar(unittest.TestCase):
     def raises_with_absolute_reference(self):
         with self.assertRaises(asyncio.CancelledError):
             Foo()
+
+
+def test_pytest_raises():
+    with pytest.raises(Exception):
+        raise ValueError("Hello")
+
+    with pytest.raises(Exception, "hello"):
+        raise ValueError("This is fine")
+
+    with pytest.raises(Exception, match="hello"):
+        raise ValueError("This is also fine")

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

@@ -172,3 +172,14 @@ def iter_f(names):
 
         if False:
             return [lambda: i for i in range(3)]  # error
+
+
+for val in range(3):
+    def make_func(val=val):
+        def tmp():
+            return print(val)
+
+        return tmp
+
+
+    funcs.append(make_func())

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

@@ -0,0 +1,39 @@
+"""
+Should emit:
+B027 - on lines 13, 16, 19, 23
+"""
+from abc import ABC
+
+
+class AbstractClass(ABC):
+    def empty_1(self):  # error
+        ...
+
+    def empty_2(self):  # error
+        pass
+
+    def body_1(self):
+        print("foo")
+        ...
+
+    def body_2(self):
+        self.body_1()
+
+
+def foo():
+    class InnerAbstractClass(ABC):
+        def empty_1(self):  # error
+            ...
+
+        def empty_2(self):  # error
+            pass
+
+        def body_1(self):
+            print("foo")
+            ...
+
+        def body_2(self):
+            self.body_1()
+
+    return InnerAbstractClass
+

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

@@ -78,6 +78,21 @@ for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
     for shopper in shoppers:
         collect_shop_items(shopper, section_items)  # B031
 
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    _ = [collect_shop_items(shopper, section_items) for shopper in shoppers]  # B031
+
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    # The variable is overridden, skip checking.
+    _ = [_ for section_items in range(3)]
+    _ = [collect_shop_items(shopper, section_items) for shopper in shoppers]
+
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    _ = [item for item in section_items]
+
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    # The iterator is being used for the second time.
+    _ = [(item1, item2) for item1 in section_items for item2 in section_items]  # B031
+
 for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
     if _section == "greens":
         collect_shop_items(shopper, section_items)
@@ -134,6 +149,16 @@ for group in groupby(items, key=lambda p: p[1]):
     collect_shop_items("Joe", group[1])
 
 
+# https://github.com/charliermarsh/ruff/issues/4050
+for _section, section_items in itertools.groupby(items, key=lambda p: p[1]):
+    if _section == "greens":
+        for item in section_items:
+            collect_shop_items(shopper, item)
+    elif _section == "frozen items":
+        _ = [item for item in section_items]
+    else:
+        collect_shop_items(shopper, section_items)
+
 #  Make sure we ignore - but don't fail on more complicated invocations
 for _key, (_value1, _value2) in groupby(
     [("a", (1, 2)), ("b", (3, 4)), ("a", (5, 6))], key=lambda p: p[1]

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

@@ -7,11 +7,14 @@ set(set(x))
 set(list(x))
 set(tuple(x))
 set(sorted(x))
+set(sorted(x, key=lambda y: y))
 set(reversed(x))
 sorted(list(x))
 sorted(tuple(x))
 sorted(sorted(x))
+sorted(sorted(x, key=lambda y: y))
 sorted(reversed(x))
+sorted(list(x), key=lambda y: y)
 tuple(
     list(
         [x, 3, "hell"\

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

@@ -0,0 +1,10 @@
+dict({})
+dict({'a': 1})
+dict({'x': 1 for x in range(10)})
+dict(
+    {'x': 1 for x in range(10)}
+)
+
+dict({}, a=1)
+dict({x: 1 for x in range(1)}, a=1)
+

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

@@ -1,4 +1,3 @@
-# PIE802
 any([x.id for x in bar])
 all([x.id for x in bar])
 any(  # first comment
@@ -15,5 +14,6 @@ all(x.id for x in bar)
 any(x.id for x in bar)
 all((x.id for x in bar))
 
+
 async def f() -> bool:
     return all([await use_greeting(greeting) for greeting in await greetings()])

crates/ruff/resources/test/fixtures/flake8_errmsg/EM.py

@@ -21,3 +21,36 @@ def f_c():
 def f_ok():
     msg = "hello"
     raise RuntimeError(msg)
+
+
+def f_unfixable():
+    msg = "hello"
+    raise RuntimeError("This is an example exception")
+
+
+def f_msg_in_nested_scope():
+    def nested():
+        msg = "hello"
+
+    raise RuntimeError("This is an example exception")
+
+
+def f_msg_in_parent_scope():
+    msg = "hello"
+
+    def nested():
+        raise RuntimeError("This is an example exception")
+
+
+def f_fix_indentation_check(foo):
+    if foo:
+        raise RuntimeError("This is an example exception")
+    else:
+        if foo == "foo":
+            raise RuntimeError(f"This is an exception: {foo}")
+    raise RuntimeError("This is an exception: {}".format(foo))
+
+
+# Report these, but don't fix them
+if foo: raise RuntimeError("This is an example exception")
+if foo: x = 1; raise RuntimeError("This is an example exception")

crates/ruff/resources/test/fixtures/flake8_import_conventions/custom_banned.py

@@ -0,0 +1,16 @@
+import typing as t  # banned
+import typing as ty  # banned
+
+import numpy as nmp  # banned
+import numpy as npy  # banned
+import tensorflow.keras.backend as K  # banned
+import torch.nn.functional as F  # banned
+from tensorflow.keras import backend as K  # banned
+from torch.nn import functional as F  # banned
+
+from typing import Any  # ok
+
+import numpy as np  # ok
+import tensorflow as tf  # ok
+import torch.nn as nn  # ok
+from tensorflow.keras import backend  # ok

crates/ruff/resources/test/fixtures/flake8_import_conventions/custom_banned_from.py

@@ -0,0 +1,10 @@
+from logging.config import BaseConfigurator  # banned
+from typing import Any, Dict  # banned
+from typing import *  # banned
+
+from pandas import DataFrame  # banned
+from pandas import *  # banned
+
+import logging.config  # ok
+import typing  # ok
+import pandas  # ok

crates/ruff/resources/test/fixtures/flake8_logging_format/G001.py

@@ -7,3 +7,12 @@ foo.info("Hello {}".format("World!"))
 logging.log(logging.INFO, msg="Hello {}".format("World!"))
 logging.log(level=logging.INFO, msg="Hello {}".format("World!"))
 logging.log(msg="Hello {}".format("World!"), level=logging.INFO)
+
+# Flask support
+import flask
+from flask import current_app
+from flask import current_app as app
+
+flask.current_app.logger.info("Hello {}".format("World!"))
+current_app.logger.info("Hello {}".format("World!"))
+app.logger.log(logging.INFO, "Hello {}".format("World!"))

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

@@ -11,3 +11,7 @@ _T = TypeVar("_T")  # OK
 _TTuple = TypeVarTuple("_TTuple")  # OK
 
 _P = ParamSpec("_P")  # OK
+
+
+def f():
+    T = TypeVar("T")  # OK

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

@@ -11,3 +11,6 @@ _T = TypeVar("_T")  # OK
 _TTuple = TypeVarTuple("_TTuple")  # OK
 
 _P = ParamSpec("_P")  # OK
+
+def f():
+    T = TypeVar("T")  # OK

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

@@ -46,3 +46,48 @@ field229: dict[int, int] = {1: 2, **{3: 4}}  # Y015 Only simple default values a
 field23 = "foo" + "bar"  # Y015 Only simple default values are allowed for assignments
 field24 = b"foo" + b"bar"  # Y015 Only simple default values are allowed for assignments
 field25 = 5 * 5  # Y015 Only simple default values are allowed for assignments
+
+# We shouldn't emit Y015 within functions
+def f():
+  field26: list[int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+
+
+# We shouldn't emit Y015 for __slots__ or __match_args__
+class Class1:
+  __slots__ = (
+    '_one',
+    '_two',
+    '_three',
+    '_four',
+    '_five',
+    '_six',
+    '_seven',
+    '_eight',
+    '_nine',
+    '_ten',
+    '_eleven',
+  )
+
+  __match_args__ = (
+    'one',
+    'two',
+    'three',
+    'four',
+    'five',
+    'six',
+    'seven',
+    'eight',
+    'nine',
+    'ten',
+    'eleven',
+  )
+
+# We shouldn't emit Y015 for __all__
+__all__ = ["Class1"]
+
+# Ignore the following for PYI015
+field26 = typing.Sequence[int]
+field27 = list[str]
+field28 = builtins.str
+field29 = str
+field30 = str | bytes | None

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

@@ -53,3 +53,48 @@ field229: dict[int, int] = {1: 2, **{3: 4}}  # Y015 Only simple default values a
 field23 = "foo" + "bar"  # Y015 Only simple default values are allowed for assignments
 field24 = b"foo" + b"bar"  # Y015 Only simple default values are allowed for assignments
 field25 = 5 * 5  # Y015 Only simple default values are allowed for assignments
+
+# We shouldn't emit Y015 within functions
+def f():
+  field26: list[int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+
+
+# We shouldn't emit Y015 for __slots__ or __match_args__
+class Class1:
+  __slots__ = (
+    '_one',
+    '_two',
+    '_three',
+    '_four',
+    '_five',
+    '_six',
+    '_seven',
+    '_eight',
+    '_nine',
+    '_ten',
+    '_eleven',
+  )
+
+  __match_args__ = (
+    'one',
+    'two',
+    'three',
+    'four',
+    'five',
+    'six',
+    'seven',
+    'eight',
+    'nine',
+    'ten',
+    'eleven',
+  )
+
+# We shouldn't emit Y015 for __all__
+__all__ = ["Class1"]
+
+# Ignore the following for PYI015
+field26 = typing.Sequence[int]
+field27 = list[str]
+field28 = builtins.str
+field29 = str
+field30 = str | bytes | None

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

@@ -0,0 +1,35 @@
+# Shouldn't affect non-union field types.
+field1: str
+
+# Should emit for duplicate field types.
+field2: str | str  # PYI016: Duplicate union member `str`
+
+
+# Should emit for union types in arguments.
+def func1(arg1: int | int):  # PYI016: Duplicate union member `int`
+    print(arg1)
+
+
+# Should emit for unions in return types.
+def func2() -> str | str:  # PYI016: Duplicate union member `str`
+    return "my string"
+
+
+# Should emit in longer unions, even if not directly adjacent.
+field3: str | str | int  # PYI016: Duplicate union member `str`
+field4: int | int | str  # PYI016: Duplicate union member `int`
+field5: str | int | str  # PYI016: Duplicate union member `str`
+field6: int | bool | str | int  # PYI016: Duplicate union member `int`
+
+# Shouldn't emit for non-type unions.
+field7 = str | str
+
+# Should emit for strangely-bracketed unions.
+field8: int | (str | int)  # PYI016: Duplicate union member `int`
+
+# Should handle user brackets when fixing.
+field9: int | (int | str)  # PYI016: Duplicate union member `int`
+field10: (str | int) | str  # PYI016: Duplicate union member `str`
+
+# Should emit for nested unions.
+field11: dict[int | int, str]

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

@@ -0,0 +1,32 @@
+# Shouldn't affect non-union field types.
+field1: str
+
+# Should emit for duplicate field types.
+field2: str | str  # PYI016: Duplicate union member `str`
+
+# Should emit for union types in arguments.
+def func1(arg1: int | int):  # PYI016: Duplicate union member `int`
+    print(arg1)
+
+# Should emit for unions in return types.
+def func2() -> str | str:  # PYI016: Duplicate union member `str`
+    return "my string"
+
+# Should emit in longer unions, even if not directly adjacent.
+field3: str | str | int  # PYI016: Duplicate union member `str`
+field4: int | int | str  # PYI016: Duplicate union member `int`
+field5: str | int | str  # PYI016: Duplicate union member `str`
+field6: int | bool | str | int  # PYI016: Duplicate union member `int`
+
+# Shouldn't emit for non-type unions.
+field7 = str | str
+
+# Should emit for strangely-bracketed unions.
+field8: int | (str | int)  # PYI016: Duplicate union member `int`
+
+# Should handle user brackets when fixing.
+field9: int | (int | str)  # PYI016: Duplicate union member `int`
+field10: (str | int) | str  # PYI016: Duplicate union member `str`
+
+# Should emit for nested unions.
+field11: dict[int | int, str]

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

@@ -0,0 +1,28 @@
+import sys
+import typing
+from typing import Annotated, Literal, TypeAlias, TypeVar
+
+import typing_extensions
+
+def f(x: "int"): ...  # Y020 Quoted annotations should never be used in stubs
+def g(x: list["int"]): ...  # Y020 Quoted annotations should never be used in stubs
+_T = TypeVar("_T", bound="int")  # Y020 Quoted annotations should never be used in stubs
+
+def h(w: Literal["a", "b"], x: typing.Literal["c"], y: typing_extensions.Literal["d"], z: _T) -> _T: ...
+
+def j() -> "int": ...  # Y020 Quoted annotations should never be used in stubs
+Alias: TypeAlias = list["int"]  # Y020 Quoted annotations should never be used in stubs
+
+class Child(list["int"]):  # Y020 Quoted annotations should never be used in stubs
+    """Documented and guaranteed useful."""  # Y021 Docstrings should not be included in stubs
+
+if sys.platform == "linux":
+    f: "int"  # Y020 Quoted annotations should never be used in stubs
+elif sys.platform == "win32":
+    f: "str"  # Y020 Quoted annotations should never be used in stubs
+else:
+    f: "bytes"  # Y020 Quoted annotations should never be used in stubs
+
+# These two shouldn't trigger Y020 -- empty strings can't be "quoted annotations"
+k = ""  # Y052 Need type annotation for "k"
+el = r""  # Y052 Need type annotation for "el"

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

@@ -0,0 +1,28 @@
+import sys
+import typing
+from typing import Annotated, Literal, TypeAlias, TypeVar
+
+import typing_extensions
+
+def f(x: "int"): ...  # Y020 Quoted annotations should never be used in stubs
+def g(x: list["int"]): ...  # Y020 Quoted annotations should never be used in stubs
+_T = TypeVar("_T", bound="int")  # Y020 Quoted annotations should never be used in stubs
+
+def h(w: Literal["a", "b"], x: typing.Literal["c"], y: typing_extensions.Literal["d"], z: _T) -> _T: ...
+
+def j() -> "int": ...  # Y020 Quoted annotations should never be used in stubs
+Alias: TypeAlias = list["int"]  # Y020 Quoted annotations should never be used in stubs
+
+class Child(list["int"]):  # Y020 Quoted annotations should never be used in stubs
+    """Documented and guaranteed useful."""  # Y021 Docstrings should not be included in stubs
+
+if sys.platform == "linux":
+    f: "int"  # Y020 Quoted annotations should never be used in stubs
+elif sys.platform == "win32":
+    f: "str"  # Y020 Quoted annotations should never be used in stubs
+else:
+    f: "bytes"  # Y020 Quoted annotations should never be used in stubs
+
+# These two shouldn't trigger Y020 -- empty strings can't be "quoted annotations"
+k = ""  # Y052 Need type annotation for "k"
+el = r""  # Y052 Need type annotation for "el"

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

@@ -0,0 +1,24 @@
+import typing
+from collections.abc import Mapping
+from typing import (
+    Annotated,
+    TypeAlias,
+    Union,
+    Literal,
+)
+
+just_literals_pipe_union: TypeAlias = (
+    Literal[True] | Literal["idk"]
+)  # not PYI042 (not a stubfile)
+PublicAliasT: TypeAlias = str | int
+PublicAliasT2: TypeAlias = Union[str, bytes]
+_ABCDEFGHIJKLMNOPQRST: TypeAlias = typing.Any
+_PrivateAliasS: TypeAlias = Literal["I", "guess", "this", "is", "okay"]
+_PrivateAliasS2: TypeAlias = Annotated[str, "also okay"]
+
+snake_case_alias1: TypeAlias = str | int  # not PYI042 (not a stubfile)
+_snake_case_alias2: TypeAlias = Literal["whatever"]  # not PYI042 (not a stubfile)
+Snake_case_alias: TypeAlias = int | float  # not PYI042 (not a stubfile)
+
+# check that this edge case doesn't crash
+_: TypeAlias = str | int

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

@@ -0,0 +1,24 @@
+import typing
+from collections.abc import Mapping
+from typing import (
+    Annotated,
+    TypeAlias,
+    Union,
+    Literal,
+)
+
+just_literals_pipe_union: TypeAlias = (
+    Literal[True] | Literal["idk"]
+)  # PYI042, since not camel case
+PublicAliasT: TypeAlias = str | int
+PublicAliasT2: TypeAlias = Union[str, bytes]
+_ABCDEFGHIJKLMNOPQRST: TypeAlias = typing.Any
+_PrivateAliasS: TypeAlias = Literal["I", "guess", "this", "is", "okay"]
+_PrivateAliasS2: TypeAlias = Annotated[str, "also okay"]
+
+snake_case_alias1: TypeAlias = str | int  # PYI042, since not camel case
+_snake_case_alias2: TypeAlias = Literal["whatever"]  # PYI042, since not camel case
+Snake_case_alias: TypeAlias = int | float  # PYI042, since not camel case
+
+# check that this edge case doesn't crash
+_: TypeAlias = str | int

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

@@ -0,0 +1,23 @@
+import typing
+from collections.abc import Mapping
+from typing import (
+    Annotated,
+    TypeAlias,
+    Union,
+    Literal,
+)
+
+_PrivateAliasT: TypeAlias = str | int  # not PYI043 (not a stubfile)
+_PrivateAliasT2: TypeAlias = typing.Any  # not PYI043 (not a stubfile)
+_PrivateAliasT3: TypeAlias = Literal[
+    "not", "a", "chance"
+]  # not PYI043 (not a stubfile)
+just_literals_pipe_union: TypeAlias = Literal[True] | Literal["idk"]
+PublicAliasT: TypeAlias = str | int
+PublicAliasT2: TypeAlias = Union[str, bytes]
+_ABCDEFGHIJKLMNOPQRST: TypeAlias = typing.Any
+_PrivateAliasS: TypeAlias = Literal["I", "guess", "this", "is", "okay"]
+_PrivateAliasS2: TypeAlias = Annotated[str, "also okay"]
+
+# check that this edge case doesn't crash
+_: TypeAlias = str | int

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

@@ -0,0 +1,23 @@
+import typing
+from collections.abc import Mapping
+from typing import (
+    Annotated,
+    TypeAlias,
+    Union,
+    Literal,
+)
+
+_PrivateAliasT: TypeAlias = str | int  # PYI043, since this ends in a T
+_PrivateAliasT2: TypeAlias = typing.Any  # PYI043, since this ends in a T
+_PrivateAliasT3: TypeAlias = Literal[
+    "not", "a", "chance"
+]  # PYI043, since this ends in a T
+just_literals_pipe_union: TypeAlias = Literal[True] | Literal["idk"]
+PublicAliasT: TypeAlias = str | int
+PublicAliasT2: TypeAlias = Union[str, bytes]
+_ABCDEFGHIJKLMNOPQRST: TypeAlias = typing.Any
+_PrivateAliasS: TypeAlias = Literal["I", "guess", "this", "is", "okay"]
+_PrivateAliasS2: TypeAlias = Annotated[str, "also okay"]
+
+# check that this edge case doesn't crash
+_: TypeAlias = str | int

crates/ruff/resources/test/fixtures/flake8_pytest_style/PT006.py

@@ -49,3 +49,18 @@ def test_list_expressions(param1, param2):
 @pytest.mark.parametrize([some_expr, "param2"], [1, 2, 3])
 def test_list_mixed_expr_literal(param1, param2):
     ...
+
+
+@pytest.mark.parametrize(("param1, " "param2, " "param3"), [(1, 2, 3), (4, 5, 6)])
+def test_implicit_str_concat_with_parens(param1, param2, param3):
+    ...
+
+
+@pytest.mark.parametrize("param1, " "param2, " "param3", [(1, 2, 3), (4, 5, 6)])
+def test_implicit_str_concat_no_parens(param1, param2, param3):
+    ...
+
+
+@pytest.mark.parametrize((("param1, " "param2, " "param3")), [(1, 2, 3), (4, 5, 6)])
+def test_implicit_str_concat_with_multi_parens(param1, param2, param3):
+    ...

crates/ruff/resources/test/fixtures/flake8_return/RET504.py

@@ -3,7 +3,7 @@
 ###
 def x():
     a = 1
-    return a  # error
+    return a  # RET504
 
 
 # Can be refactored false positives
@@ -211,10 +211,10 @@ def nonlocal_assignment():
 def decorator() -> Flask:
     app = Flask(__name__)
 
-    @app.route('/hello')
+    @app.route("/hello")
     def hello() -> str:
         """Hello endpoint."""
-        return 'Hello, World!'
+        return "Hello, World!"
 
     return app
 
@@ -222,12 +222,13 @@ def decorator() -> Flask:
 def default():
     y = 1
 
-    def f(x = y) -> X:
+    def f(x=y) -> X:
         return x
 
     return y
 
 
+# Multiple assignment
 def get_queryset(option_1, option_2):
     queryset: Any = None
     queryset = queryset.filter(a=1)
@@ -246,4 +247,28 @@ def get_queryset():
 
 def get_queryset():
     queryset = Model.filter(a=1)
-    return queryset  # error
+    return queryset  # RET504
+
+
+# Function arguments
+def str_to_bool(val):
+    if isinstance(val, bool):
+        return val
+    val = val.strip().lower()
+    if val in ("1", "true", "yes"):
+        return True
+
+    return False
+
+
+def str_to_bool(val):
+    if isinstance(val, bool):
+        return val
+    val = 1
+    return val  # RET504
+
+
+def str_to_bool(val):
+    if isinstance(val, bool):
+        return some_obj
+    return val

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

@@ -59,3 +59,15 @@ def bar():
         return foo()
     except ValueError:
         pass
+
+def with_ellipsis():
+    try:
+        foo()
+    except ValueError:
+        ...
+
+def with_ellipsis_and_return():
+    try:
+        return foo()
+    except ValueError:
+        ...

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

@@ -0,0 +1,7 @@
+"""Case: There's a random import, so it should add `contextlib` after it."""
+import math
+
+try:
+    math.sqrt(-1)
+except ValueError:  # SIM105
+    pass

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

@@ -0,0 +1,12 @@
+"""Case: `contextlib` already imported."""
+import contextlib
+
+
+def foo():
+    pass
+
+
+try:
+    foo()
+except ValueError:
+    pass

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

@@ -42,3 +42,113 @@ if False and f() and a and g() and b:  # OK
 
 if a and False and f() and b and g():  # OK
     pass
+
+
+a or "" or True  # SIM222
+
+a or "foo" or True or "bar"  # SIM222
+
+a or 0 or True  # SIM222
+
+a or 1 or True or 2  # SIM222
+
+a or 0.0 or True  # SIM222
+
+a or 0.1 or True or 0.2  # SIM222
+
+a or [] or True  # SIM222
+
+a or list([]) or True  # SIM222
+
+a or [1] or True or [2]  # SIM222
+
+a or list([1]) or True or list([2])  # SIM222
+
+a or {} or True  # SIM222
+
+a or dict() or True  # SIM222
+
+a or {1: 1} or True or {2: 2}  # SIM222
+
+a or dict({1: 1}) or True or dict({2: 2})  # SIM222
+
+a or set() or True  # SIM222
+
+a or set(set()) or True  # SIM222
+
+a or {1} or True or {2}  # SIM222
+
+a or set({1}) or True or set({2})  # SIM222
+
+a or () or True  # SIM222
+
+a or tuple(()) or True  # SIM222
+
+a or (1,) or True or (2,)  # SIM222
+
+a or tuple((1,)) or True or tuple((2,))  # SIM222
+
+a or frozenset() or True  # SIM222
+
+a or frozenset(frozenset()) or True  # SIM222
+
+a or frozenset({1}) or True or frozenset({2})  # SIM222
+
+a or frozenset(frozenset({1})) or True or frozenset(frozenset({2}))  # SIM222
+
+
+# Inside test `a` is simplified.
+
+bool(a or [1] or True or [2])  # SIM222
+
+assert a or [1] or True or [2]  # SIM222
+
+if (a or [1] or True or [2]) and (a or [1] or True or [2]):  # SIM222
+    pass
+
+0 if a or [1] or True or [2] else 1  # SIM222
+
+while a or [1] or True or [2]:  # SIM222
+    pass
+
+[
+    0
+    for a in range(10)
+    for b in range(10)
+    if a or [1] or True or [2]  # SIM222
+    if b or [1] or True or [2]  # SIM222
+]
+
+{
+    0
+    for a in range(10)
+    for b in range(10)
+    if a or [1] or True or [2]  # SIM222
+    if b or [1] or True or [2]  # SIM222
+}
+
+{
+    0: 0
+    for a in range(10)
+    for b in range(10)
+    if a or [1] or True or [2]  # SIM222
+    if b or [1] or True or [2]  # SIM222
+}
+
+(
+    0
+    for a in range(10)
+    for b in range(10)
+    if a or [1] or True or [2]  # SIM222
+    if b or [1] or True or [2]  # SIM222
+)
+
+# Outside test `a` is not simplified.
+
+a or [1] or True or [2]  # SIM222
+
+if (a or [1] or True or [2]) == (a or [1]):  # SIM222
+    pass
+
+if f(a or [1] or True or [2]):  # SIM222
+    pass

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

@@ -37,3 +37,113 @@ if True or f() or a or g() or b:  # OK
 
 if a or True or f() or b or g():  # OK
     pass
+
+
+a and "" and False  # SIM223
+
+a and "foo" and False and "bar"  # SIM223
+
+a and 0 and False  # SIM223
+
+a and 1 and False and 2  # SIM223
+
+a and 0.0 and False  # SIM223
+
+a and 0.1 and False and 0.2  # SIM223
+
+a and [] and False  # SIM223
+
+a and list([]) and False  # SIM223
+
+a and [1] and False and [2]  # SIM223
+
+a and list([1]) and False and list([2])  # SIM223
+
+a and {} and False  # SIM223
+
+a and dict() and False  # SIM223
+
+a and {1: 1} and False and {2: 2}  # SIM223
+
+a and dict({1: 1}) and False and dict({2: 2})  # SIM223
+
+a and set() and False  # SIM223
+
+a and set(set()) and False  # SIM223
+
+a and {1} and False and {2}  # SIM223
+
+a and set({1}) and False and set({2})  # SIM223
+
+a and () and False  # SIM222
+
+a and tuple(()) and False  # SIM222
+
+a and (1,) and False and (2,)  # SIM222
+
+a and tuple((1,)) and False and tuple((2,))  # SIM222
+
+a and frozenset() and False  # SIM222
+
+a and frozenset(frozenset()) and False  # SIM222
+
+a and frozenset({1}) and False and frozenset({2})  # SIM222
+
+a and frozenset(frozenset({1})) and False and frozenset(frozenset({2}))  # SIM222
+
+
+# Inside test `a` is simplified.
+
+bool(a and [] and False and [])  # SIM223
+
+assert a and [] and False and []  # SIM223
+
+if (a and [] and False and []) or (a and [] and False and []):  # SIM223
+    pass
+
+0 if a and [] and False and [] else 1  # SIM222
+
+while a and [] and False and []:  # SIM223
+    pass
+
+[
+    0
+    for a in range(10)
+    for b in range(10)
+    if a and [] and False and []  # SIM223
+    if b and [] and False and []  # SIM223
+]
+
+{
+    0
+    for a in range(10)
+    for b in range(10)
+    if a and [] and False and []  # SIM223
+    if b and [] and False and []  # SIM223
+}
+
+{
+    0: 0
+    for a in range(10)
+    for b in range(10)
+    if a and [] and False and []  # SIM223
+    if b and [] and False and []  # SIM223
+}
+
+(
+    0
+    for a in range(10)
+    for b in range(10)
+    if a and [] and False and []  # SIM223
+    if b and [] and False and []  # SIM223
+)
+
+# Outside test `a` is not simplified.
+
+a and [] and False and []  # SIM223
+
+if (a and [] and False and []) == (a and []):  # SIM223
+    pass
+
+if f(a and [] and False and []):  # SIM223
+    pass

crates/ruff/resources/test/fixtures/flake8_tidy_imports/TID251.py

@@ -31,3 +31,6 @@ typing.TypedDict.anything()
 # import aliases are resolved
 import typing as totally_not_typing
 totally_not_typing.TypedDict
+
+# relative imports are respected
+from .typing import TypedDict

crates/ruff/resources/test/fixtures/flake8_tidy_imports/TID251_false_positives.py

@@ -1,11 +0,0 @@
-# module members cannot be imported with that syntax
-import typing.TypedDict
-
-# we don't track reassignments
-import typing, other
-typing = other
-typing.TypedDict()
-
-# yet another false positive
-def foo(typing):
-    typing.TypedDict()

crates/ruff/resources/test/fixtures/flake8_type_checking/strict.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 def f():
     # Even in strict mode, this shouldn't rase an error, since `pkg` is used at runtime,
     # and implicitly imports `pkg.bar`.

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

@@ -22,3 +22,6 @@ from bar import (
      a, # comment 7
      b, # comment 8
 )
+
+# comment 9
+from baz import *  # comment 10

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

@@ -0,0 +1,4 @@
+from mypackage.subpackage import (  # long comment that seems to be a problem
+    a_long_variable_name_that_causes_problems,
+    items,
+)

crates/ruff/resources/test/fixtures/isort/required_imports/docstring.pyi

@@ -0,0 +1,3 @@
+"""Hello, world!"""
+
+x = 1

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

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

crates/ruff/resources/test/fixtures/pep8_naming/N802.py

@@ -39,3 +39,11 @@ class Test(unittest.TestCase):
 
     def testTest(self):
         assert True
+
+
+from typing import override
+
+
+@override
+def BAD_FUNC():
+    pass

crates/ruff/resources/test/fixtures/pep8_naming/N815.py

@@ -13,3 +13,11 @@ class C:
     myObj2 = namedtuple("MyObj2", ["a", "b"])
     Employee = NamedTuple('Employee', [('name', str), ('id', int)])
     Point2D = TypedDict('Point2D', {'in': int, 'x-y': int})
+
+
+class D(TypedDict):
+    lower: int
+    CONSTANT: str
+    mixedCase: bool
+    _mixedCase: list
+    mixed_Case: set

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

@@ -4,11 +4,11 @@ if not X is Y:
 #: E714
 if not X.B is Y:
     pass
-#: E714
+
+#: Okay
 if not X is Y is not Z:
     pass
 
-#: Okay
 if not X is not Y:
     pass
 

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

@@ -13,6 +13,7 @@ f = lambda: (yield from g())
 class F:
     f = lambda x: 2 * x
 
+
 f = object()
 f.method = lambda: "Method"
 f = {}
@@ -21,3 +22,30 @@ f = []
 f.append(lambda x: x**2)
 f = g = lambda x: x**2
 lambda: "no-op"
+
+# Annotated
+from typing import Callable, ParamSpec
+
+P = ParamSpec("P")
+
+# ParamSpec cannot be used in this context, so do not preserve the annotation.
+f: Callable[P, int] = lambda *args: len(args)
+f: Callable[[], None] = lambda: None
+f: Callable[..., None] = lambda a, b: None
+f: Callable[[int], int] = lambda x: 2 * x
+
+# Let's use the `Callable` type from `collections.abc` instead.
+from collections.abc import Callable
+
+f: Callable[[str, int], str] = lambda a, b: a * b
+f: Callable[[str, int], tuple[str, int]] = lambda a, b: (a, b)
+f: Callable[[str, int, list[str]], list[str]] = lambda a, b, /, c: [*c, a * b]
+
+
+# Override `Callable`
+class Callable:
+    pass
+
+
+# Do not copy the annotation from here on out.
+f: Callable[[str, int], str] = lambda a, b: a * b

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

@@ -97,10 +97,10 @@ if length > options.max_line_length:
 if os.path.exists(os.path.join(path, PEP8_BIN)):
 	cmd = ([os.path.join(path, PEP8_BIN)] +
 	       self._pep8_options(targetfile))
-#: W191
+#: W191 - okay
 '''
 	multiline string with tab in it'''
-#: E101 W191
+#: E101 (W191 okay)
 '''multiline string
 	with tabs
    and spaces
@@ -142,4 +142,10 @@ def test_keys(self):
 x = [
 	'abc'
 ]
-#:
+#: W191 - okay
+'''	multiline string with tab in it, same lines'''
+"""	here we're using '''different delimiters'''"""
+'''
+	multiline string with tab in it, different lines
+'''
+"	single line string with tab in it"

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

@@ -9,6 +9,9 @@ def f():
 
     # Here's a standalone comment that's over the limit.
 
+    x = 2
+    # Another standalone that is preceded by a newline and indent toke and is over the limit.
+
     print("Here's a string that's over the limit, but it's not a docstring.")
 
 

crates/ruff/resources/test/fixtures/pydocstyle/D214_module.py

@@ -0,0 +1,21 @@
+"""A module docstring with D214 violations
+
+    Returns
+-----
+    valid returns
+
+    Args
+-----
+    valid args
+"""
+
+import os
+from .expected import Expectation
+
+expectation = Expectation()
+expect = expectation.expect
+
+expect(os.path.normcase(__file__ if __file__[-1] != 'c' else __file__[:-1]),
+       "D214: Section is over-indented ('Returns')")
+expect(os.path.normcase(__file__ if __file__[-1] != 'c' else __file__[:-1]),
+       "D214: Section is over-indented ('Args')")

crates/ruff/resources/test/fixtures/pydocstyle/D417.py

@@ -115,6 +115,20 @@ def f(x, *args, **kwargs):
     return x
 
 
+def f(x, *, y, z):
+    """Do something.
+
+    Args:
+        x: some first value
+
+    Keyword Args:
+        y (int): the other value
+        z (int): the last value
+
+    """
+    return x, y, z
+
+
 class Test:
     def f(self, /, arg1: int) -> None:
         """

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

@@ -11,3 +11,9 @@
 "{}".format(1, 2, 3)  # F523
 "{:{}}".format(1, 2)  # No issues
 "{:{}}".format(1, 2, 3)  # F523
+
+# With *args
+"{0}{1}".format(*args)  # No issues
+"{0}{1}".format(1, *args)  # No issues
+"{0}{1}".format(1, 2, *args)  # No issues
+"{0}{1}".format(1, 2, 3, *args)  # F523

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

@@ -0,0 +1,13 @@
+def redef(value):
+    match value:
+        case True:
+
+            def fun(x, y):
+                return x
+
+        case False:
+
+            def fun(x, y):
+                return y
+
+    return fun

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

@@ -132,3 +132,8 @@ def in_ipython_notebook() -> bool:
     except NameError:
         return False  # not in notebook
     return True
+
+
+def named_expr():
+    if any((key := (value := x)) for x in ["ok"]):
+        print(key)

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

@@ -121,3 +121,8 @@ def f(x: int):
             print("A")
         case y:
             pass
+
+
+def f():
+    if any((key := (value := x)) for x in ["ok"]):
+        print(key)

crates/ruff/resources/test/fixtures/pygrep-hooks/PGH003_0.py

@@ -1,11 +1,16 @@
 x = 1  # type: ignore
-x = 1  # type ignore
 x = 1  # type:ignore
+x = 1  # type: ignore[attr-defined]  # type: ignore
 
 x = 1
+x = 1  # type ignore
 x = 1  # type ignore  # noqa
 x = 1  # type: ignore[attr-defined]
 x = 1  # type: ignore[attr-defined, name-defined]
+x = 1  # type: ignore[attr-defined]  # type: ignore[type-mismatch]
 x = 1  # type: ignore[type-mismatch]  # noqa
+x = 1  # type: ignore [attr-defined]
+x = 1  # type: ignore [attr-defined, name-defined]
+x = 1  # type: ignore [type-mismatch]  # noqa
 x = 1  # type: Union[int, str]
 x = 1  # type: ignoreme

crates/ruff/resources/test/fixtures/pygrep-hooks/PGH003_1.py

@@ -0,0 +1,16 @@
+x = 1  # pyright: ignore
+x = 1  # pyright:ignore
+x = 1  # pyright: ignore[attr-defined]  # pyright: ignore
+
+x = 1
+x = 1  # pyright ignore
+x = 1  # pyright ignore  # noqa
+x = 1  # pyright: ignore[attr-defined]
+x = 1  # pyright: ignore[attr-defined, name-defined]
+x = 1  # pyright: ignore[attr-defined]  # pyright: ignore[type-mismatch]
+x = 1  # pyright: ignore[type-mismatch]  # noqa
+x = 1  # pyright: ignore [attr-defined]
+x = 1  # pyright: ignore [attr-defined, name-defined]
+x = 1  # pyright: ignore [type-mismatch]  # noqa
+x = 1  # pyright: Union[int, str]
+x = 1  # pyright: ignoreme

crates/ruff/resources/test/fixtures/pylint/import_self/module.py

@@ -0,0 +1,3 @@
+import import_self.module
+from import_self import module
+from . import module

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

@@ -0,0 +1,21 @@
+min(1, 2, 3)
+min(1, min(2, 3))
+min(1, min(2, min(3, 4)))
+min(1, foo("a", "b"), min(3, 4))
+min(1, max(2, 3))
+max(1, 2, 3)
+max(1, max(2, 3))
+max(1, max(2, max(3, 4)))
+max(1, foo("a", "b"), max(3, 4))
+
+# These should not trigger; we do not flag cases with keyword args.
+min(1, min(2, 3), key=test)
+min(1, min(2, 3, key=test))
+# This will still trigger, to merge the calls without keyword args.
+min(1, min(2, 3, key=test), min(4, 5))
+
+# Don't provide a fix if there are comments within the call.
+min(
+    1,  # This is a comment.
+    min(2, 3),
+)

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

@@ -1,3 +1,6 @@
+import typing
+from typing import cast
+
 # For -> for, variable reused
 for i in []:
     for i in []:  # error
@@ -43,6 +46,9 @@ for i in []:
 
 # For -> assignment
 for i in []:
+    # ignore typing cast
+    i = cast(int, i)
+    i = typing.cast(int, i)
     i = 5  # error
 
 # For -> augmented assignment
@@ -53,6 +59,10 @@ for i in []:
 for i in []:
     i: int = 5  # error
 
+# For -> annotated assignment without value
+for i in []:
+    i: int  # no error
+
 # Async for -> for, variable reused
 async for i in []:
     for i in []:  # error

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

@@ -0,0 +1,5 @@
+def main():
+    exit(0)
+
+
+import functools

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

@@ -0,0 +1,5 @@
+from sys import argv
+
+
+def main():
+    exit(0)

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

@@ -0,0 +1,5 @@
+def main():
+    exit(0)
+
+
+from sys import argv

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

@@ -0,0 +1,51 @@
+class TestClass:
+    def __bool__(self):
+        ...
+    
+    def __bool__(self, x):  # too many mandatory args
+        ...
+    
+    def __bool__(self, x=1):  # additional optional args OK
+        ...
+    
+    def __bool__(self, *args):  # varargs OK
+        ...
+    
+    def __bool__():  # ignored; should be caughty by E0211/N805
+        ...
+    
+    @staticmethod
+    def __bool__():
+        ...
+
+    @staticmethod
+    def __bool__(x):  # too many mandatory args
+        ...
+    
+    @staticmethod
+    def __bool__(x=1):  # additional optional args OK
+        ...
+    
+    def __eq__(self, other):  # multiple args
+        ...
+    
+    def __eq__(self, other=1):  # expected arg is optional
+        ...
+    
+    def __eq__(self):  # too few mandatory args
+        ...
+    
+    def __eq__(self, other, other_other):  # too many mandatory args
+        ...
+    
+    def __round__(self):  # allow zero additional args.
+        ...
+    
+    def __round__(self, x):  # allow one additional args.
+        ...
+    
+    def __round__(self, x, y):  # disallow 2 args
+        ...
+    
+    def __round__(self, x, y, z=2):  # disallow 3 args even when one is optional
+        ...

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

@@ -83,3 +83,26 @@ print('Hello %s (%s)' % bar['bop'])
 print('Hello %(arg)s' % bar)
 print('Hello %(arg)s' % bar.baz)
 print('Hello %(arg)s' % bar['bop'])
+
+# Hanging modulos
+(
+    "foo %s "
+    "bar %s"
+) % (x, y)
+
+(
+    "foo %(foo)s "
+    "bar %(bar)s"
+) % {"foo": x, "bar": y}
+
+(
+    """foo %s"""
+    % (x,)
+)
+
+(
+    """
+    foo %s
+    """
+    % (x,)
+)

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

@@ -34,28 +34,6 @@ pytest.param('"%8s" % (None,)', id="unsafe width-string conversion"),
 "%(and)s" % {"and": 2}
 
 # OK (arguably false negatives)
-(
-    "foo %s "
-    "bar %s"
-) % (x, y)
-
-(
-    "foo %(foo)s "
-    "bar %(bar)s"
-) % {"foo": x, "bar": y}
-
-(
-    """foo %s"""
-    % (x,)
-)
-
-(
-    """
-    foo %s
-    """
-    % (x,)
-)
-
 'Hello %s' % bar
 
 'Hello %s' % bar.baz

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

@@ -46,6 +46,14 @@ print("foo {} ".format(x))
 
 '({}={{0!e}})'.format(a)
 
+"{[b]}".format(a)
+
+'{[b]}'.format(a)
+
+"""{[b]}""".format(a)
+
+'''{[b]}'''.format(a)
+
 ###
 # Non-errors
 ###

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

@@ -0,0 +1,27 @@
+import typing
+from dataclasses import dataclass, field
+from typing import ClassVar, Sequence
+
+KNOWINGLY_MUTABLE_DEFAULT = []
+
+
+@dataclass()
+class A:
+    mutable_default: list[int] = []
+    immutable_annotation: typing.Sequence[int] = []
+    without_annotation = []
+    ignored_via_comment: list[int] = []  # noqa: RUF008
+    correct_code: list[int] = KNOWINGLY_MUTABLE_DEFAULT
+    perfectly_fine: list[int] = field(default_factory=list)
+    class_variable: typing.ClassVar[list[int]] = []
+
+
+@dataclass
+class B:
+    mutable_default: list[int] = []
+    immutable_annotation: Sequence[int] = []
+    without_annotation = []
+    ignored_via_comment: list[int] = []  # noqa: RUF008
+    correct_code: list[int] = KNOWINGLY_MUTABLE_DEFAULT
+    perfectly_fine: list[int] = field(default_factory=list)
+    class_variable: ClassVar[list[int]] = []

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

@@ -0,0 +1,42 @@
+import datetime
+import re
+import typing
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import ClassVar, NamedTuple
+
+
+def default_function() -> list[int]:
+    return []
+
+
+class ImmutableType(NamedTuple):
+    something: int = 8
+
+
+@dataclass()
+class A:
+    hidden_mutable_default: list[int] = default_function()
+    class_variable: typing.ClassVar[list[int]] = default_function()
+    another_class_var: ClassVar[list[int]] = default_function()
+
+    fine_path: Path = Path()
+    fine_date: datetime.date = datetime.date(2042, 1, 1)
+    fine_timedelta: datetime.timedelta = datetime.timedelta(hours=7)
+    fine_tuple: tuple[int] = tuple([1])
+    fine_regex: re.Pattern = re.compile(r".*")
+
+
+DEFAULT_IMMUTABLETYPE_FOR_ALL_DATACLASSES = ImmutableType(40)
+DEFAULT_A_FOR_ALL_DATACLASSES = A([1, 2, 3])
+
+
+@dataclass
+class B:
+    hidden_mutable_default: list[int] = default_function()
+    another_dataclass: A = A()
+    not_optimal: ImmutableType = ImmutableType(20)
+    good_variant: ImmutableType = DEFAULT_IMMUTABLETYPE_FOR_ALL_DATACLASSES
+    okay_variant: A = DEFAULT_A_FOR_ALL_DATACLASSES
+
+    fine_dataclass_function: list[int] = field(default_factory=list)

crates/ruff/src/autofix/actions.rs

@@ -4,12 +4,12 @@ use itertools::Itertools;
 use libcst_native::{
     Codegen, CodegenState, ImportNames, ParenthesizableWhitespace, SmallStatement, Statement,
 };
-use rustpython_parser::ast::{ExcepthandlerKind, Expr, Keyword, Location, Stmt, StmtKind};
+use ruff_text_size::{TextLen, TextRange, TextSize};
+use rustpython_parser::ast::{ExcepthandlerKind, Expr, Keyword, Stmt, StmtKind};
 use rustpython_parser::{lexer, Mode, Tok};
 
 use ruff_diagnostics::Edit;
 use ruff_python_ast::helpers;
-use ruff_python_ast::helpers::to_absolute;
 use ruff_python_ast::imports::{AnyImport, Import};
 use ruff_python_ast::newlines::NewlineWithTrailingNewline;
 use ruff_python_ast::source_code::{Indexer, Locator, Stylist};
@@ -102,20 +102,17 @@ fn is_lone_child(child: &Stmt, parent: &Stmt, deleted: &[&Stmt]) -> Result<bool>
 
 /// Return the location of a trailing semicolon following a `Stmt`, if it's part
 /// of a multi-statement line.
-fn trailing_semicolon(stmt: &Stmt, locator: &Locator) -> Option<Location> {
-    let contents = locator.skip(stmt.end_location.unwrap());
-    for (row, line) in NewlineWithTrailingNewline::from(contents).enumerate() {
-        let trimmed = line.trim();
+fn trailing_semicolon(stmt: &Stmt, locator: &Locator) -> Option<TextSize> {
+    let contents = locator.after(stmt.end());
+
+    for line in NewlineWithTrailingNewline::from(contents) {
+        let trimmed = line.trim_start();
+
         if trimmed.starts_with(';') {
-            let column = line
-                .char_indices()
-                .find_map(|(column, char)| if char == ';' { Some(column) } else { None })
-                .unwrap();
-            return Some(to_absolute(
-                Location::new(row + 1, column),
-                stmt.end_location.unwrap(),
-            ));
+            let colon_offset = line.text_len() - trimmed.text_len();
+            return Some(stmt.end() + line.start() + colon_offset);
         }
+
         if !trimmed.starts_with('\\') {
             break;
         }
@@ -124,42 +121,36 @@ fn trailing_semicolon(stmt: &Stmt, locator: &Locator) -> Option<Location> {
 }
 
 /// Find the next valid break for a `Stmt` after a semicolon.
-fn next_stmt_break(semicolon: Location, locator: &Locator) -> Location {
-    let start_location = Location::new(semicolon.row(), semicolon.column() + 1);
-    let contents = locator.skip(start_location);
-    for (row, line) in NewlineWithTrailingNewline::from(contents).enumerate() {
+fn next_stmt_break(semicolon: TextSize, locator: &Locator) -> TextSize {
+    let start_location = semicolon + TextSize::from(1);
+
+    let contents = &locator.contents()[usize::from(start_location)..];
+    for line in NewlineWithTrailingNewline::from(contents) {
         let trimmed = line.trim();
         // Skip past any continuations.
         if trimmed.starts_with('\\') {
             continue;
         }
-        return if trimmed.is_empty() {
-            // If the line is empty, then despite the previous statement ending in a
-            // semicolon, we know that it's not a multi-statement line.
-            to_absolute(Location::new(row + 1, 0), start_location)
-        } else {
-            // Otherwise, find the start of the next statement. (Or, anything that isn't
-            // whitespace.)
-            let column = line
-                .char_indices()
-                .find_map(|(column, char)| {
-                    if char.is_whitespace() {
-                        None
-                    } else {
-                        Some(column)
-                    }
-                })
-                .unwrap();
-            to_absolute(Location::new(row + 1, column), start_location)
-        };
+
+        return start_location
+            + if trimmed.is_empty() {
+                // If the line is empty, then despite the previous statement ending in a
+                // semicolon, we know that it's not a multi-statement line.
+                line.start()
+            } else {
+                // Otherwise, find the start of the next statement. (Or, anything that isn't
+                // whitespace.)
+                let relative_offset = line.find(|c: char| !c.is_whitespace()).unwrap();
+                line.start() + TextSize::try_from(relative_offset).unwrap()
+            };
     }
-    Location::new(start_location.row() + 1, 0)
+
+    locator.line_end(start_location)
 }
 
 /// Return `true` if a `Stmt` occurs at the end of a file.
 fn is_end_of_file(stmt: &Stmt, locator: &Locator) -> bool {
-    let contents = locator.skip(stmt.end_location.unwrap());
-    contents.is_empty()
+    stmt.end() == locator.contents().text_len()
 }
 
 /// Return the `Fix` to use when deleting a `Stmt`.
@@ -190,33 +181,23 @@ pub fn delete_stmt(
     {
         // If removing this node would lead to an invalid syntax tree, replace
         // it with a `pass`.
-        Ok(Edit::replacement(
-            "pass".to_string(),
-            stmt.location,
-            stmt.end_location.unwrap(),
-        ))
+        Ok(Edit::range_replacement("pass".to_string(), stmt.range()))
     } else {
         Ok(if let Some(semicolon) = trailing_semicolon(stmt, locator) {
             let next = next_stmt_break(semicolon, locator);
-            Edit::deletion(stmt.location, next)
-        } else if helpers::match_leading_content(stmt, locator) {
-            Edit::deletion(stmt.location, stmt.end_location.unwrap())
-        } else if helpers::preceded_by_continuation(stmt, indexer) {
-            if is_end_of_file(stmt, locator) && stmt.location.column() == 0 {
+            Edit::deletion(stmt.start(), next)
+        } else if helpers::has_leading_content(stmt, locator) {
+            Edit::range_deletion(stmt.range())
+        } else if helpers::preceded_by_continuation(stmt, indexer, locator) {
+            if is_end_of_file(stmt, locator) && locator.is_at_start_of_line(stmt.start()) {
                 // Special-case: a file can't end in a continuation.
-                Edit::replacement(
-                    stylist.line_ending().to_string(),
-                    stmt.location,
-                    stmt.end_location.unwrap(),
-                )
+                Edit::range_replacement(stylist.line_ending().to_string(), stmt.range())
             } else {
-                Edit::deletion(stmt.location, stmt.end_location.unwrap())
+                Edit::range_deletion(stmt.range())
             }
         } else {
-            Edit::deletion(
-                Location::new(stmt.location.row(), 0),
-                Location::new(stmt.end_location.unwrap().row() + 1, 0),
-            )
+            let range = locator.full_lines_range(stmt.range());
+            Edit::range_deletion(range)
         })
     }
 }
@@ -231,7 +212,7 @@ pub fn remove_unused_imports<'a>(
     indexer: &Indexer,
     stylist: &Stylist,
 ) -> Result<Edit> {
-    let module_text = locator.slice(stmt);
+    let module_text = locator.slice(stmt.range());
     let mut tree = match_module(module_text)?;
 
     let Some(Statement::Simple(body)) = tree.body.first_mut() else {
@@ -337,11 +318,7 @@ pub fn remove_unused_imports<'a>(
         };
         tree.codegen(&mut state);
 
-        Ok(Edit::replacement(
-            state.to_string(),
-            stmt.location,
-            stmt.end_location.unwrap(),
-        ))
+        Ok(Edit::range_replacement(state.to_string(), stmt.range()))
     }
 }
 
@@ -353,15 +330,14 @@ pub fn remove_unused_imports<'a>(
 /// For this behavior, set `remove_parentheses` to `true`.
 pub fn remove_argument(
     locator: &Locator,
-    call_at: Location,
-    expr_at: Location,
-    expr_end: Location,
+    call_at: TextSize,
+    expr_range: TextRange,
     args: &[Expr],
     keywords: &[Keyword],
     remove_parentheses: bool,
 ) -> Result<Edit> {
     // TODO(sbrugman): Preserve trailing comments.
-    let contents = locator.skip(call_at);
+    let contents = locator.after(call_at);
 
     let mut fix_start = None;
     let mut fix_end = None;
@@ -374,13 +350,13 @@ pub fn remove_argument(
     if n_arguments == 1 {
         // Case 1: there is only one argument.
         let mut count: usize = 0;
-        for (start, tok, end) in lexer::lex_located(contents, Mode::Module, call_at).flatten() {
+        for (tok, range) in lexer::lex_located(contents, Mode::Module, call_at).flatten() {
             if matches!(tok, Tok::Lpar) {
                 if count == 0 {
                     fix_start = Some(if remove_parentheses {
-                        start
+                        range.start()
                     } else {
-                        Location::new(start.row(), start.column() + 1)
+                        range.start() + TextSize::from(1)
                     });
                 }
                 count += 1;
@@ -390,9 +366,9 @@ pub fn remove_argument(
                 count -= 1;
                 if count == 0 {
                     fix_end = Some(if remove_parentheses {
-                        end
+                        range.end()
                     } else {
-                        Location::new(end.row(), end.column() - 1)
+                        range.end() - TextSize::from(1)
                     });
                     break;
                 }
@@ -400,27 +376,27 @@ pub fn remove_argument(
         }
     } else if args
         .iter()
-        .map(|node| node.location)
-        .chain(keywords.iter().map(|node| node.location))
-        .any(|location| location > expr_at)
+        .map(Expr::start)
+        .chain(keywords.iter().map(Keyword::start))
+        .any(|location| location > expr_range.start())
     {
         // Case 2: argument or keyword is _not_ the last node.
         let mut seen_comma = false;
-        for (start, tok, end) in lexer::lex_located(contents, Mode::Module, call_at).flatten() {
+        for (tok, range) in lexer::lex_located(contents, Mode::Module, call_at).flatten() {
             if seen_comma {
                 if matches!(tok, Tok::NonLogicalNewline) {
                     // Also delete any non-logical newlines after the comma.
                     continue;
                 }
                 fix_end = Some(if matches!(tok, Tok::Newline) {
-                    end
+                    range.end()
                 } else {
-                    start
+                    range.start()
                 });
                 break;
             }
-            if start == expr_at {
-                fix_start = Some(start);
+            if range.start() == expr_range.start() {
+                fix_start = Some(range.start());
             }
             if fix_start.is_some() && matches!(tok, Tok::Comma) {
                 seen_comma = true;
@@ -429,13 +405,13 @@ pub fn remove_argument(
     } else {
         // Case 3: argument or keyword is the last node, so we have to find the last
         // comma in the stmt.
-        for (start, tok, _) in lexer::lex_located(contents, Mode::Module, call_at).flatten() {
-            if start == expr_at {
-                fix_end = Some(expr_end);
+        for (tok, range) in lexer::lex_located(contents, Mode::Module, call_at).flatten() {
+            if range.start() == expr_range.start() {
+                fix_end = Some(expr_range.end());
                 break;
             }
             if matches!(tok, Tok::Comma) {
-                fix_start = Some(start);
+                fix_start = Some(range.start());
             }
         }
     }
@@ -459,6 +435,7 @@ pub fn remove_argument(
 pub fn get_or_import_symbol(
     module: &str,
     member: &str,
+    at: TextSize,
     context: &Context,
     importer: &Importer,
     locator: &Locator,
@@ -482,14 +459,11 @@ pub fn get_or_import_symbol(
         //
         // By adding this no-op edit, we force the `unused-imports` fix to conflict with the
         // `sys-exit-alias` fix, and thus will avoid applying both fixes in the same pass.
-        let import_edit = Edit::replacement(
-            locator.slice(source).to_string(),
-            source.location,
-            source.end_location.unwrap(),
-        );
+        let import_edit =
+            Edit::range_replacement(locator.slice(source.range()).to_string(), source.range());
         Ok((import_edit, binding))
     } else {
-        if let Some(stmt) = importer.get_import_from(module) {
+        if let Some(stmt) = importer.find_import_from(module, at) {
             // Case 1: `from functools import lru_cache` is in scope, and we're trying to reference
             // `functools.cache`; thus, we add `cache` to the import, and return `"cache"` as the
             // bound name.
@@ -512,7 +486,8 @@ pub fn get_or_import_symbol(
                 .find_binding(module)
                 .map_or(true, |binding| binding.kind.is_builtin())
             {
-                let import_edit = importer.add_import(&AnyImport::Import(Import::module(module)));
+                let import_edit =
+                    importer.add_import(&AnyImport::Import(Import::module(module)), at);
                 Ok((import_edit, format!("{module}.{member}")))
             } else {
                 bail!(
@@ -527,8 +502,8 @@ pub fn get_or_import_symbol(
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
+    use ruff_text_size::TextSize;
     use rustpython_parser as parser;
-    use rustpython_parser::ast::Location;
 
     use ruff_python_ast::source_code::Locator;
 
@@ -546,19 +521,13 @@ mod tests {
         let program = parser::parse_program(contents, "<filename>")?;
         let stmt = program.first().unwrap();
         let locator = Locator::new(contents);
-        assert_eq!(
-            trailing_semicolon(stmt, &locator),
-            Some(Location::new(1, 5))
-        );
+        assert_eq!(trailing_semicolon(stmt, &locator), Some(TextSize::from(5)));
 
         let contents = "x = 1 ; y = 1";
         let program = parser::parse_program(contents, "<filename>")?;
         let stmt = program.first().unwrap();
         let locator = Locator::new(contents);
-        assert_eq!(
-            trailing_semicolon(stmt, &locator),
-            Some(Location::new(1, 6))
-        );
+        assert_eq!(trailing_semicolon(stmt, &locator), Some(TextSize::from(6)));
 
         let contents = r#"
 x = 1 \
@@ -568,10 +537,7 @@ x = 1 \
         let program = parser::parse_program(contents, "<filename>")?;
         let stmt = program.first().unwrap();
         let locator = Locator::new(contents);
-        assert_eq!(
-            trailing_semicolon(stmt, &locator),
-            Some(Location::new(2, 2))
-        );
+        assert_eq!(trailing_semicolon(stmt, &locator), Some(TextSize::from(10)));
 
         Ok(())
     }
@@ -581,15 +547,15 @@ x = 1 \
         let contents = "x = 1; y = 1";
         let locator = Locator::new(contents);
         assert_eq!(
-            next_stmt_break(Location::new(1, 4), &locator),
-            Location::new(1, 5)
+            next_stmt_break(TextSize::from(4), &locator),
+            TextSize::from(5)
         );
 
         let contents = "x = 1 ; y = 1";
         let locator = Locator::new(contents);
         assert_eq!(
-            next_stmt_break(Location::new(1, 5), &locator),
-            Location::new(1, 6)
+            next_stmt_break(TextSize::from(5), &locator),
+            TextSize::from(6)
         );
 
         let contents = r#"
@@ -599,8 +565,8 @@ x = 1 \
         .trim();
         let locator = Locator::new(contents);
         assert_eq!(
-            next_stmt_break(Location::new(2, 2), &locator),
-            Location::new(2, 4)
+            next_stmt_break(TextSize::from(10), &locator),
+            TextSize::from(12)
         );
     }
 }