Bump version to 0.0.70

.editorconfig

@@ -0,0 +1,14 @@
+# Check http://editorconfig.org for more information
+# This is the main config file for this project:
+root = true
+
+[*]
+charset = utf-8
+trim_trailing_whitespace = true
+end_of_line = lf
+indent_style = space
+insert_final_newline = true
+indent_size = 2
+
+[*.{rs,py}]
+indent_size = 4

.github/workflows/release.yaml

@@ -16,7 +16,7 @@ env:
   PYTHON_VERSION: "3.7" # to build abi3 wheels
 
 jobs:
-  macos:
+  macos-x86_64:
     runs-on: macos-latest
     steps:
       - uses: actions/checkout@v3
@@ -39,6 +39,25 @@ jobs:
       - 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:
@@ -261,7 +280,8 @@ jobs:
     name: Release
     runs-on: ubuntu-latest
     needs:
-      - macos
+      - macos-universal
+      - macos-x86_64
       - windows
       - linux
       - linux-cross

.pre-commit-config.yaml

@@ -1,5 +1,10 @@
 repos:
-  - repo: https://github.com/charliermarsh/ruff
-    rev: v0.0.33
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.0.40
     hooks:
       - id: lint
+
+  - repo: https://github.com/abravalheri/validate-pyproject
+    rev: v0.10.1
+    hooks:
+      - id: validate-pyproject

.pre-commit-hooks.yaml

@@ -1,7 +0,0 @@
-- id: lint
-  name: ruff lint
-  description: Run ruff to lint Python files.
-  entry: ruff
-  language: python
-  types_or: [python]
-  pass_filenames: true

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+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
+
+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
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+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
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+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
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+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).
+
+[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

@@ -0,0 +1,111 @@
+# Contributing to ruff
+
+Welcome! We're happy to have you here. Thank you in advance for your contribution to ruff.
+
+## 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 submitting an [Issue](https://github.com/charliermarsh/ruff/issues) outlining
+your proposed change.
+
+### Prerequisites
+
+ruff is written in Rust (1.63.0). You'll need to install the
+[Rust toolchain](https://www.rust-lang.org/tools/install) for development.
+
+You'll also need [Insta](https://insta.rs/docs/) to update snapshot tests:
+
+```shell
+cargo install cargo-insta
+```
+
+### Development
+
+After cloning the repository, run ruff locally with:
+
+```shell
+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:
+
+```shell
+cargo fmt     # Auto-formatting...
+cargo clippy  # Linting...
+cargo test    # Testing...
+```
+
+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.
+
+Your Pull Request will be reviewed by a maintainer, which may involve a few rounds of iteration
+prior to merging.
+
+### Example: Adding a new lint rule
+
+There are three phases to adding a new lint rule:
+
+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)
+   or `src/check_lines.rs` (for text-based checks).
+3. Add a test fixture.
+
+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.
+
+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. Grep for the `Check::new` invocations to understand how other,
+similar rules are implemented.
+
+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`. Once you're satisfied with the output,
+codify the behavior as a snapshot test by adding a new function to the `mod tests` section of
+`src/linter.rs`, like so:
+
+```rust
+#[test]
+fn e402() -> Result<()> {
+    let mut checks = check_path(
+        Path::new("./resources/test/fixtures/E402.py"),
+        &settings::Settings::for_rule(CheckCode::E402),
+        &fixer::Mode::Generate,
+    )?;
+    checks.sort_by_key(|check| check.location);
+    insta::assert_yaml_snapshot!(checks);
+    Ok(())
+}
+```
+
+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.
+
+### Example: Adding a new configuration option
+
+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.
+
+Ultimately, these two sources of configuration are merged into the `Settings` struct defined
+in `src/settings.rs`, which is then threaded through the codebase.
+
+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., `_`).
+
+## 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
+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).

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.33"
+version = "0.0.70"
 edition = "2021"
 
 [lib]
@@ -11,7 +11,7 @@ anyhow = { version = "1.0.60" }
 bincode = { version = "1.3.3" }
 cacache = { version = "10.0.1" }
 chrono = { version = "0.4.21" }
-clap = { version = "3.2.16", features = ["derive"] }
+clap = { version = "4.0.1", features = ["derive"] }
 clearscreen = { version = "1.0.10" }
 colored = { version = "2.0.0" }
 common-path = { version = "1.0.0" }
@@ -19,19 +19,29 @@ dirs = { version = "4.0.0" }
 fern = { version = "0.6.1" }
 filetime = { version = "0.2.17" }
 glob = { version = "0.3.0" }
-itertools = "0.10.3"
-lazy_static = "1.4.0"
+itertools = { version = "0.10.5" }
+libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "32a044c127668df44582f85699358e67803b0d73" }
 log = { version = "0.4.17" }
 notify = { version = "4.0.17" }
 once_cell = { version = "1.13.1" }
+path-absolutize = { version = "3.0.13", features = ["once_cell_cache"] }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "7d21c6923a506e79cc041708d83cef925efd33f4" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
+rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
 serde = { version = "1.0.143", features = ["derive"] }
 serde_json = { version = "1.0.83" }
 toml = { version = "0.5.9" }
 update-informer = { version = "0.5.0", default_features = false, features = ["pypi"], optional = true }
 walkdir = { version = "2.3.2" }
+strum = { version = "0.24.1", features = ["strum_macros"] }
+strum_macros = "0.24.3"
+num-bigint = "0.4.3"
+
+[dev-dependencies]
+assert_cmd = "2.0.4"
+insta = { version = "1.19.1", features = ["yaml"] }
 
 [features]
 default = ["update-informer"]
@@ -42,3 +52,9 @@ panic = "abort"
 lto = "thin"
 codegen-units = 1
 opt-level = 3
+
+[profile.dev.package.insta]
+opt-level = 3
+
+[profile.dev.package.similar]
+opt-level = 3

README.md

@@ -1,7 +1,9 @@
 # ruff
 
+[![image](https://img.shields.io/pypi/v/ruff.svg)](https://pypi.python.org/pypi/ruff)
+[![image](https://img.shields.io/pypi/l/ruff.svg)](https://pypi.python.org/pypi/ruff)
+[![image](https://img.shields.io/pypi/pyversions/ruff.svg)](https://pypi.python.org/pypi/ruff)
 [![Actions status](https://github.com/charliermarsh/ruff/workflows/CI/badge.svg)](https://github.com/charliermarsh/ruff/actions)
-[![PyPI version](https://badge.fury.io/py/ruff.svg)](https://badge.fury.io/py/ruff)
 
 An extremely fast Python linter, written in Rust.
 
@@ -18,11 +20,9 @@ An extremely fast Python linter, written in Rust.
 - 🤝 Python 3.10 compatibility
 - 🛠️ `pyproject.toml` support
 - 📦 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#caching)-inspired cache support
-- 🔧 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#caching)-inspired `--fix` support
+- 🔧 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix)-inspired `--fix` support
 - 👀 [TypeScript](https://www.typescriptlang.org/docs/handbook/configuring-watch.html)-inspired `--watch` support
-
-_ruff is a proof-of-concept and not yet intended for production use. It supports only a small subset
-of the Flake8 rules, and may crash on your codebase._
+- ⚖️ [Near-complete parity](#Parity-with-Flake8) with the built-in Flake8 rule set
 
 Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).
 
@@ -52,14 +52,14 @@ You can run ruff in `--watch` mode to automatically re-run on-change:
 ruff path/to/code/ --watch
 ```
 
-ruff also works with [Pre-Commit](https://pre-commit.com) (requires Cargo on system):
+ruff also works with [pre-commit](https://pre-commit.com):
 
 ```yaml
 repos:
-- repo: https://github.com/charliermarsh/ruff
-  rev: v0.0.33
-  hooks:
-    - id: lint
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.0.70
+    hooks:
+      - id: lint
 ```
 
 ## Configuration
@@ -80,100 +80,295 @@ select = [
 Alternatively, on the command-line:
 
 ```shell
-ruff path/to/code/ --select F401 F403
+ruff path/to/code/ --select F401 --select F403
 ```
 
 See `ruff --help` for more:
 
 ```shell
-ruff (v0.0.33)
-An extremely fast Python linter.
+ruff: An extremely fast Python linter.
 
-USAGE:
-    ruff [OPTIONS] <FILES>...
+Usage: ruff [OPTIONS] <FILES>...
 
-ARGS:
-    <FILES>...
+Arguments:
+  <FILES>...
 
-OPTIONS:
-    -e, --exit-zero               Exit with status code "0", even upon detecting errors
-        --exclude <EXCLUDE>...    List of file and/or directory patterns to exclude from checks
-    -f, --fix                     Attempt to automatically fix lint errors
-    -h, --help                    Print help information
-        --ignore <IGNORE>...      List of error codes to ignore
-    -n, --no-cache                Disable cache reads
-    -q, --quiet                   Disable all logging (but still exit with status code "1" upon
-                                  detecting errors)
-        --select <SELECT>...      List of error codes to enable
-    -v, --verbose                 Enable verbose logging
-    -w, --watch                   Run in watch mode by re-running whenever files change
+Options:
+  -v, --verbose
+          Enable verbose logging
+  -q, --quiet
+          Disable all logging (but still exit with status code "1" upon detecting errors)
+  -e, --exit-zero
+          Exit with status code "0", even upon detecting errors
+  -w, --watch
+          Run in watch mode by re-running whenever files change
+  -f, --fix
+          Attempt to automatically fix lint errors
+  -n, --no-cache
+          Disable cache reads
+      --select <SELECT>
+          List of error codes to enable
+      --extend-select <EXTEND_SELECT>
+          Like --select, but adds additional error codes on top of the selected ones
+      --ignore <IGNORE>
+          List of error codes to ignore
+      --extend-ignore <EXTEND_IGNORE>
+          Like --ignore, but adds additional error codes on top of the ignored ones
+      --exclude <EXCLUDE>
+          List of paths, used to exclude files and/or directories from checks
+      --extend-exclude <EXTEND_EXCLUDE>
+          Like --exclude, but adds additional files and directories on top of the excluded ones
+      --per-file-ignores <PER_FILE_IGNORES>
+          List of mappings from file pattern to code to exclude
+      --format <FORMAT>
+          Output serialization format for error messages [default: text] [possible values: text, json]
+      --show-files
+          See the files ruff will be run against with the current settings
+      --show-settings
+          See ruff's settings
+      --add-noqa
+          Enable automatic additions of noqa directives to failing lines
+      --dummy-variable-rgx <DUMMY_VARIABLE_RGX>
+          Regular expression matching the name of dummy variables
+      --target-version <TARGET_VERSION>
+          The minimum Python version that should be supported
+  -h, --help
+          Print help information
+  -V, --version
+          Print version information
 ```
 
+### Excluding files
+
+Exclusions are based on globs, and can be either:
+
+- Single-path patterns, like `.mypy_cache` (to exclude any directory named `.mypy_cache` in the
+  tree), `foo.py` (to exclude any file named `foo.py`), or `foo_*.py` (to exclude any file matching
+  `foo_*.py` ).
+- Relative patterns, like `directory/foo.py` (to exclude that specific file) or `directory/*.py`
+  (to exclude any Python files in `directory`). Note that these paths are relative to the
+  project root (e.g., the directory containing your `pyproject.toml`).
+
+### Ignoring errors
+
+To omit a lint check entirely, add it to the "ignore" list via `--ignore` or `--extend-ignore`,
+either  on the command-line or in your `project.toml` file.
+
+To ignore an error in-line, ruff uses a `noqa` system similar to [Flake8](https://flake8.pycqa.org/en/3.1.1/user/ignoring-errors.html).
+To ignore an individual error, add `# noqa: {code}` to the end of the line, like so:
+
+```python
+# Ignore F841.
+x = 1  # noqa: F841
+
+# Ignore E741 and F841.
+i = 1  # noqa: E741, F841
+
+# Ignore _all_ errors.
+x = 1  # noqa
+```
+
+Note that, for multi-line strings, the `noqa` directive should come at the end of the string, and
+will apply to the entire body, like so:
+
+```python
+"""Lorem ipsum dolor sit amet.
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+"""  # noqa: E501
+```
+
+ruff supports several (experimental) workflows to aid in `noqa` management.
+
+First, ruff provides a special error code, `M001`, to enforce that your `noqa` directives are
+"valid", in that the errors they _say_ they ignore are actually being triggered on that line (and
+thus suppressed). **You can run `ruff /path/to/file.py --extend-select M001` to flag unused `noqa`
+directives.**
+
+Second, ruff can _automatically remove_ unused `noqa` directives via its autofix functionality.
+**You can run `ruff /path/to/file.py --extend-select M001 --fix` to automatically remove unused
+`noqa` directives.**
+
+Third, ruff can _automatically add_ `noqa` directives to all failing lines. This is useful when
+migrating a new codebase to ruff. **You can run `ruff /path/to/file.py --add-noqa` to automatically
+add `noqa` directives to all failing lines, with the appropriate error codes.**
+
 ### Compatibility with Black
 
-ruff is intended to be compatible with [Black](https://github.com/psf/black), and should be
-compatible out-of-the-box as long as the `line-length` setting is consistent between the two.
+ruff is compatible with [Black](https://github.com/psf/black) out-of-the-box, as long as
+the `line-length` setting is consistent between the two.
 
 As a project, ruff is designed to be used alongside Black and, as such, will defer implementing
-lint rules that are obviated by Black (e.g., stylistic rules).
+stylistic lint rules that are obviated by autoformatting.
 
 ### Parity with Flake8
 
-ruff's goal is to achieve feature-parity with Flake8 when used (1) without any plugins,
-(2) alongside Black, and (3) on Python 3 code. (Using Black obviates the need for many of Flake8's
-stylistic checks; limiting to Python 3 obviates the need for certain compatibility checks.)
+ruff's goal is to achieve feature parity with Flake8 when used (1) without plugins, (2) alongside
+Black, and (3) on Python 3 code.
 
-Under those conditions, Flake8 implements about 58 rules, give or take. At time of writing, ruff
-implements 28 rules. (Note that these 28 rules likely cover a disproportionate share of errors:
-unused imports, undefined variables, etc.)
+**Under those conditions, ruff implements 44 out of 60 rules.** (ruff is missing: 14 rules related
+to string `.format` calls, 1 rule related to docstring parsing, and 1 rule related to redefined
+variables.)
 
-Of the unimplemented rules, ruff is missing:
+ruff also implements some of the most popular Flake8 plugins natively, including:
 
-- 15 rules related to string `.format` calls.
-- 6 rules related to misplaced `yield`, `break`, and `return` statements.
-- 3 rules related to syntax errors in doctests and annotations.
-- 2 rules related to redefining unused names.
-
-...along with a variety of others that don't fit neatly into any specific category.
+- [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
+- [`flake8-super`](https://pypi.org/project/flake8-super/)
+- [`flake8-print`](https://pypi.org/project/flake8-print/)
+- [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/) (12/16)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (3/32)
+- [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/) (25/48)
+- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34)
 
 Beyond rule-set parity, ruff suffers from the following limitations vis-à-vis Flake8:
 
-1. Flake8 supports a wider range of `noqa` patterns, such as per-file ignores defined in `.flake8`.
+1. ruff does not yet support a few Python 3.9 and 3.10 language features, including structural
+   pattern matching and parenthesized context managers.
 2. Flake8 has a plugin architecture and supports writing custom lint rules.
-3. ruff does not yet support parenthesized context managers.
 
 ## Rules
 
-| Code | Name | Message |
-| ---- | ----- | ------- |
-| E402 | ModuleImportNotAtTopOfFile | Module level import not at top of file |
-| E501 | LineTooLong | Line too long |
-| E711 | NoneComparison | Comparison to `None` should be `cond is None` |
-| E712 | TrueFalseComparison | Comparison to `True` should be `cond is True` |
-| E713 | NotInTest | Test for membership should be `not in` |
-| E714 | NotIsTest | Test for object identity should be `is not` |
-| E731 | DoNotAssignLambda | Do not assign a lambda expression, use a def |
-| E902 | IOError | No such file or directory: `...` |
-| F401 | UnusedImport | `...` imported but unused |
-| F403 | ImportStarUsage | Unable to detect undefined names |
-| F541 | FStringMissingPlaceholders | f-string without any placeholders |
-| F601 | MultiValueRepeatedKeyLiteral | Dictionary key literal repeated |
-| F602 | MultiValueRepeatedKeyVariable | Dictionary key `...` repeated |
-| F621 | TooManyExpressionsInStarredAssignment | too many expressions in star-unpacking assignment |
-| F622 | TwoStarredExpressions | two starred expressions in assignment |
-| F631 | AssertTuple | Assert test is a non-empty tuple, which is always `True` |
-| F634 | IfTuple | If test is a tuple, which is always `True` |
-| F704 | YieldOutsideFunction | a `yield` or `yield from` statement outside of a function/method |
-| F706 | ReturnOutsideFunction | a `return` statement outside of a function/method |
-| F707 | DefaultExceptNotLast | an `except:` block as not the last exception handler |
-| F821 | UndefinedName | Undefined name `...` |
-| F822 | UndefinedExport | Undefined name `...` in `__all__` |
-| F823 | UndefinedLocal | Local variable `...` referenced before assignment |
-| F831 | DuplicateArgumentName | Duplicate argument name in function definition |
-| F841 | UnusedVariable | Local variable `...` is assigned to but never used |
-| F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` |
-| R001 | UselessObjectInheritance | Class `...` inherits from object |
-| R002 | NoAssertEquals | `assertEquals` is deprecated, use `assertEqual` instead |
+The ✅ emoji indicates a rule is enabled by default.
+
+The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` command-line option.
+
+| Code | Name | Message |     |     |
+| ---- | ---- | ------- | --- | --- |
+| E402 | ModuleImportNotAtTopOfFile | Module level import not at top of file | ✅ |  |
+| E501 | LineTooLong | Line too long (89 > 88 characters) | ✅ |  |
+| E711 | NoneComparison | Comparison to `None` should be `cond is None` | ✅ |  |
+| E712 | TrueFalseComparison | Comparison to `True` should be `cond is True` | ✅ |  |
+| E713 | NotInTest | Test for membership should be `not in` | ✅ |  |
+| E714 | NotIsTest | Test for object identity should be `is not` | ✅ |  |
+| E721 | TypeComparison | Do not compare types, use `isinstance()` | ✅ |  |
+| E722 | DoNotUseBareExcept | Do not use bare `except` | ✅ |  |
+| E731 | DoNotAssignLambda | Do not assign a lambda expression, use a def | ✅ |  |
+| E741 | AmbiguousVariableName | Ambiguous variable name: `...` | ✅ |  |
+| E742 | AmbiguousClassName | Ambiguous class name: `...` | ✅ |  |
+| E743 | AmbiguousFunctionName | Ambiguous function name: `...` | ✅ |  |
+| E902 | IOError | IOError: `...` | ✅ |  |
+| E999 | SyntaxError | SyntaxError: `...` | ✅ |  |
+| W292 | NoNewLineAtEndOfFile | No newline at end of file | ✅ |  |
+| F401 | UnusedImport | `...` imported but unused | ✅ | 🛠 |
+| F402 | ImportShadowedByLoopVar | Import `...` from line 1 shadowed by loop variable | ✅ |  |
+| F403 | ImportStarUsed | `from ... import *` used; unable to detect undefined names | ✅ |  |
+| F404 | LateFutureImport | `from __future__` imports must occur at the beginning of the file | ✅ |  |
+| F405 | ImportStarUsage | `...` may be undefined, or defined from star imports: `...` | ✅ |  |
+| F406 | ImportStarNotPermitted | `from ... import *` only allowed at module level | ✅ |  |
+| F407 | FutureFeatureNotDefined | Future feature `...` is not defined | ✅ |  |
+| F541 | FStringMissingPlaceholders | f-string without any placeholders | ✅ |  |
+| F601 | MultiValueRepeatedKeyLiteral | Dictionary key literal repeated | ✅ |  |
+| F602 | MultiValueRepeatedKeyVariable | Dictionary key `...` repeated | ✅ |  |
+| F621 | ExpressionsInStarAssignment | Too many expressions in star-unpacking assignment | ✅ |  |
+| F622 | TwoStarredExpressions | Two starred expressions in assignment | ✅ |  |
+| F631 | AssertTuple | Assert test is a non-empty tuple, which is always `True` | ✅ |  |
+| F632 | IsLiteral | Use `==` and `!=` to compare constant literals | ✅ |  |
+| F633 | InvalidPrintSyntax | Use of `>>` is invalid with `print` function | ✅ |  |
+| F634 | IfTuple | If test is a tuple, which is always `True` | ✅ |  |
+| F701 | BreakOutsideLoop | `break` outside loop | ✅ |  |
+| F702 | ContinueOutsideLoop | `continue` not properly in loop | ✅ |  |
+| F704 | YieldOutsideFunction | `yield` or `yield from` statement outside of a function/method | ✅ |  |
+| F706 | ReturnOutsideFunction | `return` statement outside of a function/method | ✅ |  |
+| F707 | DefaultExceptNotLast | An `except:` block as not the last exception handler | ✅ |  |
+| F722 | ForwardAnnotationSyntaxError | Syntax error in forward annotation: `...` | ✅ |  |
+| F821 | UndefinedName | Undefined name `...` | ✅ |  |
+| F822 | UndefinedExport | Undefined name `...` in `__all__` | ✅ |  |
+| F823 | UndefinedLocal | Local variable `...` referenced before assignment | ✅ |  |
+| F831 | DuplicateArgumentName | Duplicate argument name in function definition | ✅ |  |
+| F841 | UnusedVariable | Local variable `...` is assigned to but never used | ✅ |  |
+| F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` | ✅ |  |
+| A001 | BuiltinVariableShadowing | Variable `...` is shadowing a python builtin |  |  |
+| A002 | BuiltinArgumentShadowing | Argument `...` is shadowing a python builtin |  |  |
+| A003 | BuiltinAttributeShadowing | Class attribute `...` is shadowing a python builtin |  |  |
+| B011 | DoNotAssertFalse | Do not `assert False` (`python -O` removes these calls), raise `AssertionError()` |  | 🛠 |
+| B014 | DuplicateHandlerException | Exception handler with duplicate exception: `ValueError` |  | 🛠 |
+| B025 | DuplicateTryBlockException | try-except block with duplicate exception `Exception` |  |  |
+| C400 | UnnecessaryGeneratorList | Unnecessary generator - rewrite as a list comprehension |  |  |
+| C401 | UnnecessaryGeneratorSet | Unnecessary generator - rewrite as a set comprehension |  |  |
+| C402 | UnnecessaryGeneratorDict | Unnecessary generator - rewrite as a dict comprehension |  |  |
+| C403 | UnnecessaryListComprehensionSet | Unnecessary list comprehension - rewrite as a set comprehension |  |  |
+| C404 | UnnecessaryListComprehensionDict | Unnecessary list comprehension - rewrite as a dict comprehension |  |  |
+| C405 | UnnecessaryLiteralSet | Unnecessary <list/tuple> literal - rewrite as a set literal |  |  |
+| C406 | UnnecessaryLiteralDict | Unnecessary <list/tuple> literal - rewrite as a dict literal |  |  |
+| C408 | UnnecessaryCollectionCall | Unnecessary <dict/list/tuple> call - rewrite as a literal |  |  |
+| C409 | UnnecessaryLiteralWithinTupleCall | Unnecessary <list/tuple> literal passed to tuple() - remove the outer call to tuple() |  |  |
+| C410 | UnnecessaryLiteralWithinListCall | Unnecessary <list/tuple> literal passed to list() - rewrite as a list literal |  |  |
+| C414 | UnnecessaryDoubleCastOrProcess | Unnecessary <list/reversed/set/sorted/tuple> call within <list/set/sorted/tuple>(). |  |  |
+| C415 | UnnecessarySubscriptReversal | Unnecessary subscript reversal of iterable within <reversed/set/sorted>() |  |  |
+| T201 | PrintFound | `print` found |  | 🛠 |
+| T203 | PPrintFound | `pprint` found |  | 🛠 |
+| U001 | UselessMetaclassType | `__metaclass__ = type` is implied |  | 🛠 |
+| U002 | UnnecessaryAbspath | `abspath(__file__)` is unnecessary in Python 3.9 and later |  | 🛠 |
+| U003 | TypeOfPrimitive | Use `str` instead of `type(...)` |  | 🛠 |
+| U004 | UselessObjectInheritance | Class `...` inherits from object |  | 🛠 |
+| U005 | DeprecatedUnittestAlias | `assertEquals` is deprecated, use `assertEqual` instead |  | 🛠 |
+| U006 | UsePEP585Annotation | Use `list` instead of `List` for type annotations |  | 🛠 |
+| U007 | UsePEP604Annotation | Use `X \| Y` for type annotations |  | 🛠 |
+| U008 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` |  | 🛠 |
+| D100 | PublicModule | Missing docstring in public module |  |  |
+| D101 | PublicClass | Missing docstring in public class |  |  |
+| D102 | PublicMethod | Missing docstring in public method |  |  |
+| D103 | PublicFunction | Missing docstring in public function |  |  |
+| D104 | PublicPackage | Missing docstring in public package |  |  |
+| D105 | MagicMethod | Missing docstring in magic method |  |  |
+| D106 | PublicNestedClass | Missing docstring in public nested class |  |  |
+| D107 | PublicInit | Missing docstring in __init__ |  |  |
+| D200 | FitsOnOneLine | One-line docstring should fit on one line |  |  |
+| D205 | NoBlankLineAfterSummary | 1 blank line required between summary line and description |  |  |
+| D209 | NewLineAfterLastParagraph | Multi-line docstring closing quotes should be on a separate line |  |  |
+| D210 | NoSurroundingWhitespace | No whitespaces allowed surrounding docstring text |  |  |
+| D212 | MultiLineSummaryFirstLine | Multi-line docstring summary should start at the first line |  |  |
+| D213 | MultiLineSummarySecondLine | Multi-line docstring summary should start at the second line |  |  |
+| D300 | UsesTripleQuotes | Use """triple double quotes""" |  |  |
+| D400 | EndsInPeriod | First line should end with a period |  |  |
+| D402 | NoSignature | First line should not be the function's 'signature' |  |  |
+| D403 | FirstLineCapitalized | First word of the first line should be properly capitalized |  |  |
+| D415 | EndsInPunctuation | First line should end with a period, question mark, or exclamation point |  |  |
+| D419 | NonEmpty | Docstring is empty |  |  |
+| D201 | NoBlankLineBeforeFunction | No blank lines allowed before function docstring (found 1) |  |  |
+| D202 | NoBlankLineAfterFunction | No blank lines allowed after function docstring (found 1) |  |  |
+| D211 | NoBlankLineBeforeClass | No blank lines allowed before class docstring |  |  |
+| D203 | OneBlankLineBeforeClass | 1 blank line required before class docstring |  |  |
+| D204 | OneBlankLineAfterClass | 1 blank line required after class docstring |  |  |
+| M001 | UnusedNOQA | Unused `noqa` directive |  | 🛠 |
+
+## Integrations
+
+### PyCharm
+
+ruff can be installed as an [External Tool](https://www.jetbrains.com/help/pycharm/configuring-third-party-tools.html)
+in PyCharm. Open the Preferences pane, then navigate to "Tools", then "External Tools". From there,
+add a new tool with the following configuration:
+
+![Install ruff as an External Tool](https://user-images.githubusercontent.com/1309177/193155720-336e43f0-1a8d-46b4-bc12-e60f9ae01f7e.png)
+
+ruff should then appear as a runnable action:
+
+![ruff as a runnable action](https://user-images.githubusercontent.com/1309177/193156026-732b0aaf-3dd9-4549-9b4d-2de6d2168a33.png)
+
+### GitHub Actions
+
+GitHub Actions has everything you need to run ruff out-of-the-box:
+
+```yaml
+name: CI
+on: push
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install ruff
+      - name: Run ruff
+        run: ruff .
+```
 
 ## Development
 
@@ -209,7 +404,7 @@ Add this `pyproject.toml` to the CPython directory:
 ```toml
 [tool.ruff]
 line-length = 88
-exclude = [
+extend-exclude = [
     "Lib/lib2to3/tests/data/bom.py",
     "Lib/lib2to3/tests/data/crlf.py",
     "Lib/lib2to3/tests/data/different_encoding.py",
@@ -240,17 +435,21 @@ Next, to benchmark the release build:
 ```shell
 cargo build --release
 
-hyperfine --ignore-failure --warmup 1 \
+hyperfine --ignore-failure --warmup 10 --runs 100 \
   "./target/release/ruff ./resources/test/cpython/ --no-cache" \
   "./target/release/ruff ./resources/test/cpython/"
 
 Benchmark 1: ./target/release/ruff ./resources/test/cpython/ --no-cache
-  Time (mean ± σ):     353.6 ms ±   7.6 ms    [User: 2868.8 ms, System: 171.5 ms]
-  Range (min … max):   344.4 ms … 367.3 ms    10 runs
+  Time (mean ± σ):     297.4 ms ±   4.9 ms    [User: 2460.0 ms, System: 67.2 ms]
+  Range (min … max):   287.7 ms … 312.1 ms    100 runs
+
+  Warning: Ignoring non-zero exit code.
 
 Benchmark 2: ./target/release/ruff ./resources/test/cpython/
-  Time (mean ± σ):      59.6 ms ±   2.5 ms    [User: 36.4 ms, System: 345.6 ms]
-  Range (min … max):    55.9 ms …  67.0 ms    48 runs
+  Time (mean ± σ):      79.6 ms ±   7.3 ms    [User: 59.7 ms, System: 356.1 ms]
+  Range (min … max):    62.4 ms … 111.2 ms    100 runs
+
+  Warning: Ignoring non-zero exit code.
 ```
 
 To benchmark against the ecosystem's existing tools:
@@ -262,11 +461,8 @@ hyperfine --ignore-failure --warmup 5 \
   "pyflakes resources/test/cpython" \
   "autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython" \
   "pycodestyle resources/test/cpython" \
-  "pycodestyle --select E501 resources/test/cpython" \
   "flake8 resources/test/cpython" \
-  "flake8 --select=F831,F541,F634,F403,F706,F901,E501 resources/test/cpython" \
-  "python -m scripts.run_flake8 resources/test/cpython" \
-  "python -m scripts.run_flake8 resources/test/cpython --select=F831,F541,F634,F403,F706,F901,E501"
+  "python -m scripts.run_flake8 resources/test/cpython"
 ```
 
 In order, these evaluate:
@@ -276,68 +472,65 @@ In order, these evaluate:
 - PyFlakes
 - autoflake
 - pycodestyle
-- pycodestyle, limited to the checks supported by ruff
 - Flake8
-- Flake8, limited to the checks supported by ruff
 - Flake8, with a hack to enable multiprocessing on macOS
-- Flake8, with a hack to enable multiprocessing on macOS, limited to the checks supported by ruff
 
 (You can `poetry install` from `./scripts` to create a working environment for the above.)
 
 ```shell
 Benchmark 1: ./target/release/ruff ./resources/test/cpython/ --no-cache
-  Time (mean ± σ):     469.3 ms ±  16.3 ms    [User: 2663.0 ms, System: 972.5 ms]
-  Range (min … max):   445.2 ms … 494.8 ms    10 runs
+  Time (mean ± σ):     297.9 ms ±   7.0 ms    [User: 2436.6 ms, System: 65.9 ms]
+  Range (min … max):   289.9 ms … 314.6 ms    10 runs
+
+  Warning: Ignoring non-zero exit code.
 
 Benchmark 2: pylint --recursive=y resources/test/cpython/
-  Time (mean ± σ):     27.211 s ±  0.097 s    [User: 26.405 s, System: 0.799 s]
-  Range (min … max):   27.056 s … 27.349 s    10 runs
+  Time (mean ± σ):     37.634 s ±  0.225 s    [User: 36.728 s, System: 0.853 s]
+  Range (min … max):   37.201 s … 38.106 s    10 runs
+
+  Warning: Ignoring non-zero exit code.
 
 Benchmark 3: pyflakes resources/test/cpython
-  Time (mean ± σ):     27.309 s ±  0.033 s    [User: 27.137 s, System: 0.169 s]
-  Range (min … max):   27.267 s … 27.372 s    10 runs
+  Time (mean ± σ):     40.950 s ±  0.449 s    [User: 40.688 s, System: 0.229 s]
+  Range (min … max):   40.348 s … 41.671 s    10 runs
+
+  Warning: Ignoring non-zero exit code.
 
 Benchmark 4: autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython
-  Time (mean ± σ):      8.027 s ±  0.024 s    [User: 74.255 s, System: 0.953 s]
-  Range (min … max):    7.969 s …  8.052 s    10 runs
+  Time (mean ± σ):     11.562 s ±  0.160 s    [User: 107.022 s, System: 1.143 s]
+  Range (min … max):   11.417 s … 11.917 s    10 runs
 
 Benchmark 5: pycodestyle resources/test/cpython
-  Time (mean ± σ):     41.666 s ±  0.266 s    [User: 41.531 s, System: 0.132 s]
-  Range (min … max):   41.295 s … 41.980 s    10 runs
+  Time (mean ± σ):     67.428 s ±  0.985 s    [User: 67.199 s, System: 0.203 s]
+  Range (min … max):   65.313 s … 68.496 s    10 runs
 
-Benchmark 6: pycodestyle --select E501 resources/test/cpython
-  Time (mean ± σ):     14.547 s ±  0.077 s    [User: 14.466 s, System: 0.079 s]
-  Range (min … max):   14.429 s … 14.695 s    10 runs
+  Warning: Ignoring non-zero exit code.
 
-Benchmark 7: flake8 resources/test/cpython
-  Time (mean ± σ):     75.700 s ±  0.152 s    [User: 75.254 s, System: 0.440 s]
-  Range (min … max):   75.513 s … 76.014 s    10 runs
+Benchmark 6: flake8 resources/test/cpython
+  Time (mean ± σ):     116.099 s ±  1.178 s    [User: 115.217 s, System: 0.845 s]
+  Range (min … max):   114.180 s … 117.724 s    10 runs
 
-Benchmark 8: flake8 --select=F831,F541,F634,F403,F706,F901,E501 resources/test/cpython
-  Time (mean ± σ):     75.122 s ±  0.532 s    [User: 74.677 s, System: 0.440 s]
-  Range (min … max):   74.130 s … 75.606 s    10 runs
+  Warning: Ignoring non-zero exit code.
 
-Benchmark 9: python -m scripts.run_flake8 resources/test/cpython
-  Time (mean ± σ):     12.794 s ±  0.147 s    [User: 90.792 s, System: 0.738 s]
-  Range (min … max):   12.606 s … 13.030 s    10 runs
-
-Benchmark 10: python -m scripts.run_flake8 resources/test/cpython --select=F831,F541,F634,F403,F706,F901,E501
-  Time (mean ± σ):     12.487 s ±  0.118 s    [User: 90.052 s, System: 0.714 s]
-  Range (min … max):   12.265 s … 12.665 s    10 runs
+Benchmark 7: python -m scripts.run_flake8 resources/test/cpython
+  Time (mean ± σ):     20.477 s ±  0.349 s    [User: 142.372 s, System: 1.504 s]
+  Range (min … max):   20.107 s … 21.183 s    10 runs
 
 Summary
   './target/release/ruff ./resources/test/cpython/ --no-cache' ran
-   17.10 ± 0.60 times faster than 'autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython'
-   26.60 ± 0.96 times faster than 'python -m scripts.run_flake8 resources/test/cpython --select=F831,F541,F634,F403,F706,F901,E501'
-   27.26 ± 1.00 times faster than 'python -m scripts.run_flake8 resources/test/cpython'
-   30.99 ± 1.09 times faster than 'pycodestyle --select E501 resources/test/cpython'
-   57.98 ± 2.03 times faster than 'pylint --recursive=y resources/test/cpython/'
-   58.19 ± 2.02 times faster than 'pyflakes resources/test/cpython'
-   88.77 ± 3.14 times faster than 'pycodestyle resources/test/cpython'
-  160.06 ± 5.68 times faster than 'flake8 --select=F831,F541,F634,F403,F706,F901,E501 resources/test/cpython'
-  161.29 ± 5.61 times faster than 'flake8 resources/test/cpython'
+   38.81 ± 1.05 times faster than 'autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython'
+   68.74 ± 1.99 times faster than 'python -m scripts.run_flake8 resources/test/cpython'
+  126.33 ± 3.05 times faster than 'pylint --recursive=y resources/test/cpython/'
+  137.46 ± 3.55 times faster than 'pyflakes resources/test/cpython'
+  226.35 ± 6.23 times faster than 'pycodestyle resources/test/cpython'
+  389.73 ± 9.92 times faster than 'flake8 resources/test/cpython'
 ```
 
 ## License
 
 MIT
+
+## Contributing
+
+Contributions are welcome and hugely appreciated. To get started, check out the
+[contributing guidelines](https://github.com/charliermarsh/ruff/blob/main/CONTRIBUTING.md).

examples/generate_rules_table.rs

@@ -1,47 +1,26 @@
 /// Generate a Markdown-compatible table of supported lint rules.
-use ruff::checks::{CheckKind, RejectedCmpop};
+use strum::IntoEnumIterator;
+
+use ruff::checks::{CheckCode, DEFAULT_CHECK_CODES};
 
 fn main() {
-    let mut check_kinds: Vec<CheckKind> = vec![
-        CheckKind::AssertTuple,
-        CheckKind::DefaultExceptNotLast,
-        CheckKind::DoNotAssignLambda,
-        CheckKind::DuplicateArgumentName,
-        CheckKind::FStringMissingPlaceholders,
-        CheckKind::IOError("...".to_string()),
-        CheckKind::IfTuple,
-        CheckKind::ImportStarUsage,
-        CheckKind::LineTooLong,
-        CheckKind::ModuleImportNotAtTopOfFile,
-        CheckKind::MultiValueRepeatedKeyLiteral,
-        CheckKind::MultiValueRepeatedKeyVariable("...".to_string()),
-        CheckKind::NoAssertEquals,
-        CheckKind::NoneComparison(RejectedCmpop::Eq),
-        CheckKind::NotInTest,
-        CheckKind::NotIsTest,
-        CheckKind::RaiseNotImplemented,
-        CheckKind::ReturnOutsideFunction,
-        CheckKind::TooManyExpressionsInStarredAssignment,
-        CheckKind::TrueFalseComparison(true, RejectedCmpop::Eq),
-        CheckKind::TwoStarredExpressions,
-        CheckKind::UndefinedExport("...".to_string()),
-        CheckKind::UndefinedLocal("...".to_string()),
-        CheckKind::UndefinedName("...".to_string()),
-        CheckKind::UnusedImport("...".to_string()),
-        CheckKind::UnusedVariable("...".to_string()),
-        CheckKind::UselessObjectInheritance("...".to_string()),
-        CheckKind::YieldOutsideFunction,
-    ];
-    check_kinds.sort_by_key(|check_kind| check_kind.code());
-
-    println!("| Code | Name | Message |");
-    println!("| ---- | ----- | ------- |");
-    for check_kind in check_kinds {
+    println!("| Code | Name | Message |     |     |");
+    println!("| ---- | ---- | ------- | --- | --- |");
+    for check_code in CheckCode::iter() {
+        let check_kind = check_code.kind();
+        let default_token = if DEFAULT_CHECK_CODES.contains(&check_code) {
+            "✅"
+        } else {
+            ""
+        };
+        let fix_token = if check_kind.fixable() { "🛠" } else { "" };
         println!(
-            "| {} | {} | {} |",
-            check_kind.code().as_str(),
-            check_kind.name(),
-            check_kind.body()
+            "| {} | {} | {} | {} | {} |",
+            check_kind.code().as_ref(),
+            check_kind.as_ref(),
+            check_kind.body().replace("|", r"\|"),
+            default_token,
+            fix_token
         );
     }
 }

examples/generate_source_code.rs

@@ -0,0 +1,26 @@
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Parser;
+use rustpython_parser::parser;
+
+use ruff::code_gen::SourceGenerator;
+use ruff::fs;
+
+#[derive(Debug, Parser)]
+struct Cli {
+    #[arg(required = true)]
+    file: PathBuf,
+}
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    let contents = fs::read_file(&cli.file)?;
+    let python_ast = parser::parse_program(&contents, &cli.file.to_string_lossy())?;
+    let mut generator = SourceGenerator::new();
+    generator.unparse_suite(&python_ast)?;
+    println!("{}", generator.generate()?);
+
+    Ok(())
+}

examples/print_ast.rs

@@ -2,14 +2,14 @@
 use std::path::PathBuf;
 
 use anyhow::Result;
-use clap::{Parser, ValueHint};
+use clap::Parser;
 use rustpython_parser::parser;
 
 use ruff::fs;
 
 #[derive(Debug, Parser)]
 struct Cli {
-    #[clap(parse(from_os_str), value_hint = ValueHint::FilePath, required = true)]
+    #[arg(required = true)]
     file: PathBuf,
 }
 

examples/print_tokens.rs

@@ -2,14 +2,14 @@
 use std::path::PathBuf;
 
 use anyhow::Result;
-use clap::{Parser, ValueHint};
+use clap::Parser;
 use rustpython_parser::lexer;
 
 use ruff::fs;
 
 #[derive(Debug, Parser)]
 struct Cli {
-    #[clap(parse(from_os_str), value_hint = ValueHint::FilePath, required = true)]
+    #[arg(required = true)]
     file: PathBuf,
 }
 

pyproject.toml

@@ -8,7 +8,6 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Programming Language :: Python",
-    "Programming Language :: Python :: 3.6",
     "Programming Language :: Python :: 3.7",
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
@@ -19,10 +18,12 @@ classifiers = [
 ]
 author = "Charlie Marsh"
 author_email = "charlie.r.marsh@gmail.com"
-url = "https://github.com/charliermarsh/ruff"
 description = "An extremely fast Python linter, written in Rust."
 requires-python = ">=3.7"
 
+[project.urls]
+repository = "https://github.com/charliermarsh/ruff"
+
 [build-system]
 requires = ["maturin>=0.13,<0.14"]
 build-backend = "maturin"

resources/test/fixtures/A001.py

@@ -0,0 +1,27 @@
+import some as sum
+from some import other as int
+
+print = 1
+copyright: 'annotation' = 2
+(complex := 3)
+float = object = 4
+min, max = 5, 6
+
+def bytes():
+    pass
+
+class slice:
+    pass
+
+try:
+    ...
+except ImportError as ValueError:
+    ...
+
+for memoryview, *bytearray in []:
+    pass
+
+with open('file') as str, open('file2') as (all, any):
+    pass
+
+[0 for sum in ()]

resources/test/fixtures/A002.py

@@ -0,0 +1,9 @@
+def func1(str, /, type, *complex, Exception, **getattr):
+    pass
+
+
+async def func2(bytes):
+    pass
+
+
+map([], lambda float: ...)

resources/test/fixtures/A003.py

@@ -0,0 +1,8 @@
+class MyClass:
+    ImportError = 4
+
+    def __init__(self):
+        self.float = 5  # is fine
+
+    def str(self):
+        pass

resources/test/fixtures/B011.py

@@ -0,0 +1,10 @@
+"""
+Should emit:
+B011 - on line 8
+B011 - on line 10
+"""
+
+assert 1 != 2
+assert False
+assert 1 != 2, "message"
+assert False, "message"

resources/test/fixtures/B014.py

@@ -0,0 +1,76 @@
+"""
+Should emit:
+B014 - on lines 11, 17, 28, 42, 49, 56, and 74.
+"""
+
+import binascii
+import re
+
+try:
+    pass
+except (Exception, TypeError):
+    # TypeError is a subclass of Exception, so it doesn't add anything
+    pass
+
+try:
+    pass
+except (OSError, OSError) as err:
+    # Duplicate exception types are useless
+    pass
+
+
+class MyError(Exception):
+    pass
+
+
+try:
+    pass
+except (MyError, MyError):
+    # Detect duplicate non-builtin errors
+    pass
+
+
+try:
+    pass
+except (MyError, Exception) as e:
+    # Don't assume that we're all subclasses of Exception
+    pass
+
+
+try:
+    pass
+except (MyError, BaseException) as e:
+    # But we *can* assume that everything is a subclass of BaseException
+    pass
+
+
+try:
+    pass
+except (re.error, re.error):
+    # Duplicate exception types as attributes
+    pass
+
+
+try:
+    pass
+except (IOError, EnvironmentError, OSError):
+    # Detect if a primary exception and any its aliases are present.
+    #
+    # Since Python 3.3, IOError, EnvironmentError, WindowsError, mmap.error,
+    # socket.error and select.error are aliases of OSError. See PEP 3151 for
+    # more info.
+    pass
+
+
+try:
+    pass
+except (MyException, NotImplemented):
+    # NotImplemented is not an exception, let's not crash on it.
+    pass
+
+
+try:
+    pass
+except (ValueError, binascii.Error):
+    # binascii.Error is a subclass of ValueError.
+    pass

resources/test/fixtures/B025.py

@@ -0,0 +1,38 @@
+"""
+Should emit:
+B025 - on lines 15, 22, 31
+"""
+
+import pickle
+
+try:
+    a = 1
+except ValueError:
+    a = 2
+finally:
+    a = 3
+
+try:
+    a = 1
+except ValueError:
+    a = 2
+except ValueError:
+    a = 2
+
+try:
+    a = 1
+except pickle.PickleError:
+    a = 2
+except ValueError:
+    a = 2
+except pickle.PickleError:
+    a = 2
+
+try:
+    a = 1
+except (ValueError, TypeError):
+    a = 2
+except ValueError:
+    a = 2
+except (OSError, TypeError):
+    a = 2

resources/test/fixtures/C400.py

@@ -0,0 +1 @@
+x = list(x for x in range(3))

resources/test/fixtures/C401.py

@@ -0,0 +1 @@
+x = set(x for x in range(3))

resources/test/fixtures/C402.py

@@ -0,0 +1 @@
+d = dict((x, x) for x in range(3))

resources/test/fixtures/C403.py

@@ -0,0 +1 @@
+s = set([x for x in range(3)])

resources/test/fixtures/C404.py

@@ -0,0 +1 @@
+d = dict([(i, i) for i in range(3)])

resources/test/fixtures/C405.py

@@ -0,0 +1,5 @@
+s1 = set([1, 2])
+s2 = set((1, 2))
+s3 = set([])
+s4 = set(())
+s5 = set()

resources/test/fixtures/C406.py

@@ -0,0 +1,5 @@
+d1 = dict([(1, 2)])
+d2 = dict(((1, 2),))
+d3 = dict([])
+d4 = dict(())
+d5 = dict()

resources/test/fixtures/C408.py

@@ -0,0 +1,5 @@
+t = tuple()
+l = list()
+d1 = dict()
+d2 = dict(a=1)
+d3 = dict(**d2)

resources/test/fixtures/C409.py

@@ -0,0 +1,3 @@
+t1 = tuple([1, 2])
+t2 = tuple((1, 2))
+t3 = tuple([])

resources/test/fixtures/C410.py

@@ -0,0 +1,4 @@
+l1 = list([1, 2])
+l2 = list((1, 2))
+l3 = list([])
+l4 = list(())

resources/test/fixtures/C414.py

@@ -0,0 +1,14 @@
+x = [1, 2, 3]
+list(list(x))
+list(tuple(x))
+tuple(list(x))
+tuple(tuple(x))
+set(set(x))
+set(list(x))
+set(tuple(x))
+set(sorted(x))
+set(reversed(x))
+sorted(list(x))
+sorted(tuple(x))
+sorted(sorted(x))
+sorted(reversed(x))

resources/test/fixtures/C415.py

@@ -0,0 +1,9 @@
+lst = [2, 1, 3]
+a = set(lst[::-1])
+b = reversed(lst[::-1])
+c = sorted(lst[::-1])
+d = sorted(lst[::-1], reverse=True)
+e = set(lst[2:-1])
+f = set(lst[:1:-1])
+g = set(lst[::1])
+h = set(lst[::-2])

resources/test/fixtures/D.py

@@ -0,0 +1,534 @@
+# No docstring, so we can test D100
+from functools import wraps
+import os
+from .expected import Expectation
+from typing import overload
+
+
+expectation = Expectation()
+expect = expectation.expect
+
+expect('class_', 'D101: Missing docstring in public class')
+
+
+class class_:
+
+    expect('meta', 'D419: Docstring is empty')
+
+    class meta:
+        """"""
+
+    @expect('D102: Missing docstring in public method')
+    def method(self=None):
+        pass
+
+    def _ok_since_private(self=None):
+        pass
+
+    @overload
+    def overloaded_method(self, a: int) -> str:
+        ...
+
+    @overload
+    def overloaded_method(self, a: str) -> str:
+        """Foo bar documentation."""
+        ...
+
+    def overloaded_method(a):
+        """Foo bar documentation."""
+        return str(a)
+
+    expect('overloaded_method',
+           "D418: Function/ Method decorated with @overload"
+           " shouldn't contain a docstring")
+
+    @property
+    def foo(self):
+        """The foo of the thing, which isn't in imperitive mood."""
+        return "hello"
+
+    @expect('D102: Missing docstring in public method')
+    def __new__(self=None):
+        pass
+
+    @expect('D107: Missing docstring in __init__')
+    def __init__(self=None):
+        pass
+
+    @expect('D105: Missing docstring in magic method')
+    def __str__(self=None):
+        pass
+
+    @expect('D102: Missing docstring in public method')
+    def __call__(self=None, x=None, y=None, z=None):
+        pass
+
+
+@expect('D419: Docstring is empty')
+def function():
+    """ """
+    def ok_since_nested():
+        pass
+
+    @expect('D419: Docstring is empty')
+    def nested():
+        ''
+
+
+def function_with_nesting():
+    """Foo bar documentation."""
+    @overload
+    def nested_overloaded_func(a: int) -> str:
+        ...
+
+    @overload
+    def nested_overloaded_func(a: str) -> str:
+        """Foo bar documentation."""
+        ...
+
+    def nested_overloaded_func(a):
+        """Foo bar documentation."""
+        return str(a)
+
+
+expect('nested_overloaded_func',
+       "D418: Function/ Method decorated with @overload"
+       " shouldn't contain a docstring")
+
+
+@overload
+def overloaded_func(a: int) -> str:
+    ...
+
+
+@overload
+def overloaded_func(a: str) -> str:
+    """Foo bar documentation."""
+    ...
+
+
+def overloaded_func(a):
+    """Foo bar documentation."""
+    return str(a)
+
+
+expect('overloaded_func',
+       "D418: Function/ Method decorated with @overload"
+       " shouldn't contain a docstring")
+
+
+@expect('D200: One-line docstring should fit on one line with quotes '
+        '(found 3)')
+@expect('D212: Multi-line docstring summary should start at the first line')
+def asdlkfasd():
+    """
+    Wrong.
+    """
+
+
+@expect('D201: No blank lines allowed before function docstring (found 1)')
+def leading_space():
+
+    """Leading space."""
+
+
+@expect('D202: No blank lines allowed after function docstring (found 1)')
+def trailing_space():
+    """Leading space."""
+
+    pass
+
+
+@expect('D201: No blank lines allowed before function docstring (found 1)')
+@expect('D202: No blank lines allowed after function docstring (found 1)')
+def trailing_and_leading_space():
+
+    """Trailing and leading space."""
+
+    pass
+
+
+expect('LeadingSpaceMissing',
+       'D203: 1 blank line required before class docstring (found 0)')
+
+
+class LeadingSpaceMissing:
+    """Leading space missing."""
+
+
+expect('WithLeadingSpace',
+       'D211: No blank lines allowed before class docstring (found 1)')
+
+
+class WithLeadingSpace:
+
+    """With leading space."""
+
+
+expect('TrailingSpace',
+       'D204: 1 blank line required after class docstring (found 0)')
+expect('TrailingSpace',
+       'D211: No blank lines allowed before class docstring (found 1)')
+
+
+class TrailingSpace:
+
+    """TrailingSpace."""
+    pass
+
+
+expect('LeadingAndTrailingSpaceMissing',
+       'D203: 1 blank line required before class docstring (found 0)')
+expect('LeadingAndTrailingSpaceMissing',
+       'D204: 1 blank line required after class docstring (found 0)')
+
+
+class LeadingAndTrailingSpaceMissing:
+    """Leading and trailing space missing."""
+    pass
+
+
+@expect('D205: 1 blank line required between summary line and description '
+        '(found 0)')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def multi_line_zero_separating_blanks():
+    """Summary.
+    Description.
+
+    """
+
+
+@expect('D205: 1 blank line required between summary line and description '
+        '(found 2)')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def multi_line_two_separating_blanks():
+    """Summary.
+
+
+    Description.
+
+    """
+
+
+@expect('D213: Multi-line docstring summary should start at the second line')
+def multi_line_one_separating_blanks():
+    """Summary.
+
+    Description.
+
+    """
+
+
+@expect('D207: Docstring is under-indented')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def asdfsdf():
+    """Summary.
+
+Description.
+
+    """
+
+
+@expect('D207: Docstring is under-indented')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def asdsdfsdffsdf():
+    """Summary.
+
+    Description.
+
+"""
+
+
+@expect('D208: Docstring is over-indented')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def asdfsdsdf24():
+    """Summary.
+
+       Description.
+
+    """
+
+
+@expect('D208: Docstring is over-indented')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def asdfsdsdfsdf24():
+    """Summary.
+
+    Description.
+
+        """
+
+
+@expect('D208: Docstring is over-indented')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def asdfsdfsdsdsdfsdf24():
+    """Summary.
+
+        Description.
+
+    """
+
+
+@expect('D209: Multi-line docstring closing quotes should be on a separate '
+        'line')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def asdfljdf24():
+    """Summary.
+
+    Description."""
+
+
+@expect('D210: No whitespaces allowed surrounding docstring text')
+def endswith():
+    """Whitespace at the end. """
+
+
+@expect('D210: No whitespaces allowed surrounding docstring text')
+def around():
+    """ Whitespace at everywhere. """
+
+
+@expect('D210: No whitespaces allowed surrounding docstring text')
+@expect('D213: Multi-line docstring summary should start at the second line')
+def multiline():
+    """ Whitespace at the beginning.
+
+    This is the end.
+    """
+
+
+@expect('D300: Use """triple double quotes""" (found \'\'\'-quotes)')
+def triple_single_quotes_raw():
+    r'''Summary.'''
+
+
+@expect('D300: Use """triple double quotes""" (found \'\'\'-quotes)')
+def triple_single_quotes_raw_uppercase():
+    R'''Summary.'''
+
+
+@expect('D300: Use """triple double quotes""" (found \'-quotes)')
+def single_quotes_raw():
+    r'Summary.'
+
+
+@expect('D300: Use """triple double quotes""" (found \'-quotes)')
+def single_quotes_raw_uppercase():
+    R'Summary.'
+
+
+@expect('D300: Use """triple double quotes""" (found \'-quotes)')
+@expect('D301: Use r""" if any backslashes in a docstring')
+def single_quotes_raw_uppercase_backslash():
+    R'Sum\mary.'
+
+
+@expect('D301: Use r""" if any backslashes in a docstring')
+def double_quotes_backslash():
+    """Sum\\mary."""
+
+
+@expect('D301: Use r""" if any backslashes in a docstring')
+def double_quotes_backslash_uppercase():
+    R"""Sum\\mary."""
+
+
+@expect('D213: Multi-line docstring summary should start at the second line')
+def exceptions_of_D301():
+    """Exclude some backslashes from D301.
+
+    In particular, line continuations \
+    and unicode literals \u0394 and \N{GREEK CAPITAL LETTER DELTA}.
+    They are considered to be intentionally unescaped.
+    """
+
+
+@expect("D400: First line should end with a period (not 'y')")
+@expect("D415: First line should end with a period, question mark, "
+        "or exclamation point (not 'y')")
+def lwnlkjl():
+    """Summary"""
+
+
+@expect("D401: First line should be in imperative mood "
+        "(perhaps 'Return', not 'Returns')")
+def liouiwnlkjl():
+    """Returns foo."""
+
+
+@expect("D401: First line should be in imperative mood; try rephrasing "
+        "(found 'Constructor')")
+def sdgfsdg23245():
+    """Constructor for a foo."""
+
+
+@expect("D401: First line should be in imperative mood; try rephrasing "
+        "(found 'Constructor')")
+def sdgfsdg23245777():
+    """Constructor."""
+
+
+@expect('D402: First line should not be the function\'s "signature"')
+def foobar():
+    """Signature: foobar()."""
+
+
+@expect('D213: Multi-line docstring summary should start at the second line')
+def new_209():
+    """First line.
+
+    More lines.
+    """
+    pass
+
+
+@expect('D213: Multi-line docstring summary should start at the second line')
+def old_209():
+    """One liner.
+
+    Multi-line comments. OK to have extra blank line
+
+    """
+
+
+@expect("D103: Missing docstring in public function")
+def oneliner_d102(): return
+
+
+@expect("D400: First line should end with a period (not 'r')")
+@expect("D415: First line should end with a period, question mark,"
+        " or exclamation point (not 'r')")
+def oneliner_withdoc(): """One liner"""
+
+
+def ignored_decorator(func):   # noqa: D400,D401,D415
+    """Runs something"""
+    func()
+    pass
+
+
+def decorator_for_test(func):   # noqa: D400,D401,D415
+    """Runs something"""
+    func()
+    pass
+
+
+@ignored_decorator
+def oneliner_ignored_decorator(): """One liner"""
+
+
+@decorator_for_test
+@expect("D400: First line should end with a period (not 'r')")
+@expect("D415: First line should end with a period, question mark,"
+        " or exclamation point (not 'r')")
+def oneliner_with_decorator_expecting_errors(): """One liner"""
+
+
+@decorator_for_test
+def valid_oneliner_with_decorator(): """One liner."""
+
+
+@expect("D207: Docstring is under-indented")
+@expect('D213: Multi-line docstring summary should start at the second line')
+def docstring_start_in_same_line(): """First Line.
+
+    Second Line
+    """
+
+
+def function_with_lambda_arg(x=lambda y: y):
+    """Wrap the given lambda."""
+
+
+@expect('D213: Multi-line docstring summary should start at the second line')
+def a_following_valid_function(x=None):
+    """Check for a bug where the previous function caused an assertion.
+
+    The assertion was caused in the next function, so this one is necessary.
+
+    """
+
+
+def outer_function():
+    """Do something."""
+    def inner_function():
+        """Do inner something."""
+        return 0
+
+
+@expect("D400: First line should end with a period (not 'g')")
+@expect("D401: First line should be in imperative mood "
+        "(perhaps 'Run', not 'Runs')")
+@expect("D415: First line should end with a period, question mark, "
+        "or exclamation point (not 'g')")
+def docstring_bad():
+    """Runs something"""
+    pass
+
+
+def docstring_bad_ignore_all():  # noqa
+    """Runs something"""
+    pass
+
+
+def docstring_bad_ignore_one():  # noqa: D400,D401,D415
+    """Runs something"""
+    pass
+
+
+@expect("D401: First line should be in imperative mood "
+        "(perhaps 'Run', not 'Runs')")
+def docstring_ignore_some_violations_but_catch_D401():  # noqa: E501,D400,D415
+    """Runs something"""
+    pass
+
+
+@expect(
+    "D401: First line should be in imperative mood "
+    "(perhaps 'Initiate', not 'Initiates')"
+)
+def docstring_initiates():
+    """Initiates the process."""
+
+
+@expect(
+    "D401: First line should be in imperative mood "
+    "(perhaps 'Initialize', not 'Initializes')"
+)
+def docstring_initializes():
+    """Initializes the process."""
+
+
+@wraps(docstring_bad_ignore_one)
+def bad_decorated_function():
+    """Bad (E501) but decorated"""
+    pass
+
+
+def valid_google_string():  # noqa: D400
+    """Test a valid something!"""
+
+
+@expect("D415: First line should end with a period, question mark, "
+        "or exclamation point (not 'g')")
+def bad_google_string():  # noqa: D400
+    """Test a valid something"""
+
+
+# This is reproducing a bug where AttributeError is raised when parsing class
+# parameters as functions for Google / Numpy conventions.
+class Blah:  # noqa: D203,D213
+    """A Blah.
+
+    Parameters
+    ----------
+    x : int
+
+    """
+
+    def __init__(self, x):
+        pass
+
+
+expect(os.path.normcase(__file__ if __file__[-1] != 'c' else __file__[:-1]),
+       'D100: Missing docstring in public module')

resources/test/fixtures/E402.py

@@ -1,4 +1,8 @@
 """Top-level docstring."""
+
+__all__ = ["y"]
+__version__: str = "0.1.0"
+
 import a
 
 try:

resources/test/fixtures/E501.py

@@ -4,3 +4,13 @@
 
 Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 """
+
+_ = """Lorem ipsum dolor sit amet.
+
+    https://github.com/PyCQA/pycodestyle/pull/258/files#diff-841c622497a8033d10152bfdfb15b20b92437ecdea21a260944ea86b77b51533
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+"""  # noqa: E501
+
+_ = "---------------------------------------------------------------------------AAAAAAA"
+_ = "---------------------------------------------------------------------------亜亜亜亜亜亜亜"

resources/test/fixtures/E711.py

@@ -1,11 +1,50 @@
-if var == None:
+#: E711
+if res == None:
+    pass
+#: E711
+if res != None:
+    pass
+#: E711
+if None == res:
+    pass
+#: E711
+if None != res:
+    pass
+#: E711
+if res[1] == None:
+    pass
+#: E711
+if res[1] != None:
+    pass
+#: E711
+if None != res[1]:
+    pass
+#: E711
+if None == res[1]:
     pass
 
-if None != var:
+#: Okay
+if x not in y:
     pass
 
-if var is None:
+if not (X in Y or X is Z):
     pass
 
-if None is not var:
+if not (X in Y):
     pass
+
+if x is not y:
+    pass
+
+if X is not Y is not Z:
+    pass
+
+if TrueElement.get_element(True) == TrueElement.get_element(False):
+    pass
+
+if (True) == TrueElement or x == TrueElement:
+    pass
+
+assert (not foo) in bar
+assert {"x": not foo} in bar
+assert [42, not foo] in bar

resources/test/fixtures/E712.py

@@ -1,14 +1,46 @@
-if var == True:
+#: E712
+if res == True:
+    pass
+#: E712
+if res != False:
+    pass
+#: E712
+if True != res:
+    pass
+#: E712
+if False == res:
+    pass
+#: E712
+if res[1] == True:
+    pass
+#: E712
+if res[1] != False:
+    pass
+#: E712
+var = 1 if cond == True else -1 if cond == False else cond
+#: E712
+if (True) == TrueElement or x == TrueElement:
     pass
 
-if False != var:
+#: Okay
+if x not in y:
     pass
 
-if var != False != True:
+if not (X in Y or X is Z):
     pass
 
-if var is True:
+if not (X in Y):
     pass
 
-if False is not var:
+if x is not y:
     pass
+
+if X is not Y is not Z:
+    pass
+
+if TrueElement.get_element(True) == TrueElement.get_element(False):
+    pass
+
+assert (not foo) in bar
+assert {"x": not foo} in bar
+assert [42, not foo] in bar

resources/test/fixtures/E713.py

@@ -1,7 +1,38 @@
-my_list = [1, 2, 3]
-if not num in my_list:
-    print(num)
+#: E713
+if not X in Y:
+    pass
+#: E713
+if not X.B in Y:
+    pass
+#: E713
+if not X in Y and Z == "zero":
+    pass
+#: E713
+if X == "zero" or not Y in Z:
+    pass
+#: E713
+if not (X in Y):
+    pass
 
-my_list = [1, 2, 3]
-if num not in my_list:
-    print(num)
+#: Okay
+if x not in y:
+    pass
+
+if not (X in Y or X is Z):
+    pass
+
+if x is not y:
+    pass
+
+if X is not Y is not Z:
+    pass
+
+if TrueElement.get_element(True) == TrueElement.get_element(False):
+    pass
+
+if (True) == TrueElement or x == TrueElement:
+    pass
+
+assert (not foo) in bar
+assert {"x": not foo} in bar
+assert [42, not foo] in bar

resources/test/fixtures/E714.py

@@ -1,5 +1,38 @@
-if not user is None:
-    print(user.name)
+#: E714
+if not X is Y:
+    pass
+#: E714
+if not X.B is Y:
+    pass
+#: E714
+if not X is Y is not Z:
+    pass
 
-if user is not None:
-    print(user.name)
+#: Okay
+if not X is not Y:
+    pass
+
+if x not in y:
+    pass
+
+if not (X in Y or X is Z):
+    pass
+
+if not (X in Y):
+    pass
+
+if x is not y:
+    pass
+
+if X is not Y is not Z:
+    pass
+
+if TrueElement.get_element(True) == TrueElement.get_element(False):
+    pass
+
+if (True) == TrueElement or x == TrueElement:
+    pass
+
+assert (not foo) in bar
+assert {"x": not foo} in bar
+assert [42, not foo] in bar

resources/test/fixtures/E721.py

@@ -0,0 +1,54 @@
+#: E721
+if type(res) == type(42):
+    pass
+#: E721
+if type(res) != type(""):
+    pass
+#: E721
+import types
+
+if res == types.IntType:
+    pass
+#: E721
+import types
+
+if type(res) is not types.ListType:
+    pass
+#: E721
+assert type(res) == type(False) or type(res) == type(None)
+#: E721
+assert type(res) == type([])
+#: E721
+assert type(res) == type(())
+#: E721
+assert type(res) == type((0,))
+#: E721
+assert type(res) == type((0))
+#: E721
+assert type(res) != type((1,))
+#: E721
+assert type(res) is type((1,))
+#: E721
+assert type(res) is not type((1,))
+#: E211 E721
+assert type(res) == type(
+    [
+        2,
+    ]
+)
+#: E201 E201 E202 E721
+assert type(res) == type(())
+#: E201 E202 E721
+assert type(res) == type((0,))
+
+#: Okay
+import types
+
+if isinstance(res, int):
+    pass
+if isinstance(res, str):
+    pass
+if isinstance(res, types.MethodType):
+    pass
+if type(a) != type(b) or type(a) == type(ccc):
+    pass

resources/test/fixtures/E722.py

@@ -0,0 +1,33 @@
+#: E722
+try:
+    pass
+except:
+    pass
+#: E722
+try:
+    pass
+except Exception:
+    pass
+except:
+    pass
+#: E722
+try:
+    pass
+except:
+    pass
+#: Okay
+fake_code = """"
+try:
+    do_something()
+except:
+    pass
+"""
+try:
+    pass
+except Exception:
+    pass
+#: Okay
+from . import compute_type
+
+if compute_type(foo) == 5:
+    pass

resources/test/fixtures/E731.py

@@ -1,6 +1,21 @@
-from typing import Callable, Iterable
+#: E731
+f = lambda x: 2 * x
+#: E731
+f = lambda x: 2 * x
+#: E731
+while False:
+    this = lambda y, z: 2 * x
 
-a = lambda x: x**2
-b = map(lambda x: 2 * x, range(3))
-c: Callable = lambda x: x**2
-d: Iterable = map(lambda x: 2 * x, range(3))
+
+f = object()
+#: E731
+f.method = lambda: "Method"
+
+f = {}
+#: E731
+f["a"] = lambda x: x ** 2
+
+f = []
+f.append(lambda x: x ** 2)
+
+lambda: "no-op"

resources/test/fixtures/E741.py

@@ -0,0 +1,75 @@
+from contextlib import contextmanager
+
+l = 0
+I = 0
+O = 0
+l: int = 0
+
+a, l = 0, 1
+[a, l] = 0, 1
+a, *l = 0, 1, 2
+a = l = 0
+
+o = 0
+i = 0
+
+for l in range(3):
+    pass
+
+
+for a, l in zip(range(3), range(3)):
+    pass
+
+
+def f1():
+    global l
+    l = 0
+
+
+def f2():
+    l = 0
+
+    def f3():
+        nonlocal l
+        l = 1
+
+    f3()
+    return l
+
+
+def f4(l, /, I):
+    return l, I, O
+
+
+def f5(l=0, *, I=1):
+    return l, I
+
+
+def f6(*l, **I):
+    return l, I
+
+
+@contextmanager
+def ctx1():
+    yield 0
+
+
+with ctx1() as l:
+    pass
+
+
+@contextmanager
+def ctx2():
+    yield 0, 1
+
+
+with ctx2() as (a, l):
+    pass
+
+try:
+    pass
+except ValueError as l:
+    pass
+
+if (l := 5) > 0:
+    pass

resources/test/fixtures/E742.py

@@ -0,0 +1,14 @@
+class l:
+    pass
+
+
+class I:
+    pass
+
+
+class O:
+    pass
+
+
+class X:
+    pass

resources/test/fixtures/E743.py

@@ -0,0 +1,15 @@
+def l():
+    pass
+
+
+def I():
+    pass
+
+
+class X:
+    def O(self):
+        pass
+
+
+def x():
+    pass

resources/test/fixtures/E999.py

@@ -0,0 +1,2 @@
+def x():
+

resources/test/fixtures/F401.py

@@ -1,41 +0,0 @@
-from __future__ import all_feature_names
-import os
-import functools
-from datetime import datetime
-from collections import (
-    Counter,
-    OrderedDict,
-    namedtuple,
-)
-import multiprocessing.pool
-import multiprocessing.process
-import logging.config
-import logging.handlers
-from typing import TYPING_CHECK, NamedTuple, Dict, Type, TypeVar, List, Set, Union, cast
-
-from blah import ClassA, ClassB, ClassC
-
-if TYPING_CHECK:
-    from models import Fruit, Nut, Vegetable
-
-
-class X:
-    datetime: datetime
-    foo: Type["NamedTuple"]
-
-    def a(self) -> "namedtuple":
-        x = os.environ["1"]
-        y = Counter()
-        z = multiprocessing.pool.ThreadPool()
-
-
-__all__ = ["ClassA"] + ["ClassB"]
-__all__ += ["ClassC"]
-
-X = TypeVar("X")
-Y = TypeVar("Y", bound="Dict")
-Z = TypeVar("Z", "List", "Set")
-
-a = list["Fruit"]
-b = Union["Nut", None]
-c = cast("Vegetable", b)

resources/test/fixtures/F401_0.py

@@ -0,0 +1,88 @@
+from __future__ import all_feature_names
+import functools, os
+from datetime import datetime
+from collections import (
+    Counter,
+    OrderedDict,
+    namedtuple,
+)
+import multiprocessing.pool
+import multiprocessing.process
+import logging.config
+import logging.handlers
+from typing import (
+    TYPE_CHECKING,
+    NamedTuple,
+    Dict,
+    Type,
+    TypeVar,
+    List,
+    Set,
+    Union,
+    cast,
+)
+from dataclasses import MISSING, field
+
+from blah import ClassA, ClassB, ClassC
+
+if TYPE_CHECKING:
+    from models import Fruit, Nut, Vegetable
+
+
+if TYPE_CHECKING:
+    import shelve
+    import importlib
+
+if TYPE_CHECKING:
+    """Hello, world!"""
+    import pathlib
+
+    z = 1
+
+
+class X:
+    datetime: datetime
+    foo: Type["NamedTuple"]
+
+    def a(self) -> "namedtuple":
+        x = os.environ["1"]
+        y = Counter()
+        z = multiprocessing.pool.ThreadPool()
+
+    def b(self) -> None:
+        import pickle
+
+
+__all__ = ["ClassA"] + ["ClassB"]
+__all__ += ["ClassC"]
+
+X = TypeVar("X")
+Y = TypeVar("Y", bound="Dict")
+Z = TypeVar("Z", "List", "Set")
+
+a = list["Fruit"]
+b = Union["Nut", None]
+c = cast("Vegetable", b)
+
+Field = lambda default=MISSING: field(default=default)
+
+
+# Test: access a sub-importation via an alias.
+import pyarrow as pa
+import pyarrow.csv
+
+print(pa.csv.read_csv("test.csv"))
+
+
+# Test: referencing an import via TypeAlias.
+import sys
+
+import numpy as np
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+CustomInt: TypeAlias = "np.int8 | np.int16"

resources/test/fixtures/F401_1.py

@@ -0,0 +1,5 @@
+"""Access a sub-importation via an alias."""
+import pyarrow as pa
+import pyarrow.csv
+
+print(pa.csv.read_csv("test.csv"))

resources/test/fixtures/F401_2.py

@@ -0,0 +1,12 @@
+"""Test: referencing an import via TypeAlias."""
+import sys
+
+import numpy as np
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+CustomInt: TypeAlias = "np.int8 | np.int16"

resources/test/fixtures/F401_3.py

@@ -0,0 +1,14 @@
+"""Test: referencing an import via TypeAlias (with future annotations)."""
+from __future__ import annotations
+
+import sys
+
+import numpy as np
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+CustomInt: TypeAlias = np.int8 | np.int16

resources/test/fixtures/F401_4.py

@@ -0,0 +1,14 @@
+"""Test: referencing an import via TypeAlias (with future annotations and quotes)."""
+from __future__ import annotations
+
+import sys
+
+import numpy as np
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+CustomInt: TypeAlias = "np.int8 | np.int16"

resources/test/fixtures/F402.py

@@ -0,0 +1,9 @@
+import os
+import os.path as path
+
+
+for os in range(3):
+    pass
+
+for path in range(3):
+    pass

resources/test/fixtures/F404.py

@@ -0,0 +1,6 @@
+"""Docstring"""
+from __future__ import absolute_import
+
+from collections import namedtuple
+
+from __future__ import print_function

resources/test/fixtures/F405.py

@@ -0,0 +1,11 @@
+from mymodule import *
+
+
+def print_name():
+    print(name)
+
+
+def print_name(name):
+    print(name)
+
+__all__ = ['a']

resources/test/fixtures/F406.py

@@ -0,0 +1,9 @@
+from F634 import *
+
+
+def f():
+    from F634 import *
+
+
+class F:
+    from F634 import *

resources/test/fixtures/F407.py

@@ -0,0 +1,2 @@
+from __future__ import print_function
+from __future__ import non_existent_feature

resources/test/fixtures/F632.py

@@ -0,0 +1,5 @@
+if x is "abc":
+    pass
+
+if 123 is not y:
+    pass

resources/test/fixtures/F633.py

@@ -0,0 +1,4 @@
+from __future__ import print_function
+import sys
+
+print >> sys.stderr, "Hello"

resources/test/fixtures/F701.py

@@ -0,0 +1,23 @@
+for i in range(10):
+    break
+else:
+    break
+
+i = 0
+while i < 10:
+    i += 1
+    break
+
+
+def f():
+    for i in range(10):
+        break
+
+    break
+
+
+class Foo:
+    break
+
+
+break

resources/test/fixtures/F702.py

@@ -0,0 +1,23 @@
+for i in range(10):
+    continue
+else:
+    continue
+
+i = 0
+while i < 10:
+    i += 1
+    continue
+
+
+def f():
+    for i in range(10):
+        continue
+
+    continue
+
+
+class Foo:
+    continue
+
+
+continue

resources/test/fixtures/F722.py

@@ -0,0 +1,10 @@
+class A:
+    pass
+
+
+def f() -> "A":
+    pass
+
+
+def g() -> "///":
+    pass

resources/test/fixtures/F821.py

@@ -77,3 +77,57 @@ class Ticket:
 
     def set_status(self, status: Status):
         self.status = status
+
+
+def update_tomato():
+    print(TOMATO)
+    TOMATO = "cherry tomato"
+
+
+A = f'{B}'
+A = (
+    f'B'
+    f'{B}'
+)
+
+
+from typing import Annotated, Literal
+
+
+def arbitrary_callable() -> None:
+    ...
+
+
+class PEP593Test:
+    field: Annotated[
+        int,
+        "base64",
+        arbitrary_callable(),
+        123,
+        (1, 2, 3),
+    ]
+    field_with_stringified_type: Annotated[
+        "PEP593Test",
+        123,
+    ]
+    field_with_undefined_stringified_type: Annotated[
+        "PEP593Test123",
+        123,
+    ]
+    field_with_nested_subscript: Annotated[
+        dict[Literal["foo"], str],
+        123,
+    ]
+    field_with_undefined_nested_subscript: Annotated[
+        dict["foo", "bar"],  # Expected to fail as undefined.
+        123,
+    ]
+
+
+def in_ipython_notebook() -> bool:
+    try:
+        # autoimported by notebooks
+        get_ipython()  # type: ignore[name-defined]
+    except NameError:
+        return False  # not in notebook
+    return True

resources/test/fixtures/F841.py

@@ -10,7 +10,28 @@ except ValueError as e:
     print(e)
 
 
-def f():
+def f1():
     x = 1
     y = 2
     z = x + y
+
+
+def f2():
+    foo = (1, 2)
+    (a, b) = (1, 2)
+
+    bar = (1, 2)
+    (c, d) = bar
+
+    (x, y) = baz = bar
+
+
+def f3():
+    locals()
+    x = 1
+
+
+def f4():
+    _ = 1
+    __ = 1
+    _discarded = 1

resources/test/fixtures/M001.py

@@ -0,0 +1,60 @@
+def f() -> None:
+    # Valid
+    a = 1  # noqa
+
+    # Valid
+    b = 2  # noqa: F841
+
+    # Invalid
+    c = 1  # noqa
+    print(c)
+
+    # Invalid
+    d = 1  # noqa: E501
+
+    # Invalid
+    d = 1  # noqa: F841, E501
+
+    # Invalid (and unimplemented)
+    d = 1  # noqa: F841, W191
+
+
+# Valid
+_ = """Lorem ipsum dolor sit amet.
+
+    https://github.com/PyCQA/pycodestyle/pull/258/files#diff-841c622497a8033d10152bfdfb15b20b92437ecdea21a260944ea86b77b51533
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+"""  # noqa: E501
+
+# Valid
+_ = """Lorem ipsum dolor sit amet.
+
+    https://github.com/PyCQA/pycodestyle/pull/258/files#diff-841c622497a8033d10152bfdfb15b20b92437ecdea21a260944ea86b77b51533
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+"""  # noqa
+
+# Invalid
+_ = """Lorem ipsum dolor sit amet.
+
+    https://github.com/PyCQA/pycodestyle/pull/258/files#diff-841c622497a8033d10152bfdfb15b20b92437ecdea21a260944ea86b77b51533
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+"""  # noqa: E501, F841
+
+# Invalid
+_ = """Lorem ipsum dolor sit amet.
+
+    https://github.com/PyCQA/pycodestyle/pull/258/files#diff-841c622497a8033d10152bfdfb15b20b92437ecdea21a260944ea86b77b51533
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor.
+"""  # noqa: E501
+
+# Invalid
+_ = """Lorem ipsum dolor sit amet.
+
+    https://github.com/PyCQA/pycodestyle/pull/258/files#diff-841c622497a8033d10152bfdfb15b20b92437ecdea21a260944ea86b77b51533
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor.
+"""  # noqa

resources/test/fixtures/R002.py

@@ -1,3 +0,0 @@
-self.assertEquals (1, 2)
-self.assertEquals(1, 2)
-self.assertEqual(3, 4)

resources/test/fixtures/T201.py

@@ -0,0 +1 @@
+print("Hello, world!")  # T201

resources/test/fixtures/T203.py

@@ -0,0 +1,10 @@
+from pprint import pprint
+
+pprint("Hello, world!")  # T203
+
+
+import pprint
+
+pprint.pprint("Hello, world!")  # T203
+
+pprint.pformat("Hello, world!")

resources/test/fixtures/U001.py

@@ -0,0 +1,13 @@
+class A:
+    __metaclass__ = type
+
+
+class B:
+    __metaclass__ = type
+
+    def __init__(self) -> None:
+        pass
+
+
+class C(metaclass=type):
+    pass

resources/test/fixtures/U002.py

@@ -0,0 +1,15 @@
+from os.path import abspath
+
+x = abspath(__file__)
+
+
+import os
+
+
+y = os.path.abspath(__file__)
+
+
+from os import path
+
+
+z = path.abspath(__file__)

resources/test/fixtures/U003.py

@@ -0,0 +1,5 @@
+type('')
+type(b'')
+type(0)
+type(0.)
+type(0j)

resources/test/fixtures/U005.py

@@ -0,0 +1,10 @@
+import unittest
+
+
+class Suite(unittest.TestCase):
+    def test(self) -> None:
+        self.assertEquals (1, 2)
+        self.assertEquals(1, 2)
+        self.assertEqual(3, 4)
+        self.failUnlessAlmostEqual(1, 1.1)
+        self.assertNotRegexpMatches("a", "b")

resources/test/fixtures/U006.py

@@ -0,0 +1,12 @@
+from typing import List
+
+
+def f(x: List[str]) -> None:
+    ...
+
+
+import typing
+
+
+def f(x: typing.List[str]) -> None:
+    ...

resources/test/fixtures/U007.py

@@ -0,0 +1,40 @@
+from typing import Optional
+
+
+def f(x: Optional[str]) -> None:
+    ...
+
+
+import typing
+
+
+def f(x: typing.Optional[str]) -> None:
+    ...
+
+
+from typing import Union
+
+
+def f(x: Union[str, int, Union[float, bytes]]) -> None:
+    ...
+
+
+import typing
+
+
+def f(x: typing.Union[str, int]) -> None:
+    ...
+
+
+from typing import Union
+
+
+def f(x: "Union[str, int, Union[float, bytes]]") -> None:
+    ...
+
+
+import typing
+
+
+def f(x: "typing.Union[str, int]") -> None:
+    ...

resources/test/fixtures/U008.py

@@ -0,0 +1,65 @@
+class Parent:
+    def method(self):
+        pass
+
+    def wrong(self):
+        pass
+
+
+class Child(Parent):
+    def method(self):
+        parent = super()  # ok
+        super().method()  # ok
+        Parent.method(self)  # ok
+        Parent.super(1, 2)  # ok
+
+    def wrong(self):
+        parent = super(Child, self)  # wrong
+        super(Child, self).method  # wrong
+        super(
+            Child,
+            self,
+        ).method()  # wrong
+
+
+class BaseClass:
+    def f(self):
+        print("f")
+
+
+def defined_outside(self):
+    super(MyClass, self).f()  # CANNOT use super()
+
+
+class MyClass(BaseClass):
+    def normal(self):
+        super(MyClass, self).f()  # can use super()
+        super().f()
+
+    def different_argument(self, other):
+        super(MyClass, other).f()  # CANNOT use super()
+
+    def comprehension_scope(self):
+        [super(MyClass, self).f() for x in [1]]  # CANNOT use super()
+
+    def inner_functions(self):
+        def outer_argument():
+            super(MyClass, self).f()  # CANNOT use super()
+
+        def inner_argument(self):
+            super(MyClass, self).f()  # can use super()
+            super().f()
+
+        outer_argument()
+        inner_argument(self)
+
+    def inner_class(self):
+        class InnerClass:
+            super(MyClass, self).f()  # CANNOT use super()
+
+            def method(inner_self):
+                super(MyClass, self).f()  # CANNOT use super()
+
+        InnerClass().method()
+
+    defined_outside = defined_outside

resources/test/fixtures/W292_0.py

@@ -0,0 +1,2 @@
+def fn() -> None:
+    pass

resources/test/fixtures/W292_1.py

@@ -0,0 +1,2 @@
+def fn() -> None:
+    pass  # noqa: W292

resources/test/fixtures/W292_2.py

@@ -0,0 +1,2 @@
+def fn() -> None:
+    pass

resources/test/fixtures/__init__.py

@@ -0,0 +1,3 @@
+print(__path__)
+
+__all__ = ["a", "b", "c"]

resources/test/fixtures/directory/also_excluded.py

@@ -0,0 +1,9 @@
+a = "abc"
+b = f"ghi{'jkl'}"
+
+c = f"def"
+d = f"def" + "ghi"
+e = (
+    f"def" +
+    "ghi"
+)

resources/test/fixtures/future_annotations.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from models import (
+    Fruit,
+    Nut,
+)
+
+
+@dataclass
+class Foo:
+    x: int
+    y: int
+
+    @classmethod
+    def a(cls) -> Foo:
+        return cls(x=0, y=0)
+
+    @classmethod
+    def b(cls) -> "Foo":
+        return cls(x=0, y=0)
+
+    @classmethod
+    def c(cls) -> Bar:
+        return cls(x=0, y=0)
+
+    @classmethod
+    def d(cls) -> Fruit:
+        return cls(x=0, y=0)

resources/test/fixtures/pyproject.toml

@@ -1,33 +1,7 @@
 [tool.ruff]
 line-length = 88
-exclude = ["excluded.py", "**/migrations"]
-select = [
-    "E402",
-    "E501",
-    "E711",
-    "E712",
-    "E713",
-    "E714",
-    "E731",
-    "E902",
-    "F401",
-    "F403",
-    "F541",
-    "F601",
-    "F602",
-    "F621",
-    "F622",
-    "F631",
-    "F634",
-    "F704",
-    "F706",
-    "F707",
-    "F821",
-    "F822",
-    "F823",
-    "F831",
-    "F841",
-    "F901",
-    "R001",
-    "R002",
+extend-exclude = [
+    "excluded.py",
+    "migrations",
+    "directory/also_excluded.py",
 ]

setup.py

@@ -0,0 +1,23 @@
+import sys
+
+from setuptools import setup
+
+sys.stderr.write(
+    """
+===============================
+Unsupported installation method
+===============================
+ruff no longer supports installation with `python setup.py install`.
+Please use `python -m pip install .` instead.
+"""
+)
+sys.exit(1)
+
+
+# The below code will never execute, however GitHub is particularly
+# picky about where it finds Python packaging metadata.
+# See: https://github.com/github/feedback/discussions/6456
+#
+# To be removed once GitHub catches up.
+
+setup(name="ruff", install_requires=[])

src/ast.rs

@@ -1,4 +1,5 @@
-pub mod checks;
+pub mod checkers;
+pub mod helpers;
 pub mod operations;
 pub mod relocate;
 pub mod types;

src/ast/checks.rs

@@ -1,430 +0,0 @@
-use std::collections::BTreeSet;
-
-use itertools::izip;
-use rustpython_parser::ast::{
-    Arg, Arguments, Cmpop, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprKind, Keyword,
-    Location, Stmt, Unaryop,
-};
-
-use crate::ast::operations::SourceCodeLocator;
-use crate::ast::types::{Binding, BindingKind, Scope};
-use crate::autofix::{fixer, fixes};
-use crate::checks::{Check, CheckKind, Fix, RejectedCmpop};
-
-/// Check IfTuple compliance.
-pub fn check_if_tuple(test: &Expr, location: Location) -> Option<Check> {
-    if let ExprKind::Tuple { elts, .. } = &test.node {
-        if !elts.is_empty() {
-            return Some(Check::new(CheckKind::IfTuple, location));
-        }
-    }
-    None
-}
-
-/// Check AssertTuple compliance.
-pub fn check_assert_tuple(test: &Expr, location: Location) -> Option<Check> {
-    if let ExprKind::Tuple { elts, .. } = &test.node {
-        if !elts.is_empty() {
-            return Some(Check::new(CheckKind::AssertTuple, location));
-        }
-    }
-    None
-}
-
-/// Check NotInTest and NotIsTest compliance.
-pub fn check_not_tests(
-    op: &Unaryop,
-    operand: &Expr,
-    check_not_in: bool,
-    check_not_is: bool,
-) -> Vec<Check> {
-    let mut checks: Vec<Check> = vec![];
-
-    if matches!(op, Unaryop::Not) {
-        if let ExprKind::Compare { ops, .. } = &operand.node {
-            match ops[..] {
-                [Cmpop::In] => {
-                    if check_not_in {
-                        checks.push(Check::new(CheckKind::NotInTest, operand.location));
-                    }
-                }
-                [Cmpop::Is] => {
-                    if check_not_is {
-                        checks.push(Check::new(CheckKind::NotIsTest, operand.location));
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-
-    checks
-}
-
-/// Check UnusedVariable compliance.
-pub fn check_unused_variables(scope: &Scope) -> Vec<Check> {
-    let mut checks: Vec<Check> = vec![];
-
-    for (name, binding) in scope.values.iter() {
-        // TODO(charlie): Ignore if using `locals`.
-        if binding.used.is_none()
-            && name != "_"
-            && name != "__tracebackhide__"
-            && name != "__traceback_info__"
-            && name != "__traceback_supplement__"
-            && matches!(binding.kind, BindingKind::Assignment)
-        {
-            checks.push(Check::new(
-                CheckKind::UnusedVariable(name.to_string()),
-                binding.location,
-            ));
-        }
-    }
-
-    checks
-}
-
-/// Check DoNotAssignLambda compliance.
-pub fn check_do_not_assign_lambda(value: &Expr, location: Location) -> Option<Check> {
-    if let ExprKind::Lambda { .. } = &value.node {
-        Some(Check::new(CheckKind::DoNotAssignLambda, location))
-    } else {
-        None
-    }
-}
-
-/// Check UselessObjectInheritance compliance.
-pub fn check_useless_object_inheritance(
-    stmt: &Stmt,
-    name: &str,
-    bases: &[Expr],
-    keywords: &[Keyword],
-    scope: &Scope,
-    locator: &mut SourceCodeLocator,
-    autofix: &fixer::Mode,
-) -> Option<Check> {
-    for expr in bases {
-        if let ExprKind::Name { id, .. } = &expr.node {
-            if id == "object" {
-                match scope.values.get(id) {
-                    None
-                    | Some(Binding {
-                        kind: BindingKind::Builtin,
-                        ..
-                    }) => {
-                        let mut check = Check::new(
-                            CheckKind::UselessObjectInheritance(name.to_string()),
-                            expr.location,
-                        );
-                        if matches!(autofix, fixer::Mode::Generate)
-                            || matches!(autofix, fixer::Mode::Apply)
-                        {
-                            if let Some(fix) = fixes::remove_class_def_base(
-                                locator,
-                                &stmt.location,
-                                expr.location,
-                                bases,
-                                keywords,
-                            ) {
-                                check.amend(fix);
-                            }
-                        }
-                        return Some(check);
-                    }
-                    _ => {}
-                }
-            }
-        }
-    }
-
-    None
-}
-
-/// Check DefaultExceptNotLast compliance.
-pub fn check_default_except_not_last(handlers: &Vec<Excepthandler>) -> Option<Check> {
-    for (idx, handler) in handlers.iter().enumerate() {
-        let ExcepthandlerKind::ExceptHandler { type_, .. } = &handler.node;
-        if type_.is_none() && idx < handlers.len() - 1 {
-            return Some(Check::new(
-                CheckKind::DefaultExceptNotLast,
-                handler.location,
-            ));
-        }
-    }
-
-    None
-}
-
-/// Check RaiseNotImplemented compliance.
-pub fn check_raise_not_implemented(expr: &Expr) -> Option<Check> {
-    match &expr.node {
-        ExprKind::Call { func, .. } => {
-            if let ExprKind::Name { id, .. } = &func.node {
-                if id == "NotImplemented" {
-                    return Some(Check::new(CheckKind::RaiseNotImplemented, expr.location));
-                }
-            }
-        }
-        ExprKind::Name { id, .. } => {
-            if id == "NotImplemented" {
-                return Some(Check::new(CheckKind::RaiseNotImplemented, expr.location));
-            }
-        }
-        _ => {}
-    }
-
-    None
-}
-
-/// Check DuplicateArgumentName compliance.
-pub fn check_duplicate_arguments(arguments: &Arguments) -> Vec<Check> {
-    let mut checks: Vec<Check> = vec![];
-
-    // Collect all the arguments into a single vector.
-    let mut all_arguments: Vec<&Arg> = arguments
-        .args
-        .iter()
-        .chain(arguments.posonlyargs.iter())
-        .chain(arguments.kwonlyargs.iter())
-        .collect();
-    if let Some(arg) = &arguments.vararg {
-        all_arguments.push(arg);
-    }
-    if let Some(arg) = &arguments.kwarg {
-        all_arguments.push(arg);
-    }
-
-    // Search for duplicates.
-    let mut idents: BTreeSet<&str> = BTreeSet::new();
-    for arg in all_arguments {
-        let ident = &arg.node.arg;
-        if idents.contains(ident.as_str()) {
-            checks.push(Check::new(CheckKind::DuplicateArgumentName, arg.location));
-        }
-        idents.insert(ident);
-    }
-
-    checks
-}
-
-/// Check AssertEquals compliance.
-pub fn check_assert_equals(expr: &Expr, autofix: &fixer::Mode) -> Option<Check> {
-    if let ExprKind::Attribute { value, attr, .. } = &expr.node {
-        if attr == "assertEquals" {
-            if let ExprKind::Name { id, .. } = &value.node {
-                if id == "self" {
-                    let mut check = Check::new(CheckKind::NoAssertEquals, expr.location);
-                    if matches!(autofix, fixer::Mode::Generate)
-                        || matches!(autofix, fixer::Mode::Apply)
-                    {
-                        check.amend(Fix {
-                            content: "assertEqual".to_string(),
-                            start: Location::new(expr.location.row(), expr.location.column() + 1),
-                            end: Location::new(
-                                expr.location.row(),
-                                expr.location.column() + 1 + "assertEquals".len(),
-                            ),
-                            applied: false,
-                        });
-                    }
-                    return Some(check);
-                }
-            }
-        }
-    }
-    None
-}
-
-#[derive(Debug, PartialEq)]
-enum DictionaryKey<'a> {
-    Constant(&'a Constant),
-    Variable(&'a String),
-}
-
-fn convert_to_value(expr: &Expr) -> Option<DictionaryKey> {
-    match &expr.node {
-        ExprKind::Constant { value, .. } => Some(DictionaryKey::Constant(value)),
-        ExprKind::Name { id, .. } => Some(DictionaryKey::Variable(id)),
-        _ => None,
-    }
-}
-
-/// Check MultiValueRepeatedKeyLiteral and MultiValueRepeatedKeyVariable compliance.
-pub fn check_repeated_keys(
-    keys: &Vec<Expr>,
-    check_repeated_literals: bool,
-    check_repeated_variables: bool,
-) -> Vec<Check> {
-    let mut checks: Vec<Check> = vec![];
-
-    let num_keys = keys.len();
-    for i in 0..num_keys {
-        let k1 = &keys[i];
-        let v1 = convert_to_value(k1);
-        for k2 in keys.iter().take(num_keys).skip(i + 1) {
-            let v2 = convert_to_value(k2);
-            match (&v1, &v2) {
-                (Some(DictionaryKey::Constant(v1)), Some(DictionaryKey::Constant(v2))) => {
-                    if check_repeated_literals && v1 == v2 {
-                        checks.push(Check::new(
-                            CheckKind::MultiValueRepeatedKeyLiteral,
-                            k2.location,
-                        ))
-                    }
-                }
-                (Some(DictionaryKey::Variable(v1)), Some(DictionaryKey::Variable(v2))) => {
-                    if check_repeated_variables && v1 == v2 {
-                        checks.push(Check::new(
-                            CheckKind::MultiValueRepeatedKeyVariable(v2.to_string()),
-                            k2.location,
-                        ))
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-
-    checks
-}
-
-/// Check TrueFalseComparison and NoneComparison compliance.
-pub fn check_literal_comparisons(
-    left: &Expr,
-    ops: &Vec<Cmpop>,
-    comparators: &Vec<Expr>,
-    check_none_comparisons: bool,
-    check_true_false_comparisons: bool,
-) -> Vec<Check> {
-    let mut checks: Vec<Check> = vec![];
-
-    let op = ops.first().unwrap();
-    let comparator = left;
-
-    // Check `left`.
-    if check_none_comparisons
-        && matches!(
-            comparator.node,
-            ExprKind::Constant {
-                value: Constant::None,
-                kind: None
-            }
-        )
-    {
-        if matches!(op, Cmpop::Eq) {
-            checks.push(Check::new(
-                CheckKind::NoneComparison(RejectedCmpop::Eq),
-                comparator.location,
-            ));
-        }
-        if matches!(op, Cmpop::NotEq) {
-            checks.push(Check::new(
-                CheckKind::NoneComparison(RejectedCmpop::NotEq),
-                comparator.location,
-            ));
-        }
-    }
-
-    if check_true_false_comparisons {
-        if let ExprKind::Constant {
-            value: Constant::Bool(value),
-            kind: None,
-        } = comparator.node
-        {
-            if matches!(op, Cmpop::Eq) {
-                checks.push(Check::new(
-                    CheckKind::TrueFalseComparison(value, RejectedCmpop::Eq),
-                    comparator.location,
-                ));
-            }
-            if matches!(op, Cmpop::NotEq) {
-                checks.push(Check::new(
-                    CheckKind::TrueFalseComparison(value, RejectedCmpop::NotEq),
-                    comparator.location,
-                ));
-            }
-        }
-    }
-
-    // Check each comparator in order.
-    for (op, comparator) in izip!(ops, comparators) {
-        if check_none_comparisons
-            && matches!(
-                comparator.node,
-                ExprKind::Constant {
-                    value: Constant::None,
-                    kind: None
-                }
-            )
-        {
-            if matches!(op, Cmpop::Eq) {
-                checks.push(Check::new(
-                    CheckKind::NoneComparison(RejectedCmpop::Eq),
-                    comparator.location,
-                ));
-            }
-            if matches!(op, Cmpop::NotEq) {
-                checks.push(Check::new(
-                    CheckKind::NoneComparison(RejectedCmpop::NotEq),
-                    comparator.location,
-                ));
-            }
-        }
-
-        if check_true_false_comparisons {
-            if let ExprKind::Constant {
-                value: Constant::Bool(value),
-                kind: None,
-            } = comparator.node
-            {
-                if matches!(op, Cmpop::Eq) {
-                    checks.push(Check::new(
-                        CheckKind::TrueFalseComparison(value, RejectedCmpop::Eq),
-                        comparator.location,
-                    ));
-                }
-                if matches!(op, Cmpop::NotEq) {
-                    checks.push(Check::new(
-                        CheckKind::TrueFalseComparison(value, RejectedCmpop::NotEq),
-                        comparator.location,
-                    ));
-                }
-            }
-        }
-    }
-
-    checks
-}
-
-/// Check TwoStarredExpressions and TooManyExpressionsInStarredAssignment compliance.
-pub fn check_starred_expressions(
-    elts: &[Expr],
-    location: Location,
-    check_too_many_expressions: bool,
-    check_two_starred_expressions: bool,
-) -> Option<Check> {
-    let mut has_starred: bool = false;
-    let mut starred_index: Option<usize> = None;
-    for (index, elt) in elts.iter().enumerate() {
-        if matches!(elt.node, ExprKind::Starred { .. }) {
-            if has_starred && check_two_starred_expressions {
-                return Some(Check::new(CheckKind::TwoStarredExpressions, location));
-            }
-            has_starred = true;
-            starred_index = Some(index);
-        }
-    }
-
-    if check_too_many_expressions {
-        if let Some(starred_index) = starred_index {
-            if starred_index >= 1 << 8 || elts.len() - starred_index > 1 << 24 {
-                return Some(Check::new(
-                    CheckKind::TooManyExpressionsInStarredAssignment,
-                    location,
-                ));
-            }
-        }
-    }
-
-    None
-}

src/ast/helpers.rs

@@ -0,0 +1,133 @@
+use once_cell::sync::Lazy;
+use regex::Regex;
+use rustpython_ast::{Excepthandler, ExcepthandlerKind, Expr, ExprKind, StmtKind};
+
+use crate::python::typing;
+
+fn compose_call_path_inner<'a>(expr: &'a Expr, parts: &mut Vec<&'a str>) {
+    match &expr.node {
+        ExprKind::Call { func, .. } => {
+            compose_call_path_inner(func, parts);
+        }
+        ExprKind::Attribute { value, attr, .. } => {
+            compose_call_path_inner(value, parts);
+            parts.push(attr);
+        }
+        ExprKind::Name { id, .. } => {
+            parts.push(id);
+        }
+        _ => {}
+    }
+}
+
+pub fn compose_call_path(expr: &Expr) -> Option<String> {
+    let mut segments = vec![];
+    compose_call_path_inner(expr, &mut segments);
+    if segments.is_empty() {
+        None
+    } else {
+        Some(segments.join("."))
+    }
+}
+
+pub fn match_name_or_attr(expr: &Expr, target: &str) -> bool {
+    match &expr.node {
+        ExprKind::Attribute { attr, .. } => target == attr,
+        ExprKind::Name { id, .. } => target == id,
+        _ => false,
+    }
+}
+
+pub enum SubscriptKind {
+    AnnotatedSubscript,
+    PEP593AnnotatedSubscript,
+}
+
+pub fn match_annotated_subscript(expr: &Expr) -> Option<SubscriptKind> {
+    match &expr.node {
+        ExprKind::Attribute { attr, .. } => {
+            if typing::is_annotated_subscript(attr) {
+                Some(SubscriptKind::AnnotatedSubscript)
+            } else if typing::is_pep593_annotated_subscript(attr) {
+                Some(SubscriptKind::PEP593AnnotatedSubscript)
+            } else {
+                None
+            }
+        }
+        ExprKind::Name { id, .. } => {
+            if typing::is_annotated_subscript(id) {
+                Some(SubscriptKind::AnnotatedSubscript)
+            } else if typing::is_pep593_annotated_subscript(id) {
+                Some(SubscriptKind::PEP593AnnotatedSubscript)
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+static DUNDER_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"__[^\s]+__").unwrap());
+
+pub fn is_assignment_to_a_dunder(node: &StmtKind) -> bool {
+    // Check whether it's an assignment to a dunder, with or without a type annotation.
+    // This is what pycodestyle (as of 2.9.1) does.
+    match node {
+        StmtKind::Assign {
+            targets,
+            value: _,
+            type_comment: _,
+        } => {
+            if targets.len() != 1 {
+                return false;
+            }
+            match &targets[0].node {
+                ExprKind::Name { id, ctx: _ } => DUNDER_REGEX.is_match(id),
+                _ => false,
+            }
+        }
+        StmtKind::AnnAssign {
+            target,
+            annotation: _,
+            value: _,
+            simple: _,
+        } => match &target.node {
+            ExprKind::Name { id, ctx: _ } => DUNDER_REGEX.is_match(id),
+            _ => false,
+        },
+        _ => false,
+    }
+}
+
+/// Extract the names of all handled exceptions.
+pub fn extract_handler_names(handlers: &[Excepthandler]) -> Vec<String> {
+    let mut handler_names = vec![];
+    for handler in handlers {
+        match &handler.node {
+            ExcepthandlerKind::ExceptHandler { type_, .. } => {
+                if let Some(type_) = type_ {
+                    if let ExprKind::Tuple { elts, .. } = &type_.node {
+                        for type_ in elts {
+                            if let Some(name) = compose_call_path(type_) {
+                                handler_names.push(name);
+                            }
+                        }
+                    } else if let Some(name) = compose_call_path(type_) {
+                        handler_names.push(name);
+                    }
+                }
+            }
+        }
+    }
+    handler_names
+}
+
+/// Returns `true` if a call is an argumented `super` invocation.
+pub fn is_super_call_with_arguments(func: &Expr, args: &Vec<Expr>) -> bool {
+    // Check: is this a `super` call?
+    if let ExprKind::Name { id, .. } = &func.node {
+        id == "super" && !args.is_empty()
+    } else {
+        false
+    }
+}

src/ast/operations.rs

@@ -1,6 +1,6 @@
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Location, Stmt, StmtKind};
 
-use crate::ast::types::{BindingKind, Scope};
+use crate::ast::types::{BindingKind, Range, Scope};
 
 /// Extract the names bound to a given __all__ assignment.
 pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
@@ -22,7 +22,7 @@ pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
     if let StmtKind::AugAssign { .. } = &stmt.node {
         if let Some(binding) = scope.values.get("__all__") {
             if let BindingKind::Export(existing) = &binding.kind {
-                names.extend(existing.clone());
+                names.extend_from_slice(existing);
             }
         }
     }
@@ -70,9 +70,7 @@ pub fn extract_all_names(stmt: &Stmt, scope: &Scope) -> Vec<String> {
 pub fn on_conditional_branch(parent_stack: &[usize], parents: &[&Stmt]) -> bool {
     for index in parent_stack.iter().rev() {
         let parent = parents[*index];
-        if matches!(parent.node, StmtKind::If { .. })
-            || matches!(parent.node, StmtKind::While { .. })
-        {
+        if matches!(parent.node, StmtKind::If { .. } | StmtKind::While { .. }) {
             return true;
         }
         if let StmtKind::Expr { value } = &parent.node {
@@ -89,10 +87,10 @@ pub fn on_conditional_branch(parent_stack: &[usize], parents: &[&Stmt]) -> bool
 pub fn in_nested_block(parent_stack: &[usize], parents: &[&Stmt]) -> bool {
     for index in parent_stack.iter().rev() {
         let parent = parents[*index];
-        if matches!(parent.node, StmtKind::Try { .. })
-            || matches!(parent.node, StmtKind::If { .. })
-            || matches!(parent.node, StmtKind::With { .. })
-        {
+        if matches!(
+            parent.node,
+            StmtKind::Try { .. } | StmtKind::If { .. } | StmtKind::With { .. }
+        ) {
             return true;
         }
     }
@@ -100,6 +98,26 @@ pub fn in_nested_block(parent_stack: &[usize], parents: &[&Stmt]) -> bool {
     false
 }
 
+/// Check if a node represents an unpacking assignment.
+pub fn is_unpacking_assignment(stmt: &Stmt) -> bool {
+    if let StmtKind::Assign { targets, value, .. } = &stmt.node {
+        if !targets.iter().any(|child| {
+            matches!(
+                child.node,
+                ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. }
+            )
+        }) {
+            return false;
+        }
+        match &value.node {
+            ExprKind::Set { .. } | ExprKind::List { .. } | ExprKind::Tuple { .. } => return false,
+            _ => {}
+        }
+        return true;
+    }
+    false
+}
+
 /// Struct used to efficiently slice source code at (row, column) Locations.
 pub struct SourceCodeLocator<'a> {
     content: &'a str,
@@ -116,7 +134,7 @@ impl<'a> SourceCodeLocator<'a> {
         }
     }
 
-    pub fn slice_source_code(&mut self, location: &Location) -> &'a str {
+    fn init(&mut self) {
         if !self.initialized {
             let mut offset = 0;
             for i in self.content.lines() {
@@ -124,9 +142,40 @@ impl<'a> SourceCodeLocator<'a> {
                 offset += i.len();
                 offset += 1;
             }
+            self.offsets.push(offset);
             self.initialized = true;
         }
+    }
+
+    pub fn slice_source_code_at(&mut self, location: &Location) -> &'a str {
+        self.init();
         let offset = self.offsets[location.row() - 1] + location.column() - 1;
         &self.content[offset..]
     }
+
+    pub fn slice_source_code_range(&mut self, range: &Range) -> &'a str {
+        self.init();
+        let start = self.offsets[range.location.row() - 1] + range.location.column() - 1;
+        let end = self.offsets[range.end_location.row() - 1] + range.end_location.column() - 1;
+        &self.content[start..end]
+    }
+
+    pub fn partition_source_code_at(
+        &mut self,
+        outer: &Range,
+        inner: &Range,
+    ) -> (&'a str, &'a str, &'a str) {
+        self.init();
+        let outer_start = self.offsets[outer.location.row() - 1] + outer.location.column() - 1;
+        let outer_end =
+            self.offsets[outer.end_location.row() - 1] + outer.end_location.column() - 1;
+        let inner_start = self.offsets[inner.location.row() - 1] + inner.location.column() - 1;
+        let inner_end =
+            self.offsets[inner.end_location.row() - 1] + inner.end_location.column() - 1;
+        (
+            &self.content[outer_start..inner_start],
+            &self.content[inner_start..inner_end],
+            &self.content[inner_end..outer_end],
+        )
+    }
 }

src/ast/relocate.rs

@@ -1,13 +1,17 @@
-use rustpython_parser::ast::{Expr, ExprKind, Keyword, Location};
+use rustpython_parser::ast::{Expr, ExprKind, Keyword};
 
-fn relocate_keyword(keyword: &mut Keyword, location: Location) {
-    keyword.location = location;
+use crate::ast::types::Range;
+
+fn relocate_keyword(keyword: &mut Keyword, location: Range) {
+    keyword.location = location.location;
+    keyword.end_location = location.end_location;
     relocate_expr(&mut keyword.node.value, location);
 }
 
 /// Change an expression's location (recursively) to match a desired, fixed location.
-pub fn relocate_expr(expr: &mut Expr, location: Location) {
-    expr.location = location;
+pub fn relocate_expr(expr: &mut Expr, location: Range) {
+    expr.location = location.location;
+    expr.end_location = location.end_location;
     match &mut expr.node {
         ExprKind::BoolOp { values, .. } => {
             for expr in values {

src/ast/types.rs

@@ -1,17 +1,37 @@
 use std::collections::BTreeMap;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-use rustpython_parser::ast::Location;
+use rustpython_parser::ast::{Located, Location};
 
 fn id() -> usize {
     static COUNTER: AtomicUsize = AtomicUsize::new(1);
     COUNTER.fetch_add(1, Ordering::Relaxed)
 }
 
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Range {
+    pub location: Location,
+    pub end_location: Location,
+}
+
+impl Range {
+    pub fn from_located<T>(located: &Located<T>) -> Self {
+        Range {
+            location: located.location,
+            end_location: located.end_location,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct FunctionScope {
+    pub uses_locals: bool,
+}
+
 #[derive(Clone, Debug)]
 pub enum ScopeKind {
     Class,
-    Function,
+    Function(FunctionScope),
     Generator,
     Module,
 }
@@ -20,6 +40,7 @@ pub enum ScopeKind {
 pub struct Scope {
     pub id: usize,
     pub kind: ScopeKind,
+    pub import_starred: bool,
     pub values: BTreeMap<String, Binding>,
 }
 
@@ -28,28 +49,51 @@ impl Scope {
         Scope {
             id: id(),
             kind,
+            import_starred: false,
             values: BTreeMap::new(),
         }
     }
 }
 
+#[derive(Clone, Debug)]
+pub struct BindingContext {
+    pub defined_by: usize,
+    pub defined_in: Option<usize>,
+}
+
 #[derive(Clone, Debug)]
 pub enum BindingKind {
+    Annotation,
     Argument,
     Assignment,
+    Binding,
+    LoopVar,
     Builtin,
     ClassDefinition,
     Definition,
     Export(Vec<String>),
     FutureImportation,
-    Importation(String),
     StarImportation,
-    SubmoduleImportation(String),
+    Importation(String, String, BindingContext),
+    FromImportation(String, String, BindingContext),
+    SubmoduleImportation(String, String, BindingContext),
 }
 
 #[derive(Clone, Debug)]
 pub struct Binding {
     pub kind: BindingKind,
-    pub location: Location,
-    pub used: Option<usize>,
+    pub range: Range,
+    /// Tuple of (scope index, range) indicating the scope and range at which the binding was
+    /// last used.
+    pub used: Option<(usize, Range)>,
+}
+
+pub trait CheckLocator {
+    fn locate_check(&self, default: Range) -> Range;
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ImportKind {
+    Import,
+    ImportFrom,
 }

src/ast/visitor.rs

@@ -4,6 +4,8 @@ use rustpython_parser::ast::{
     PatternKind, Stmt, StmtKind, Unaryop, Withitem,
 };
 
+use crate::ast::helpers::match_name_or_attr;
+
 pub trait Visitor<'a> {
     fn visit_stmt(&mut self, stmt: &'a Stmt) {
         walk_stmt(self, stmt);
@@ -148,7 +150,11 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
         } => {
             visitor.visit_annotation(annotation);
             if let Some(expr) = value {
-                visitor.visit_expr(expr);
+                if match_name_or_attr(annotation, "TypeAlias") {
+                    visitor.visit_annotation(expr);
+                } else {
+                    visitor.visit_expr(expr);
+                }
             }
             visitor.visit_expr(target);
         }

src/autofix/fixer.rs

@@ -2,6 +2,7 @@ use std::fs;
 use std::path::Path;
 
 use anyhow::Result;
+use itertools::Itertools;
 use rustpython_parser::ast::Location;
 
 use crate::checks::{Check, Fix};
@@ -43,41 +44,46 @@ fn apply_fixes<'a>(fixes: impl Iterator<Item = &'a mut Fix>, contents: &str) ->
     let mut output = "".to_string();
     let mut last_pos: Location = Location::new(0, 0);
 
-    for fix in fixes {
+    for fix in fixes.sorted_by_key(|fix| fix.location) {
         // Best-effort approach: if this fix overlaps with a fix we've already applied, skip it.
-        if last_pos > fix.start {
+        if last_pos > fix.location {
             continue;
         }
 
-        if fix.start.row() > last_pos.row() {
+        if fix.location.row() > last_pos.row() {
             if last_pos.row() > 0 || last_pos.column() > 0 {
                 output.push_str(&lines[last_pos.row() - 1][last_pos.column() - 1..]);
                 output.push('\n');
             }
-            for line in &lines[last_pos.row()..fix.start.row() - 1] {
+            for line in &lines[last_pos.row()..fix.location.row() - 1] {
                 output.push_str(line);
                 output.push('\n');
             }
-            output.push_str(&lines[fix.start.row() - 1][..fix.start.column() - 1]);
+            output.push_str(&lines[fix.location.row() - 1][..fix.location.column() - 1]);
             output.push_str(&fix.content);
         } else {
             output.push_str(
-                &lines[last_pos.row() - 1][last_pos.column() - 1..fix.start.column() - 1],
+                &lines[last_pos.row() - 1][last_pos.column() - 1..fix.location.column() - 1],
             );
             output.push_str(&fix.content);
         }
 
-        last_pos = fix.end;
+        last_pos = fix.end_location;
         fix.applied = true;
     }
 
-    if last_pos.row() > 0 || last_pos.column() > 0 {
+    if last_pos.row() > 0
+        && (last_pos.row() - 1) < lines.len()
+        && (last_pos.row() > 0 || last_pos.column() > 0)
+    {
         output.push_str(&lines[last_pos.row() - 1][last_pos.column() - 1..]);
         output.push('\n');
     }
-    for line in &lines[last_pos.row()..] {
-        output.push_str(line);
-        output.push('\n');
+    if last_pos.row() < lines.len() {
+        for line in &lines[last_pos.row()..] {
+            output.push_str(line);
+            output.push('\n');
+        }
     }
 
     output
@@ -106,8 +112,8 @@ mod tests {
     fn apply_single_replacement() -> Result<()> {
         let mut fixes = vec![Fix {
             content: "Bar".to_string(),
-            start: Location::new(1, 9),
-            end: Location::new(1, 15),
+            location: Location::new(1, 9),
+            end_location: Location::new(1, 15),
             applied: false,
         }];
         let actual = apply_fixes(
@@ -130,8 +136,8 @@ mod tests {
     fn apply_single_removal() -> Result<()> {
         let mut fixes = vec![Fix {
             content: "".to_string(),
-            start: Location::new(1, 8),
-            end: Location::new(1, 16),
+            location: Location::new(1, 8),
+            end_location: Location::new(1, 16),
             applied: false,
         }];
         let actual = apply_fixes(
@@ -155,14 +161,14 @@ mod tests {
         let mut fixes = vec![
             Fix {
                 content: "".to_string(),
-                start: Location::new(1, 8),
-                end: Location::new(1, 17),
+                location: Location::new(1, 8),
+                end_location: Location::new(1, 17),
                 applied: false,
             },
             Fix {
                 content: "".to_string(),
-                start: Location::new(1, 17),
-                end: Location::new(1, 24),
+                location: Location::new(1, 17),
+                end_location: Location::new(1, 24),
                 applied: false,
             },
         ];
@@ -187,14 +193,14 @@ mod tests {
         let mut fixes = vec![
             Fix {
                 content: "".to_string(),
-                start: Location::new(1, 8),
-                end: Location::new(1, 16),
+                location: Location::new(1, 8),
+                end_location: Location::new(1, 16),
                 applied: false,
             },
             Fix {
                 content: "ignored".to_string(),
-                start: Location::new(1, 10),
-                end: Location::new(1, 12),
+                location: Location::new(1, 10),
+                end_location: Location::new(1, 12),
                 applied: false,
             },
         ];

src/autofix/fixes.rs

@@ -1,8 +1,14 @@
-use rustpython_parser::ast::{Expr, Keyword, Location};
+use anyhow::Result;
+use itertools::Itertools;
+use libcst_native::ImportNames::Aliases;
+use libcst_native::NameOrAttribute::N;
+use libcst_native::{Codegen, Expression, SmallStatement, Statement};
+use rustpython_parser::ast::{ExcepthandlerKind, Expr, Keyword, Location, Stmt, StmtKind};
 use rustpython_parser::lexer;
 use rustpython_parser::token::Tok;
 
 use crate::ast::operations::SourceCodeLocator;
+use crate::ast::types::Range;
 use crate::checks::Fix;
 
 /// Convert a location within a file (relative to `base`) to an absolute position.
@@ -25,7 +31,7 @@ pub fn remove_class_def_base(
     bases: &[Expr],
     keywords: &[Keyword],
 ) -> Option<Fix> {
-    let content = locator.slice_source_code(stmt_at);
+    let content = locator.slice_source_code_at(stmt_at);
 
     // Case 1: `object` is the only base.
     if bases.len() == 1 && keywords.is_empty() {
@@ -52,8 +58,8 @@ pub fn remove_class_def_base(
         return match (fix_start, fix_end) {
             (Some(start), Some(end)) => Some(Fix {
                 content: "".to_string(),
-                start,
-                end,
+                location: start,
+                end_location: end,
                 applied: false,
             }),
             _ => None,
@@ -91,8 +97,8 @@ pub fn remove_class_def_base(
         match (fix_start, fix_end) {
             (Some(start), Some(end)) => Some(Fix {
                 content: "".to_string(),
-                start,
-                end,
+                location: start,
+                end_location: end,
                 applied: false,
             }),
             _ => None,
@@ -116,11 +122,271 @@ pub fn remove_class_def_base(
         match (fix_start, fix_end) {
             (Some(start), Some(end)) => Some(Fix {
                 content: "".to_string(),
-                start,
-                end,
+                location: start,
+                end_location: end,
                 applied: false,
             }),
             _ => None,
         }
     }
 }
+
+pub fn remove_super_arguments(locator: &mut SourceCodeLocator, expr: &Expr) -> Option<Fix> {
+    let range = Range::from_located(expr);
+    let contents = locator.slice_source_code_range(&range);
+
+    let mut tree = match libcst_native::parse_module(contents, None) {
+        Ok(m) => m,
+        Err(_) => return None,
+    };
+
+    if let Some(Statement::Simple(body)) = tree.body.first_mut() {
+        if let Some(SmallStatement::Expr(body)) = body.body.first_mut() {
+            if let Expression::Call(body) = &mut body.value {
+                body.args = vec![];
+                body.whitespace_before_args = Default::default();
+                body.whitespace_after_func = Default::default();
+
+                let mut state = Default::default();
+                tree.codegen(&mut state);
+
+                return Some(Fix {
+                    content: state.to_string(),
+                    location: range.location,
+                    end_location: range.end_location,
+                    applied: false,
+                });
+            }
+        }
+    }
+
+    None
+}
+
+/// Determine if a body contains only a single statement, taking into account deleted.
+fn has_single_child(body: &[Stmt], deleted: &[&Stmt]) -> bool {
+    body.iter().filter(|child| !deleted.contains(child)).count() == 1
+}
+
+/// Determine if a child is the only statement in its body.
+fn is_lone_child(child: &Stmt, parent: &Stmt, deleted: &[&Stmt]) -> Result<bool> {
+    match &parent.node {
+        StmtKind::FunctionDef { body, .. }
+        | StmtKind::AsyncFunctionDef { body, .. }
+        | StmtKind::ClassDef { body, .. }
+        | StmtKind::With { body, .. }
+        | StmtKind::AsyncWith { body, .. } => {
+            if body.iter().contains(child) {
+                Ok(has_single_child(body, deleted))
+            } else {
+                Err(anyhow::anyhow!("Unable to find child in parent body."))
+            }
+        }
+        StmtKind::For { body, orelse, .. }
+        | StmtKind::AsyncFor { body, orelse, .. }
+        | StmtKind::While { body, orelse, .. }
+        | StmtKind::If { body, orelse, .. } => {
+            if body.iter().contains(child) {
+                Ok(has_single_child(body, deleted))
+            } else if orelse.iter().contains(child) {
+                Ok(has_single_child(orelse, deleted))
+            } else {
+                Err(anyhow::anyhow!("Unable to find child in parent body."))
+            }
+        }
+        StmtKind::Try {
+            body,
+            handlers,
+            orelse,
+            finalbody,
+        } => {
+            if body.iter().contains(child) {
+                Ok(has_single_child(body, deleted))
+            } else if orelse.iter().contains(child) {
+                Ok(has_single_child(orelse, deleted))
+            } else if finalbody.iter().contains(child) {
+                Ok(has_single_child(finalbody, deleted))
+            } else if let Some(body) = handlers.iter().find_map(|handler| match &handler.node {
+                ExcepthandlerKind::ExceptHandler { body, .. } => {
+                    if body.iter().contains(child) {
+                        Some(body)
+                    } else {
+                        None
+                    }
+                }
+            }) {
+                Ok(has_single_child(body, deleted))
+            } else {
+                Err(anyhow::anyhow!("Unable to find child in parent body."))
+            }
+        }
+        _ => Err(anyhow::anyhow!("Unable to find child in parent body.")),
+    }
+}
+
+pub fn remove_stmt(stmt: &Stmt, parent: Option<&Stmt>, deleted: &[&Stmt]) -> Result<Fix> {
+    if parent
+        .map(|parent| is_lone_child(stmt, parent, deleted))
+        .map_or(Ok(None), |v| v.map(Some))?
+        .unwrap_or_default()
+    {
+        // If removing this node would lead to an invalid syntax tree, replace
+        // it with a `pass`.
+        Ok(Fix {
+            location: stmt.location,
+            end_location: stmt.end_location,
+            content: "pass".to_string(),
+            applied: false,
+        })
+    } else {
+        // Otherwise, nuke the entire line.
+        // TODO(charlie): This logic assumes that there are no multi-statement physical lines.
+        Ok(Fix {
+            location: Location::new(stmt.location.row(), 1),
+            end_location: Location::new(stmt.end_location.row() + 1, 1),
+            content: "".to_string(),
+            applied: false,
+        })
+    }
+}
+
+/// Generate a Fix to remove any unused imports from an `import` statement.
+pub fn remove_unused_imports(
+    locator: &mut SourceCodeLocator,
+    full_names: &[&str],
+    stmt: &Stmt,
+    parent: Option<&Stmt>,
+    deleted: &[&Stmt],
+) -> Result<Fix> {
+    let mut tree = match libcst_native::parse_module(
+        locator.slice_source_code_range(&Range::from_located(stmt)),
+        None,
+    ) {
+        Ok(m) => m,
+        Err(_) => return Err(anyhow::anyhow!("Failed to extract CST from source.")),
+    };
+
+    let body = if let Some(Statement::Simple(body)) = tree.body.first_mut() {
+        body
+    } else {
+        return Err(anyhow::anyhow!("Expected node to be: Statement::Simple."));
+    };
+    let body = if let Some(SmallStatement::Import(body)) = body.body.first_mut() {
+        body
+    } else {
+        return Err(anyhow::anyhow!(
+            "Expected node to be: SmallStatement::ImportFrom."
+        ));
+    };
+    let aliases = &mut body.names;
+
+    // Preserve the trailing comma (or not) from the last entry.
+    let trailing_comma = aliases.last().and_then(|alias| alias.comma.clone());
+
+    // Identify unused imports from within the `import from`.
+    let mut removable = vec![];
+    for (index, alias) in aliases.iter().enumerate() {
+        if let N(import_name) = &alias.name {
+            if full_names.contains(&import_name.value) {
+                removable.push(index);
+            }
+        }
+    }
+    // TODO(charlie): This is quadratic.
+    for index in removable.iter().rev() {
+        aliases.remove(*index);
+    }
+
+    if let Some(alias) = aliases.last_mut() {
+        alias.comma = trailing_comma;
+    }
+
+    if aliases.is_empty() {
+        remove_stmt(stmt, parent, deleted)
+    } else {
+        let mut state = Default::default();
+        tree.codegen(&mut state);
+
+        Ok(Fix {
+            content: state.to_string(),
+            location: stmt.location,
+            end_location: stmt.end_location,
+            applied: false,
+        })
+    }
+}
+
+/// Generate a Fix to remove any unused imports from an `import from` statement.
+pub fn remove_unused_import_froms(
+    locator: &mut SourceCodeLocator,
+    full_names: &[&str],
+    stmt: &Stmt,
+    parent: Option<&Stmt>,
+    deleted: &[&Stmt],
+) -> Result<Fix> {
+    let mut tree = match libcst_native::parse_module(
+        locator.slice_source_code_range(&Range::from_located(stmt)),
+        None,
+    ) {
+        Ok(m) => m,
+        Err(_) => return Err(anyhow::anyhow!("Failed to extract CST from source.")),
+    };
+
+    let body = if let Some(Statement::Simple(body)) = tree.body.first_mut() {
+        body
+    } else {
+        return Err(anyhow::anyhow!("Expected node to be: Statement::Simple."));
+    };
+    let body = if let Some(SmallStatement::ImportFrom(body)) = body.body.first_mut() {
+        body
+    } else {
+        return Err(anyhow::anyhow!(
+            "Expected node to be: SmallStatement::ImportFrom."
+        ));
+    };
+    let aliases = if let Aliases(aliases) = &mut body.names {
+        aliases
+    } else {
+        return Err(anyhow::anyhow!("Expected node to be: Aliases."));
+    };
+
+    // Preserve the trailing comma (or not) from the last entry.
+    let trailing_comma = aliases.last().and_then(|alias| alias.comma.clone());
+
+    // Identify unused imports from within the `import from`.
+    let mut removable = vec![];
+    for (index, alias) in aliases.iter().enumerate() {
+        if let N(name) = &alias.name {
+            let import_name = if let Some(N(module_name)) = &body.module {
+                format!("{}.{}", module_name.value, name.value)
+            } else {
+                name.value.to_string()
+            };
+            if full_names.contains(&import_name.as_str()) {
+                removable.push(index);
+            }
+        }
+    }
+    // TODO(charlie): This is quadratic.
+    for index in removable.iter().rev() {
+        aliases.remove(*index);
+    }
+
+    if let Some(alias) = aliases.last_mut() {
+        alias.comma = trailing_comma;
+    }
+
+    if aliases.is_empty() {
+        remove_stmt(stmt, parent, deleted)
+    } else {
+        let mut state = Default::default();
+        tree.codegen(&mut state);
+
+        Ok(Fix {
+            content: state.to_string(),
+            location: stmt.location,
+            end_location: stmt.end_location,
+            applied: false,
+        })
+    }
+}

src/cache.rs

@@ -1,11 +1,14 @@
 use std::collections::hash_map::DefaultHasher;
-use std::fs::Metadata;
+use std::fs::{create_dir_all, File, Metadata};
 use std::hash::{Hash, Hasher};
+use std::io::Write;
 use std::path::Path;
 
+use anyhow::Result;
 use cacache::Error::EntryNotFound;
 use filetime::FileTime;
 use log::error;
+use path_absolutize::Absolutize;
 use serde::{Deserialize, Serialize};
 
 use crate::autofix::fixer;
@@ -77,12 +80,22 @@ fn cache_key(path: &Path, settings: &Settings, autofix: &fixer::Mode) -> String
     autofix.hash(&mut hasher);
     format!(
         "{}@{}@{}",
-        path.canonicalize().unwrap().to_string_lossy(),
+        path.absolutize().unwrap().to_string_lossy(),
         VERSION,
         hasher.finish()
     )
 }
 
+pub fn init() -> Result<()> {
+    let gitignore_path = Path::new(cache_dir()).join(".gitignore");
+    if gitignore_path.exists() {
+        return Ok(());
+    }
+    create_dir_all(cache_dir())?;
+    let mut file = File::create(gitignore_path)?;
+    file.write_all(b"*").map_err(|e| e.into())
+}
+
 pub fn get(
     path: &Path,
     metadata: &Metadata,

src/check_lines.rs

@@ -1,11 +1,17 @@
+use std::collections::BTreeMap;
+
 use rustpython_parser::ast::Location;
 
-use crate::checks::{Check, CheckKind};
+use crate::ast::types::Range;
+use crate::autofix::fixer;
+use crate::checks::{Check, CheckCode, CheckKind, Fix};
+use crate::noqa;
+use crate::noqa::Directive;
 use crate::settings::Settings;
 
 /// Whether the given line is too long and should be reported.
-fn should_enforce_line_length(line: &str, limit: usize) -> bool {
-    if line.len() > limit {
+fn should_enforce_line_length(line: &str, length: usize, limit: usize) -> bool {
+    if length > limit {
         let mut chunks = line.split_whitespace();
         if let (Some(first), Some(_)) = (chunks.next(), chunks.next()) {
             // Do not enforce the line length for commented lines with a single word
@@ -19,34 +25,244 @@ fn should_enforce_line_length(line: &str, limit: usize) -> bool {
     }
 }
 
-pub fn check_lines(checks: &mut Vec<Check>, contents: &str, settings: &Settings) {
-    let enforce_line_too_long = settings.select.contains(CheckKind::LineTooLong.code());
+pub fn check_lines(
+    checks: &mut Vec<Check>,
+    contents: &str,
+    noqa_line_for: &[usize],
+    settings: &Settings,
+    autofix: &fixer::Mode,
+) {
+    let enforce_line_too_long = settings.enabled.contains(&CheckCode::E501);
+    let enforce_noqa = settings.enabled.contains(&CheckCode::M001);
+
+    let mut noqa_directives: BTreeMap<usize, (Directive, Vec<&str>)> = BTreeMap::new();
 
     let mut line_checks = vec![];
     let mut ignored = vec![];
-    for (row, line) in contents.lines().enumerate() {
+
+    let lines: Vec<&str> = contents.lines().collect();
+    for (lineno, line) in lines.iter().enumerate() {
+        // Grab the noqa (logical) line number for the current (physical) line.
+        // If there are newlines at the end of the file, they won't be represented in
+        // `noqa_line_for`, so fallback to the current line.
+        let noqa_lineno = noqa_line_for
+            .get(lineno)
+            .map(|lineno| lineno - 1)
+            .unwrap_or(lineno);
+
+        if enforce_noqa {
+            noqa_directives
+                .entry(noqa_lineno)
+                .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
+        }
+
         // Remove any ignored checks.
         // TODO(charlie): Only validate checks for the current line.
         for (index, check) in checks.iter().enumerate() {
-            if check.location.row() == row + 1 && check.is_inline_ignored(line) {
-                ignored.push(index);
+            if check.location.row() == lineno + 1 {
+                let noqa = noqa_directives
+                    .entry(noqa_lineno)
+                    .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
+
+                match noqa {
+                    (Directive::All(_, _), matches) => {
+                        matches.push(check.kind.code().as_ref());
+                        ignored.push(index)
+                    }
+                    (Directive::Codes(_, _, codes), matches) => {
+                        if codes.contains(&check.kind.code().as_ref()) {
+                            matches.push(check.kind.code().as_ref());
+                            ignored.push(index);
+                        }
+                    }
+                    (Directive::None, _) => {}
+                }
             }
         }
 
         // Enforce line length.
-        if enforce_line_too_long && should_enforce_line_length(line, settings.line_length) {
-            let check = Check::new(
-                CheckKind::LineTooLong,
-                Location::new(row + 1, settings.line_length + 1),
-            );
-            if !check.is_inline_ignored(line) {
-                line_checks.push(check);
+        if enforce_line_too_long {
+            let line_length = line.chars().count();
+            if should_enforce_line_length(line, line_length, settings.line_length) {
+                let noqa = noqa_directives
+                    .entry(noqa_lineno)
+                    .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
+
+                let check = Check::new(
+                    CheckKind::LineTooLong(line_length, settings.line_length),
+                    Range {
+                        location: Location::new(lineno + 1, 1),
+                        end_location: Location::new(lineno + 1, line_length + 1),
+                    },
+                );
+
+                match noqa {
+                    (Directive::All(_, _), matches) => {
+                        matches.push(check.kind.code().as_ref());
+                    }
+                    (Directive::Codes(_, _, codes), matches) => {
+                        if codes.contains(&check.kind.code().as_ref()) {
+                            matches.push(check.kind.code().as_ref());
+                        } else {
+                            line_checks.push(check);
+                        }
+                    }
+                    (Directive::None, _) => line_checks.push(check),
+                }
             }
         }
     }
+
+    // Enforce newlines at end of files.
+    if settings.enabled.contains(&CheckCode::W292) && !contents.ends_with('\n') {
+        // Note: if `lines.last()` is `None`, then `contents` is empty (and so we don't want to
+        // raise W292 anyway).
+        if let Some(line) = lines.last() {
+            let lineno = lines.len() - 1;
+            let noqa_lineno = noqa_line_for
+                .get(lineno)
+                .map(|lineno| lineno - 1)
+                .unwrap_or(lineno);
+
+            let noqa = noqa_directives
+                .entry(noqa_lineno)
+                .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
+
+            let check = Check::new(
+                CheckKind::NoNewLineAtEndOfFile,
+                Range {
+                    location: Location::new(lines.len(), line.len() + 1),
+                    end_location: Location::new(lines.len(), line.len() + 1),
+                },
+            );
+
+            match noqa {
+                (Directive::All(_, _), matches) => {
+                    matches.push(check.kind.code().as_ref());
+                }
+                (Directive::Codes(_, _, codes), matches) => {
+                    if codes.contains(&check.kind.code().as_ref()) {
+                        matches.push(check.kind.code().as_ref());
+                    } else {
+                        line_checks.push(check);
+                    }
+                }
+                (Directive::None, _) => line_checks.push(check),
+            }
+        }
+    }
+
+    // Enforce that the noqa directive was actually used.
+    if enforce_noqa {
+        for (row, (directive, matches)) in noqa_directives {
+            match directive {
+                Directive::All(start, end) => {
+                    if matches.is_empty() {
+                        let mut check = Check::new(
+                            CheckKind::UnusedNOQA(None),
+                            Range {
+                                location: Location::new(row + 1, start + 1),
+                                end_location: Location::new(row + 1, end + 1),
+                            },
+                        );
+                        if matches!(autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                            check.amend(Fix {
+                                content: "".to_string(),
+                                location: Location::new(row + 1, start + 1),
+                                end_location: Location::new(
+                                    row + 1,
+                                    lines[row].chars().count() + 1,
+                                ),
+                                applied: false,
+                            });
+                        }
+                        line_checks.push(check);
+                    }
+                }
+                Directive::Codes(start, end, codes) => {
+                    let mut invalid_codes = vec![];
+                    let mut valid_codes = vec![];
+                    for code in codes {
+                        if !matches.contains(&code) {
+                            invalid_codes.push(code.to_string());
+                        } else {
+                            valid_codes.push(code.to_string());
+                        }
+                    }
+
+                    if !invalid_codes.is_empty() {
+                        let mut check = Check::new(
+                            CheckKind::UnusedNOQA(Some(invalid_codes)),
+                            Range {
+                                location: Location::new(row + 1, start + 1),
+                                end_location: Location::new(row + 1, end + 1),
+                            },
+                        );
+                        if matches!(autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                            if valid_codes.is_empty() {
+                                check.amend(Fix {
+                                    content: "".to_string(),
+                                    location: Location::new(row + 1, start + 1),
+                                    end_location: Location::new(
+                                        row + 1,
+                                        lines[row].chars().count() + 1,
+                                    ),
+                                    applied: false,
+                                });
+                            } else {
+                                check.amend(Fix {
+                                    content: format!("  # noqa: {}", valid_codes.join(", ")),
+                                    location: Location::new(row + 1, start + 1),
+                                    end_location: Location::new(
+                                        row + 1,
+                                        lines[row].chars().count() + 1,
+                                    ),
+                                    applied: false,
+                                });
+                            }
+                        }
+                        line_checks.push(check);
+                    }
+                }
+                Directive::None => {}
+            }
+        }
+    }
+
     ignored.sort();
     for index in ignored.iter().rev() {
         checks.swap_remove(*index);
     }
     checks.extend(line_checks);
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::autofix::fixer;
+    use crate::checks::{Check, CheckCode};
+    use crate::settings;
+
+    use super::check_lines;
+
+    #[test]
+    fn e501_non_ascii_char() {
+        let line = "'\u{4e9c}' * 2"; // 7 in UTF-32, 9 in UTF-8.
+        let noqa_line_for: Vec<usize> = vec![1];
+        let check_with_max_line_length = |line_length: usize| {
+            let mut checks: Vec<Check> = vec![];
+            check_lines(
+                &mut checks,
+                line,
+                &noqa_line_for,
+                &settings::Settings {
+                    line_length,
+                    ..settings::Settings::for_rule(CheckCode::E501)
+                },
+                &fixer::Mode::Generate,
+            );
+            return checks;
+        };
+        assert!(!check_with_max_line_length(6).is_empty());
+        assert!(check_with_max_line_length(7).is_empty());
+    }
+}

src/cli.rs

@@ -0,0 +1,139 @@
+use std::fmt;
+use std::path::PathBuf;
+
+use clap::{command, Parser};
+use log::warn;
+use regex::Regex;
+
+use crate::checks::CheckCode;
+use crate::printer::SerializationFormat;
+use crate::pyproject::StrCheckCodePair;
+use crate::settings::PythonVersion;
+use crate::RawSettings;
+
+#[derive(Debug, Parser)]
+#[command(author, about = "ruff: An extremely fast Python linter.")]
+#[command(version)]
+pub struct Cli {
+    #[arg(required = true)]
+    pub files: Vec<PathBuf>,
+    /// Enable verbose logging.
+    #[arg(short, long)]
+    pub verbose: bool,
+    /// Disable all logging (but still exit with status code "1" upon detecting errors).
+    #[arg(short, long)]
+    pub quiet: bool,
+    /// Exit with status code "0", even upon detecting errors.
+    #[arg(short, long)]
+    pub exit_zero: bool,
+    /// Run in watch mode by re-running whenever files change.
+    #[arg(short, long)]
+    pub watch: bool,
+    /// Attempt to automatically fix lint errors.
+    #[arg(short, long)]
+    pub fix: bool,
+    /// Disable cache reads.
+    #[arg(short, long)]
+    pub no_cache: bool,
+    /// List of error codes to enable.
+    #[arg(long, value_delimiter = ',')]
+    pub select: Vec<CheckCode>,
+    /// Like --select, but adds additional error codes on top of the selected ones.
+    #[arg(long, value_delimiter = ',')]
+    pub extend_select: Vec<CheckCode>,
+    /// List of error codes to ignore.
+    #[arg(long, value_delimiter = ',')]
+    pub ignore: Vec<CheckCode>,
+    /// Like --ignore, but adds additional error codes on top of the ignored ones.
+    #[arg(long, value_delimiter = ',')]
+    pub extend_ignore: Vec<CheckCode>,
+    /// List of paths, used to exclude files and/or directories from checks.
+    #[arg(long, value_delimiter = ',')]
+    pub exclude: Vec<String>,
+    /// Like --exclude, but adds additional files and directories on top of the excluded ones.
+    #[arg(long, value_delimiter = ',')]
+    pub extend_exclude: Vec<String>,
+    /// List of mappings from file pattern to code to exclude
+    #[arg(long, value_delimiter = ',')]
+    pub per_file_ignores: Vec<StrCheckCodePair>,
+    /// Output serialization format for error messages.
+    #[arg(long, value_enum, default_value_t=SerializationFormat::Text)]
+    pub format: SerializationFormat,
+    /// See the files ruff will be run against with the current settings.
+    #[arg(long)]
+    pub show_files: bool,
+    /// See ruff's settings.
+    #[arg(long)]
+    pub show_settings: bool,
+    /// Enable automatic additions of noqa directives to failing lines.
+    #[arg(long)]
+    pub add_noqa: bool,
+    /// Regular expression matching the name of dummy variables.
+    #[arg(long)]
+    pub dummy_variable_rgx: Option<Regex>,
+    /// The minimum Python version that should be supported.
+    #[arg(long)]
+    pub target_version: Option<PythonVersion>,
+    /// Round-trip auto-formatting.
+    // TODO(charlie): This should be a sub-command.
+    #[arg(long, hide = true)]
+    pub autoformat: bool,
+    /// The name of the file when passing it through stdin.
+    #[arg(long)]
+    pub stdin_filename: Option<String>,
+}
+
+pub enum Warnable {
+    Select,
+    ExtendSelect,
+}
+
+impl fmt::Display for Warnable {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Warnable::Select => fmt.write_str("--select"),
+            Warnable::ExtendSelect => fmt.write_str("--extend-select"),
+        }
+    }
+}
+
+/// Warn the user if they attempt to enable a code that won't be respected.
+pub fn warn_on(
+    flag: Warnable,
+    codes: &Vec<CheckCode>,
+    cli_ignore: &Vec<CheckCode>,
+    cli_extend_ignore: &Vec<CheckCode>,
+    pyproject_settings: &RawSettings,
+    pyproject_path: &Option<PathBuf>,
+) {
+    for code in codes {
+        if !cli_ignore.is_empty() {
+            if cli_ignore.contains(code) {
+                warn!("{code:?} was passed to {flag}, but ignored via --ignore")
+            }
+        } else if pyproject_settings.ignore.contains(code) {
+            if let Some(path) = pyproject_path {
+                warn!(
+                    "{code:?} was passed to {flag}, but ignored by the `ignore` field in {}",
+                    path.to_string_lossy()
+                )
+            } else {
+                warn!("{code:?} was passed to {flag}, but ignored by the default `ignore` field",)
+            }
+        }
+        if !cli_extend_ignore.is_empty() {
+            if cli_extend_ignore.contains(code) {
+                warn!("{code:?} was passed to {flag}, but ignored via --extend-ignore")
+            }
+        } else if pyproject_settings.extend_ignore.contains(code) {
+            if let Some(path) = pyproject_path {
+                warn!(
+                    "{code:?} was passed to {flag}, but ignored by the `extend_ignore` field in {}",
+                    path.to_string_lossy()
+                )
+            } else {
+                warn!("{code:?} was passed to {flag}, but ignored by the default `extend_ignore` field")
+            }
+        }
+    }
+}