Bump version to 0.0.79

This reverts commit 77e5564f4b.

.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/ci.yaml

@@ -2,16 +2,16 @@ name: CI
 
 on:
   push:
-    branches: [ main ]
+    branches: [main]
   pull_request:
-    branches: [ main ]
+    branches: [main]
 
 jobs:
   cargo_build:
     name: "cargo build"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
@@ -33,7 +33,7 @@ jobs:
     name: "cargo fmt"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
@@ -55,7 +55,7 @@ jobs:
     name: "cargo clippy"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
@@ -77,7 +77,7 @@ jobs:
     name: "cargo test"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
@@ -99,13 +99,13 @@ jobs:
     name: "maturin build"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
       - uses: actions/setup-python@v4
         with:
-          python-version: '3.10'
+          python-version: "3.10"
       - run: pip install maturin
       - uses: actions/cache@v3
         env:

.github/workflows/release.yaml

@@ -1,49 +1,71 @@
 name: Release
 
 on:
+  pull_request:
+    branches: [main]
   create:
     tags:
       - v*
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  PACKAGE_NAME: ruff
+  PYTHON_VERSION: "3.7" # to build abi3 wheels
+
 jobs:
-  macos:
+  macos-x86_64:
     runs-on: macos-latest
-    strategy:
-      matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10']
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
       - name: Install Rust toolchain
         uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
-          target: aarch64-apple-darwin
           profile: minimal
           default: true
-      - name: Build
-        run: cargo build --release
-      - name: Tests
-        run: cargo test --no-default-features --release
       - name: Build wheels - x86_64
         uses: messense/maturin-action@v1
         with:
           target: x86_64
-          args: -i python --release --out dist --sdist
+          args: --release --out dist --sdist
+          maturin-version: "v0.13.0"
       - name: Install built wheel - x86_64
         run: |
-          pip install ruff --no-index --find-links dist --force-reinstall
+          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
-        if: ${{ matrix.python-version >= '3.8' || matrix.python-version == '3.10' }}
         uses: messense/maturin-action@v1
         with:
-          args: -i python --release --universal2 --out dist
+          args: --release --universal2 --out dist
+          maturin-version: "v0.13.0"
       - name: Install built wheel - universal2
-        if: ${{ matrix.python-version >= '3.8' }}
         run: |
-          pip install ruff --no-index --find-links dist --force-reinstall
+          pip install dist/${{ env.PACKAGE_NAME }}-*universal2.whl --force-reinstall
       - name: Upload wheels
         uses: actions/upload-artifact@v2
         with:
@@ -54,36 +76,29 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10']
         target: [x64, x86]
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: ${{ env.PYTHON_VERSION }}
           architecture: ${{ matrix.target }}
-      - name: Update rustup
-        run: rustup self update
       - name: Install Rust toolchain
         uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
           profile: minimal
           default: true
-      - name: Build
-        if: matrix.target == 'x64'
-        run: cargo build --release
-      - name: Tests
-        if: matrix.target == 'x64'
-        run: cargo test --no-default-features --release
       - name: Build wheels
         uses: messense/maturin-action@v1
         with:
           target: ${{ matrix.target }}
-          args: -i python --release --out dist
+          args: --release --out dist
+          maturin-version: "v0.13.0"
       - name: Install built wheel
+        shell: bash
         run: |
-          pip install ruff --no-index --find-links dist --force-reinstall
+          python -m pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
       - name: Upload wheels
         uses: actions/upload-artifact@v2
         with:
@@ -94,96 +109,195 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10']
         target: [x86_64, i686]
     steps:
-    - uses: actions/checkout@v2
-    - name: Install Rust toolchain
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        profile: minimal
-        default: true
-    - name: Build
-      run: cargo build --release
-    - name: Tests
-      run: cargo test --no-default-features --release
-    - uses: actions/setup-python@v2
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Build Wheels
-      uses: messense/maturin-action@v1
-      with:
-        target: ${{ matrix.target }}
-        manylinux: auto
-        args: -i ${{ matrix.python-version }} --release --out dist
-    - name: Install built wheel
-      if: matrix.target == 'x86_64'
-      run: |
-        pip install ruff --no-index --find-links dist --force-reinstall
-    - name: Upload wheels
-      uses: actions/upload-artifact@v2
-      with:
-        name: wheels
-        path: dist
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
 
   linux-cross:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10']
-        target: [aarch64, armv7, s390x, ppc64le]
+        target: [aarch64, armv7, s390x, ppc64le, ppc64]
     steps:
-    - uses: actions/checkout@v2
-    - name: Build Wheels
-      uses: messense/maturin-action@v1
-      with:
-        target: ${{ matrix.target }}
-        manylinux: auto
-        args: -i ${{ matrix.python-version }} --release --out dist
-    - uses: uraimo/run-on-arch-action@v2.2.0
-      name: Install built wheel
-      with:
-        arch: ${{ matrix.target }}
-        distro: ubuntu20.04
-        githubToken: ${{ github.token }}
-        # Mount the dist directory as /artifacts in the container
-        dockerRunArgs: |
-          --volume "${PWD}/dist:/artifacts"
-        install: |
-          apt-get update
-          apt-get install -y --no-install-recommends python3 python3-venv software-properties-common
-          add-apt-repository ppa:deadsnakes/ppa
-          apt-get update
-          apt-get install -y curl python3.7-venv python3.9-venv python3.10-venv
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --no-default-features --release --out dist
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@v2.0.5
+        if: matrix.target != 'ppc64'
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.target }}
+          distro: ubuntu20.04
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update
+            apt-get install -y --no-install-recommends python3 python3-pip
+            pip3 install -U pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target:
+          - x86_64-unknown-linux-musl
+          - i686-unknown-linux-musl
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist
+          maturin-version: "v0.13.0"
+      - name: Install built wheel
+        if: matrix.target == 'x86_64-unknown-linux-musl'
+        uses: addnab/docker-run-action@v3
+        with:
+          image: alpine:latest
+          options: -v ${{ github.workspace }}:/io -w /io
+          run: |
+            apk add py3-pip
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links /io/dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  musllinux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        platform:
+          - target: aarch64-unknown-linux-musl
+            arch: aarch64
+          - target: armv7-unknown-linux-musleabihf
+            arch: armv7
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist
+          maturin-version: "v0.13.0"
+      - uses: uraimo/run-on-arch-action@master
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.platform.arch }}
+          distro: alpine_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apk add py3-pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
+
+  pypy:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        target: [x86_64, aarch64]
+        python-version:
+          - "3.7"
+          - "3.8"
+          - "3.9"
+        exclude:
+          - os: macos-latest
+            target: aarch64
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: pypy${{ matrix.python-version }}
+      - name: Build wheels
+        uses: messense/maturin-action@v1
+        with:
+          maturin-version: "v0.13.0"
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist -i pypy${{ matrix.python-version }}
+      - name: Install built wheel
+        if: matrix.target == 'x86_64'
         run: |
-          ls -lrth /artifacts
-          PYTHON=python${{ matrix.python-version }}
-          $PYTHON -m venv venv
-          venv/bin/pip install -U pip
-          venv/bin/pip install ruff --no-index --find-links /artifacts --force-reinstall
-    - name: Upload wheels
-      uses: actions/upload-artifact@v2
-      with:
-        name: wheels
-        path: dist
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - name: Upload wheels
+        uses: actions/upload-artifact@v2
+        with:
+          name: wheels
+          path: dist
 
   release:
     name: Release
     runs-on: ubuntu-latest
+    needs:
+      - macos-universal
+      - macos-x86_64
+      - windows
+      - linux
+      - linux-cross
+      - musllinux
+      - musllinux-cross
+      - pypy
     if: "startsWith(github.ref, 'refs/tags/')"
-    needs: [ macos, windows, linux, linux-cross ]
     steps:
       - uses: actions/download-artifact@v2
         with:
           name: wheels
-      - uses: actions/setup-python@v2
-        with:
-          python-version: '3.10'
+      - uses: actions/setup-python@v4
       - name: Publish to PyPi
         env:
           TWINE_USERNAME: __token__
           TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
         run: |
-          pip install --upgrade wheel pip setuptools twine
-          twine upload --skip-existing *
+          pip install --upgrade twine
+          twine upload --skip-existing *

.gitignore

@@ -1,5 +1,5 @@
 # Local cache
-.cache
+.ruff_cache
 resources/test/cpython
 
 ###

.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+repos:
+  - 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

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.18"
+version = "0.0.79"
 edition = "2021"
 
 [lib]
@@ -9,27 +9,62 @@ name = "ruff"
 [dependencies]
 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"] }
-clearscreen = { version = "1.0.10" }
+clap = { version = "4.0.1", features = ["derive"] }
 colored = { version = "2.0.0" }
 common-path = { version = "1.0.0" }
 dirs = { version = "4.0.0" }
 fern = { version = "0.6.1" }
 filetime = { version = "0.2.17" }
+glob = { version = "0.3.0" }
+itertools = { version = "0.10.5" }
+libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "32a044c127668df44582f85699358e67803b0d73" }
 log = { version = "0.4.17" }
 notify = { version = "4.0.17" }
-pyo3 = { version = "0.17.1", features = ["auto-initialize"] }
+num-bigint = { version = "0.4.3" }
+once_cell = { version = "1.13.1" }
+path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "7a688e0b6c2904f286acac1e4af3f1628dd38589" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/charliermarsh/RustPython.git", rev = "210db77e4274787028dc3ebc0b4841d1334c8c10" }
+rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "210db77e4274787028dc3ebc0b4841d1334c8c10" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "210db77e4274787028dc3ebc0b4841d1334c8c10" }
 serde = { version = "1.0.143", features = ["derive"] }
 serde_json = { version = "1.0.83" }
+strum = { version = "0.24.1", features = ["strum_macros"] }
+strum_macros = { version = "0.24.3" }
+textwrap = { version = "0.15.1" }
+titlecase = { version = "2.2.1" }
 toml = { version = "0.5.9" }
+update-informer = { version = "0.5.0", default_features = false, features = ["pypi"], optional = true }
 walkdir = { version = "2.3.2" }
 
-[profile.release]
-lto = true
-panic = "abort"
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+cacache = { version = "10.0.1" } # uses async-std
+clearscreen = { version = "1.0.10" } # uses which
 
+# https://docs.rs/getrandom/0.2.7/getrandom/#webassembly-support
+# For (future) wasm-pack support
+[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
+getrandom = { version = "0.2.7", features = ["js"] }
+
+[dev-dependencies]
+assert_cmd = { version = "2.0.4" }
+insta = { version = "1.19.1", features = ["yaml"] }
+test-case = { version = "2.2.2" }
+
+[features]
+default = ["update-informer"]
+update-informer = ["dep:update-informer"]
+
+[profile.release]
+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,48 +1,64 @@
-# ruff
+# 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.
 
 <p align="center">
-  <img alt="Bar chart with benchmark results" src="https://user-images.githubusercontent.com/1309177/187221271-9db38ced-c622-406a-abf3-dec27ebc1b08.svg">
+  <img alt="Bar chart with benchmark results" src="https://user-images.githubusercontent.com/1309177/187504482-6d9df992-a81d-4e86-9f6a-d958741c8182.svg">
 </p>
 
 <p align="center">
   <i>Linting the CPython codebase from scratch.</i>
 </p>
 
-Major features:
+- ⚡️ 10-100x faster than existing linters
+- 🐍 Installable via `pip`
+- 🤝 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#--fix)-inspired autofix support (e.g., automatically remove unused imports)
+- 👀 [TypeScript](https://www.typescriptlang.org/docs/handbook/configuring-watch.html)-inspired `--watch` support, for continuous file monitoring
+- ⚖️ [Near-parity](#Parity-with-Flake8) with the built-in Flake8 rule set
+- 🔌 Native re-implementations of popular Flake8 plugins, like [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/) ([`pydocstyle`](https://pypi.org/project/pydocstyle/))
 
-- 10-100x faster than your current linter.
-- Installable via `pip`.
-- Python 3.10 compatibility.
-- [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#caching)-inspired cache semantics.
-- [TypeScript](https://www.typescriptlang.org/docs/handbook/configuring-watch.html)-inspired `--watch` semantics.
-- `pyproject.toml` support.
+Ruff aims to be orders of magnitude faster than alternative tools while integrating more
+functionality behind a single, common interface. Ruff can be used to replace Flake8 (plus a variety
+of plugins), [`pydocstyle`](https://pypi.org/project/pydocstyle/), [`yesqa`](https://github.com/asottile/yesqa),
+and even a subset of [`pyupgrade`](https://pypi.org/project/pyupgrade/) and [`autoflake`](https://pypi.org/project/autoflake/)
+all while executing tens or hundreds of times faster than any individual tool.
 
-_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._
+Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).
 
-## Installation and usage
+## Table of Contents
+
+1. [Installation and Usage](#installation-and-usage)
+2. [Configuration](#configuration)
+3. [Supported Rules](#supported-rules)
+4. [Editor Integrations](#editor-integrations)
+5. [FAQ](#faq)
+6. [Development](#development)
+7. [Releases](#releases)
+8. [Benchmarks](#benchmarks)
+9. [License](#license)
+10. [Contributing](#contributing)
+
+## Installation and Usage
 
 ### Installation
 
-Available as [ruff](https://pypi.org/project/ruff/) on PyPI:
+Available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 
 ```shell
 pip install ruff
 ```
 
-For now, wheels are only available for macOS (on Python 3.7, 3.8, 3.9, and 3.10). If you're using a
-different operating system or Python version, you'll need to install the [Rust toolchain](https://www.rust-lang.org/tools/install)
-prior to running `pip install ruff`. (This is an effort limitation on my part, not a technical
-limitation.)
-
 ### Usage
 
-To run ruff, try any of the following:
+To run Ruff, try any of the following:
 
 ```shell
 ruff path/to/code/to/check.py
@@ -50,17 +66,27 @@ ruff path/to/code/
 ruff path/to/code/*.py
 ```
 
-You can run ruff in `--watch` mode to automatically re-run on-change:
+You can run Ruff in `--watch` mode to automatically re-run on-change:
 
 ```shell
 ruff path/to/code/ --watch
 ```
 
+Ruff also works with [pre-commit](https://pre-commit.com):
+
+```yaml
+repos:
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.0.79
+    hooks:
+      - id: lint
+```
+
 ## Configuration
 
-ruff is configurable both via `pyproject.toml` and the command line.
+Ruff is configurable both via `pyproject.toml` and the command line.
 
-For example, you could configure ruff to only enforce a subset of rules with:
+For example, you could configure Ruff to only enforce a subset of rules with:
 
 ```toml
 [tool.ruff]
@@ -74,65 +100,526 @@ 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
-A Python linter written in Rust
+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
-    -h, --help                  Print help information
-        --ignore <IGNORE>...    Comma-separated 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>...    Comma-separated list of error codes to enable
-    -v, --verbose               Enable verbose logging
-    -w, --watch                 Run in watch mode by re-running whenever files change
+Options:
+      --config <CONFIG>
+          Path to the `pyproject.toml` file to use for configuration
+  -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
+      --stdin-filename <STDIN_FILENAME>
+          The name of the file when passing it through stdin
+  -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 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.**
+
+## Supported Rules
+
+By default, Ruff enables all `E`, `W`, and `F` error codes, which correspond to those built-in to
+Flake8.
+
+The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` command-line option.
+
+### Pyflakes
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| 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` |  |
+
+### pycodestyle
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| 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 |  |
+
+### pydocstyle
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| 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 |  |
+| D201 | NoBlankLineBeforeFunction | No blank lines allowed before function docstring (found 1) | 🛠 |
+| D202 | NoBlankLineAfterFunction | No blank lines allowed after function docstring (found 1) | 🛠 |
+| D203 | OneBlankLineBeforeClass | 1 blank line required before class docstring | 🛠 |
+| D204 | OneBlankLineAfterClass | 1 blank line required after class docstring | 🛠 |
+| D205 | NoBlankLineAfterSummary | 1 blank line required between summary line and description | 🛠 |
+| D206 | IndentWithSpaces | Docstring should be indented with spaces, not tabs |  |
+| D207 | NoUnderIndentation | Docstring is under-indented |  |
+| D208 | NoOverIndentation | Docstring is over-indented |  |
+| D209 | NewLineAfterLastParagraph | Multi-line docstring closing quotes should be on a separate line | 🛠 |
+| D210 | NoSurroundingWhitespace | No whitespaces allowed surrounding docstring text | 🛠 |
+| D211 | NoBlankLineBeforeClass | No blank lines allowed before class docstring | 🛠 |
+| D212 | MultiLineSummaryFirstLine | Multi-line docstring summary should start at the first line |  |
+| D213 | MultiLineSummarySecondLine | Multi-line docstring summary should start at the second line |  |
+| D214 | SectionNotOverIndented | Section is over-indented ("Returns") |  |
+| D215 | SectionUnderlineNotOverIndented | Section underline is over-indented ("Returns") |  |
+| 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 |  |
+| D404 | NoThisPrefix | First word of the docstring should not be `This` |  |
+| D405 | CapitalizeSectionName | Section name should be properly capitalized ("returns") |  |
+| D406 | NewLineAfterSectionName | Section name should end with a newline ("Returns") |  |
+| D407 | DashedUnderlineAfterSection | Missing dashed underline after section ("Returns") |  |
+| D408 | SectionUnderlineAfterName | Section underline should be in the line following the section's name ("Returns") |  |
+| D409 | SectionUnderlineMatchesSectionLength | Section underline should match the length of its name ("Returns") |  |
+| D410 | BlankLineAfterSection | Missing blank line after section ("Returns") | 🛠 |
+| D411 | BlankLineBeforeSection | Missing blank line before section ("Returns") |  |
+| D412 | NoBlankLinesBetweenHeaderAndContent | No blank lines allowed between a section header and its content ("Returns") |  |
+| D413 | BlankLineAfterLastSection | Missing blank line after last section ("Returns") | 🛠 |
+| D414 | NonEmptySection | Section has no content ("Returns") |  |
+| D415 | EndsInPunctuation | First line should end with a period, question mark, or exclamation point |  |
+| D416 | SectionNameEndsInColon | Section name should end with a colon ("Returns") |  |
+| D417 | DocumentAllArguments | Missing argument descriptions in the docstring: `x`, `y` |  |
+| D418 | SkipDocstring | Function decorated with @overload shouldn't contain a docstring |  |
+| D419 | NonEmpty | Docstring is empty |  |
+
+### pyupgrade
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| 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)` | 🛠 |
+
+### pep8-naming
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| N801 | InvalidClassName | Class name `...` should use CapWords convention  |  |
+| N802 | InvalidFunctionName | Function name `...` should be lowercase |  |
+| N803 | InvalidArgumentName | Argument name `...` should be lowercase |  |
+| N804 | InvalidFirstArgumentNameForClassMethod | First argument of a class method should be named `cls` |  |
+| N805 | InvalidFirstArgumentNameForMethod | First argument of a method should be named `self` |  |
+
+### flake8-comprehensions
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| 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) |  |
+| C411 | UnnecessaryListCall | Unnecessary `list` call (remove the outer call to `list()`) |  |
+| C413 | UnnecessaryCallAroundSorted | Unnecessary `(list\|reversed)` call around `sorted()` |  |
+| 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)()` |  |
+| C416 | UnnecessaryComprehension |  Unnecessary `(list\|set)` comprehension (rewrite using `(list\|set)()`) |  |
+| C417 | UnnecessaryMap | Unnecessary `map` usage (rewrite using a `(list\|set\|dict)` comprehension) |  |
+
+### flake8-bugbear
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| 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` |  |
+
+### flake8-builtins
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| 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 |  |
+
+### flake8-print
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| T201 | PrintFound | `print` found | 🛠 |
+| T203 | PPrintFound | `pprint` found | 🛠 |
+
+### Meta rules
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| M001 | UnusedNOQA | Unused `noqa` directive | 🛠 |
+
+## Editor 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 .
+```
+
+## FAQ
+
+### Is Ruff compatible with Black?
+
+Yes. 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
+stylistic lint rules that are obviated by autoformatting.
+
+### How does Ruff compare to Flake8?
+
+Ruff can be used as a (near) drop-in replacement for Flake8 when used (1) without or with a small
+number of plugins, (2) alongside Black, and (3) on Python 3 code.
+
+Under those conditions Ruff is missing 14 rules related to string `.format` calls, 1 rule related
+to docstring parsing, and 1 rule related to redefined variables.
+
+Ruff re-implements some of the most popular Flake8 plugins and related code quality tools natively,
+including:
+
+- [`pydocstyle`](https://pypi.org/project/pydocstyle/)
+- [`yesqa`](https://github.com/asottile/yesqa)
+- [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
+- [`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/)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (3/32)
+- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34)
+- [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
+
+Beyond rule-set parity, Ruff suffers from the following limitations vis-à-vis 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. (To date, popular Flake8
+   plugins have been re-implemented within Ruff directly.)
+
+### Which tools does Ruff replace?
+
+Today, Ruff can be used to replace Flake8 when used with any of the following plugins:
+
+- [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
+- [`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/)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (3/32)
+
+Ruff also implements the functionality that you get from [`yesqa`](https://github.com/asottile/yesqa),
+and a subset of the rules implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34).
+
+If you're looking to use Ruff, but rely on an unsupported Flake8 plugin, free to file an Issue.
+
+### Do I need to install Rust to use Ruff?
+
+Nope! Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
+
+```shell
+pip install ruff
+```
+
+Ruff ships with wheels for all major platforms, which enables `pip` to install Ruff without relying
+on Rust at all.
+
+### Can I write my own plugins for Ruff?
+
+Ruff does not yet support third-party plugins, though a plugin system is within-scope for the
+project. See [#283](https://github.com/charliermarsh/ruff/issues/2830) for more.
+
+### Does Ruff support NumPy- or Google-style docstrings?
+
+Yes! To enable a specific docstring convention, start by enabling all `pydocstyle` error codes, and
+then selectively disabling based on your [preferred convention](https://www.pydocstyle.org/en/latest/error_codes.html#default-conventions).
+
+For example, if you're coming from `flake8-docstrings`, the following configuration is equivalent to
+`--docstring-convention numpy`:
+
+```toml
+[tool.ruff]
+extend-select = [
+    "D100",
+    "D101",
+    "D102",
+    "D103",
+    "D104",
+    "D105",
+    "D106",
+    "D200",
+    "D201",
+    "D202",
+    "D204",
+    "D205",
+    "D206",
+    "D207",
+    "D208",
+    "D209",
+    "D210",
+    "D211",
+    "D214",
+    "D215",
+    "D300",
+    "D400",
+    "D402",
+    "D403",
+    "D404",
+    "D405",
+    "D406",
+    "D407",
+    "D408",
+    "D409",
+    "D410",
+    "D411",
+    "D412",
+    "D413",
+    "D418",
+    "D419",
+]
+```
+
+Similarly, the following is equivalent to `--docstring-convention google`:
+
+```toml
+[tool.ruff]
+extend-select = [
+    "D100",
+    "D101",
+    "D102",
+    "D103",
+    "D104",
+    "D105",
+    "D106",
+    "D107",
+    "D200",
+    "D201",
+    "D202",
+    "D205",
+    "D206",
+    "D207",
+    "D208",
+    "D209",
+    "D210",
+    "D211",
+    "D212",
+    "D214",
+    "D300",
+    "D402",
+    "D403",
+    "D405",
+    "D410",
+    "D411",
+    "D412",
+    "D414",
+    "D415",
+    "D416",
+    "D417",
+    "D418",
+    "D419",
+]
 ```
 
 ## Development
 
-ruff is written in Rust (1.63.0). You'll need to install the [Rust toolchain](https://www.rust-lang.org/tools/install)
+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.
 
 Assuming you have `cargo` installed, you can run:
 
 ```shell
-cargo run resources/test/src
+cargo run resources/test/fixtures
 cargo fmt
 cargo clippy
 cargo test
 ```
 
-## Deployment
+## Releases
 
-ruff is distributed on [PyPI](https://pypi.org/project/ruff/), and published via [`maturin`](https://github.com/PyO3/maturin).
+Ruff is distributed on [PyPI](https://pypi.org/project/ruff/), and published via [`maturin`](https://github.com/PyO3/maturin).
 
-For now, releases are cut and published manually:
+See: `.github/workflows/release.yaml`.
 
-```shell
-for TARGET in x86_64-apple-darwin aarch64-apple-darwin
-do
-  maturin publish --username crmarsh --skip-existing --target ${TARGET} -i \
-    /usr/local/opt/python@3.7/libexec/bin/python \
-    /usr/local/opt/python@3.8/libexec/bin/python \
-    /usr/local/opt/python@3.9/libexec/bin/python \
-    /usr/local/opt/python@3.10/libexec/bin/python
-done
-```
-
-## Benchmarking
+## Benchmarks
 
 First, clone [CPython](https://github.com/python/cpython). It's a large and diverse Python codebase,
 which makes it a good target for benchmarking.
@@ -144,49 +631,25 @@ git clone --branch 3.10 https://github.com/python/cpython.git resources/test/cpy
 Add this `pyproject.toml` to the CPython directory:
 
 ```toml
-[tool.linter]
+[tool.ruff]
 line-length = 88
-exclude = [
-    "Lib/ctypes/test/test_numbers.py",
-    "Lib/dataclasses.py",
+extend-exclude = [
     "Lib/lib2to3/tests/data/bom.py",
     "Lib/lib2to3/tests/data/crlf.py",
     "Lib/lib2to3/tests/data/different_encoding.py",
     "Lib/lib2to3/tests/data/false_encoding.py",
     "Lib/lib2to3/tests/data/py2_test_grammar.py",
-    "Lib/sqlite3/test/factory.py",
-    "Lib/sqlite3/test/hooks.py",
-    "Lib/sqlite3/test/regression.py",
-    "Lib/sqlite3/test/transactions.py",
-    "Lib/sqlite3/test/types.py",
     "Lib/test/bad_coding2.py",
     "Lib/test/badsyntax_3131.py",
     "Lib/test/badsyntax_pep3120.py",
     "Lib/test/encoded_modules/module_iso_8859_1.py",
     "Lib/test/encoded_modules/module_koi8_r.py",
-    "Lib/test/sortperf.py",
-    "Lib/test/test_email/torture_test.py",
     "Lib/test/test_fstring.py",
-    "Lib/test/test_genericpath.py",
-    "Lib/test/test_getopt.py",
     "Lib/test/test_grammar.py",
-    "Lib/test/test_htmlparser.py",
-    "Lib/test/test_importlib/stubs.py",
-    "Lib/test/test_importlib/test_files.py",
-    "Lib/test/test_importlib/test_metadata_api.py",
-    "Lib/test/test_importlib/test_open.py",
     "Lib/test/test_importlib/test_util.py",
     "Lib/test/test_named_expressions.py",
     "Lib/test/test_patma.py",
-    "Lib/test/test_peg_generator/__main__.py",
-    "Lib/test/test_pipes.py",
     "Lib/test/test_source_encoding.py",
-    "Lib/test/test_weakref.py",
-    "Lib/test/test_webbrowser.py",
-    "Lib/tkinter/__main__.py",
-    "Lib/tkinter/test/test_tkinter/test_variables.py",
-    "Modules/_decimal/libmpdec/literature/fnt.py",
-    "Modules/_decimal/tests/deccheck.py",
     "Tools/c-analyzer/c_parser/parser/_delim.py",
     "Tools/i18n/pygettext.py",
     "Tools/test2to3/maintest.py",
@@ -201,124 +664,102 @@ 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 the ecosystem's existing tools:
+To benchmark against the ecosystem's existing tools:
 
 ```shell
-hyperfine --ignore-failure --warmup 1 \
+hyperfine --ignore-failure --warmup 5 \
+  "./target/release/ruff ./resources/test/cpython/ --no-cache" \
   "pylint --recursive=y resources/test/cpython/" \
   "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:
+
+- Ruff
 - Pylint
-- PyFlakes
+- 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 ± σ):     566.9 ms ±  36.6 ms    [User: 2618.0 ms, System: 992.0 ms]
-  Range (min … max):   504.8 ms … 634.0 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: ./target/release/ruff ./resources/test/cpython/
-  Time (mean ± σ):      79.5 ms ±   2.3 ms    [User: 330.1 ms, System: 254.3 ms]
-  Range (min … max):    75.6 ms …  85.2 ms    35 runs
+Benchmark 2: pylint --recursive=y resources/test/cpython/
+  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: pylint --recursive=y resources/test/cpython/
-  Time (mean ± σ):     27.532 s ±  0.207 s    [User: 26.606 s, System: 0.899 s]
-  Range (min … max):   27.344 s … 28.064 s    10 runs
+Benchmark 3: pyflakes resources/test/cpython
+  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: pyflakes resources/test/cpython
-  Time (mean ± σ):     28.074 s ±  0.551 s    [User: 27.845 s, System: 0.212 s]
-  Range (min … max):   27.479 s … 29.467 s    10 runs
+Benchmark 4: autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython
+  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 ± σ):     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
 
   Warning: Ignoring non-zero exit code.
 
-Benchmark 5: autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython
-  Time (mean ± σ):      4.986 s ±  0.190 s    [User: 43.257 s, System: 0.801 s]
-  Range (min … max):    4.837 s …  5.462 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
 
   Warning: Ignoring non-zero exit code.
 
-Benchmark 6: pycodestyle resources/test/cpython
-  Time (mean ± σ):     42.400 s ±  0.211 s    [User: 42.177 s, System: 0.213 s]
-  Range (min … max):   42.106 s … 42.677 s    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Benchmark 7: pycodestyle --select E501 resources/test/cpython
-  Time (mean ± σ):     14.578 s ±  0.068 s    [User: 14.466 s, System: 0.108 s]
-  Range (min … max):   14.475 s … 14.726 s    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Benchmark 8: flake8 resources/test/cpython
-  Time (mean ± σ):     76.414 s ±  0.461 s    [User: 75.611 s, System: 0.652 s]
-  Range (min … max):   75.691 s … 77.180 s    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Benchmark 9: flake8 --select=F831,F541,F634,F403,F706,F901,E501 resources/test/cpython
-  Time (mean ± σ):     75.960 s ±  0.610 s    [User: 75.255 s, System: 0.634 s]
-  Range (min … max):   75.159 s … 77.066 s    10 runs
-
-  Warning: Ignoring non-zero exit code.
-
-Benchmark 10: python -m scripts.run_flake8 resources/test/cpython
-  Time (mean ± σ):     13.536 s ±  0.584 s    [User: 90.911 s, System: 0.934 s]
-  Range (min … max):   12.831 s … 14.699 s    10 runs
-
-Benchmark 11: python -m scripts.run_flake8 resources/test/cpython --select=F831,F541,F634,F403,F706,F901,E501
-  Time (mean ± σ):     12.781 s ±  0.192 s    [User: 89.525 s, System: 0.882 s]
-  Range (min … max):   12.568 s … 13.119 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/' ran
-    7.13 ± 0.50 times faster than './target/release/ruff ./resources/test/cpython/ --no-cache'
-   62.69 ± 3.01 times faster than 'autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython'
-  160.71 ± 5.26 times faster than 'python -m scripts.run_flake8 resources/test/cpython --select=F831,F541,F634,F403,F706,F901,E501'
-  170.21 ± 8.86 times faster than 'python -m scripts.run_flake8 resources/test/cpython'
-  183.30 ± 5.40 times faster than 'pycodestyle --select E501 resources/test/cpython'
-  346.19 ± 10.40 times faster than 'pylint --recursive=y resources/test/cpython/'
-  353.00 ± 12.39 times faster than 'pyflakes resources/test/cpython'
-  533.14 ± 15.74 times faster than 'pycodestyle resources/test/cpython'
-  955.13 ± 28.83 times faster than 'flake8 --select=F831,F541,F634,F403,F706,F901,E501 resources/test/cpython'
-  960.82 ± 28.55 times faster than 'flake8 resources/test/cpython'
+  './target/release/ruff ./resources/test/cpython/ --no-cache' ran
+   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

@@ -0,0 +1,29 @@
+//! Generate a Markdown-compatible table of supported lint rules.
+
+use strum::IntoEnumIterator;
+
+use ruff::checks::{CheckCategory, CheckCode};
+
+fn main() {
+    for check_category in CheckCategory::iter() {
+        println!("### {}", check_category.title());
+        println!();
+
+        println!("| Code | Name | Message | Fix |");
+        println!("| ---- | ---- | ------- | --- |");
+        for check_code in CheckCode::iter() {
+            if check_code.category() == check_category {
+                let check_kind = check_code.kind();
+                let fix_token = if check_kind.fixable() { "🛠" } else { "" };
+                println!(
+                    "| {} | {} | {} | {} |",
+                    check_kind.code().as_ref(),
+                    check_kind.as_ref(),
+                    check_kind.body().replace("|", r"\|"),
+                    fix_token
+                );
+            }
+        }
+        println!();
+    }
+}

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

@@ -0,0 +1,26 @@
+//! Print the AST for a given Python file.
+
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Parser;
+use rustpython_parser::parser;
+
+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())?;
+
+    println!("{:#?}", python_ast);
+
+    Ok(())
+}

examples/print_tokens.rs

@@ -0,0 +1,26 @@
+//! Print the token stream for a given Python file.
+
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Parser;
+use rustpython_parser::lexer;
+
+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)?;
+    for (_, tok, _) in lexer::make_tokenizer(&contents).flatten() {
+        println!("{:#?}", tok);
+    }
+
+    Ok(())
+}

publish/Dockerfile

@@ -1,5 +0,0 @@
-FROM python:3.10.6-buster
-
-RUN pip install ruff
-RUN touch foo.py
-RUN ruff foo.py

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/C411.py

@@ -0,0 +1,2 @@
+x = [1, 2, 3]
+list([i for i in x])

resources/test/fixtures/C413.py

@@ -0,0 +1,4 @@
+x = [2, 3, 1]
+list(sorted(x))
+reversed(sorted(x))
+reversed(sorted(x, reverse=True))

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/C416.py

@@ -0,0 +1,6 @@
+x = [1, 2, 3]
+[i for i in x]
+{i for i in x}
+
+[i for i in x if i > 1]
+[i for i in x for j in x]

resources/test/fixtures/C417.py

@@ -0,0 +1,6 @@
+nums = [1, 2, 3]
+map(lambda x: x + 1, nums)
+map(lambda x: str(x), nums)
+list(map(lambda x: x * 2, nums))
+set(map(lambda x: x % 2 == 0, nums))
+dict(map(lambda v: (v, v**2), nums))

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

@@ -0,0 +1,32 @@
+"""Top-level docstring."""
+
+__all__ = ["y"]
+__version__: str = "0.1.0"
+
+import a
+
+try:
+    import b
+except ImportError:
+    pass
+else:
+    pass
+
+import c
+
+if x > 0:
+    import d
+else:
+    import e
+
+y = x + 1
+
+import f
+
+
+def foo() -> None:
+    import e
+
+
+if __name__ == "__main__":
+    import g

resources/test/fixtures/E501.py

@@ -0,0 +1,16 @@
+"""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.
+"""
+
+_ = """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

@@ -0,0 +1,50 @@
+#: 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
+
+#: Okay
+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/E712.py

@@ -0,0 +1,46 @@
+#: 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
+
+#: Okay
+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
+
+assert (not foo) in bar
+assert {"x": not foo} in bar
+assert [42, not foo] in bar

resources/test/fixtures/E713.py

@@ -0,0 +1,38 @@
+#: 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
+
+#: 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

@@ -0,0 +1,38 @@
+#: 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
+
+#: 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

@@ -0,0 +1,21 @@
+#: E731
+f = lambda x: 2 * x
+#: E731
+f = lambda x: 2 * x
+#: E731
+while False:
+    this = lambda y, z: 2 * x
+
+
+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_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/F601.py

@@ -0,0 +1,12 @@
+x = {
+    "a": 1,
+    "a": 2,
+    "b": 3,
+    ("a", "b"): 3,
+    ("a", "b"): 4,
+    1.0: 2,
+    1: 0,
+    1: 3,
+    b"123": 1,
+    b"123": 4,
+}

resources/test/fixtures/F602.py

@@ -0,0 +1,7 @@
+a = 1
+b = 2
+x = {
+    a: 1,
+    a: 2,
+    b: 3,
+}

resources/test/fixtures/F622.py

@@ -0,0 +1,3 @@
+*a, *b, c = (1, 2, 3)
+*a, b, c = (1, 2, 3)
+a, b, *c = (1, 2, 3)

resources/test/fixtures/F631.py

@@ -0,0 +1,4 @@
+assert (False, "x")
+assert (False,)
+assert ()
+assert True

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/F634.py

@@ -6,3 +6,5 @@ for _ in range(5):
         pass
     elif (3, 4):
         pass
+    elif ():
+        pass

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/F704.py

@@ -0,0 +1,10 @@
+def f() -> int:
+    yield 1
+
+
+class Foo:
+    yield 2
+
+
+yield 3
+yield from 3

resources/test/fixtures/F707.py

@@ -0,0 +1,46 @@
+try:
+    pass
+except:
+    pass
+except ValueError:
+    pass
+
+try:
+    pass
+except:
+    pass
+except ValueError:
+    pass
+finally:
+    pass
+
+try:
+    pass
+except:
+    pass
+except ValueError:
+    pass
+else:
+    pass
+
+try:
+    pass
+except:
+    pass
+
+try:
+    pass
+except ValueError:
+    pass
+except:
+    pass
+
+try:
+    pass
+except ValueError:
+    pass
+
+try:
+    pass
+finally:
+    pass

resources/test/fixtures/F722.py

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

resources/test/fixtures/F821.py

@@ -0,0 +1,133 @@
+def get_name():
+    return self.name
+
+
+def get_name():
+    return (self.name,)
+
+
+def get_name():
+    del self.name
+
+
+def get_name(self):
+    return self.name
+
+
+x = list()
+
+
+def randdec(maxprec, maxexp):
+    return numeric_string(maxprec, maxexp)
+
+
+def ternary_optarg(prec, exp_range, itr):
+    for _ in range(100):
+        a = randdec(prec, 2 * exp_range)
+        b = randdec(prec, 2 * exp_range)
+        c = randdec(prec, 2 * exp_range)
+        yield a, b, c, None
+        yield a, b, c, None, None
+
+
+class Foo:
+    CLASS_VAR = 1
+    REFERENCES_CLASS_VAR = {"CLASS_VAR": CLASS_VAR}
+    ANNOTATED_CLASS_VAR: int = 2
+
+
+from typing import Literal
+
+
+class Class:
+    copy_on_model_validation: Literal["none", "deep", "shallow"]
+    post_init_call: Literal["before_validation", "after_validation"]
+
+    def __init__(self):
+        Class
+
+
+try:
+    x = 1 / 0
+except Exception as e:
+    print(e)
+
+
+y: int = 1
+
+x: "Bar" = 1
+
+[first] = ["yup"]
+
+
+from typing import List, TypedDict
+
+
+class Item(TypedDict):
+    nodes: List[TypedDict("Node", {"name": str})]
+
+
+from enum import Enum
+
+
+class Ticket:
+    class Status(Enum):
+        OPEN = "OPEN"
+        CLOSED = "CLOSED"
+
+    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/F822.py

@@ -0,0 +1,3 @@
+a = 1
+
+__all__ = ["a", "b"]

resources/test/fixtures/F823.py

@@ -0,0 +1,27 @@
+my_dict = {}
+my_var = 0
+
+
+def foo():
+    my_var += 1
+
+
+def bar():
+    global my_var
+    my_var += 1
+
+
+def baz():
+    global my_var
+    global my_dict
+    my_dict[my_var] += 1
+
+
+def dec(x):
+    return x
+
+
+@dec
+def f():
+    dec = 1
+    return dec

resources/test/fixtures/F841.py

@@ -0,0 +1,37 @@
+try:
+    1 / 0
+except ValueError as e:
+    pass
+
+
+try:
+    1 / 0
+except ValueError as e:
+    print(e)
+
+
+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/N801.py

@@ -0,0 +1,34 @@
+class bad:
+    pass
+
+
+class _bad:
+    pass
+
+
+class bad_class:
+    pass
+
+
+class Bad_Class:
+    pass
+
+
+class BAD_CLASS:
+    pass
+
+
+class Good:
+    pass
+
+
+class _Good:
+    pass
+
+
+class GoodClass:
+    pass
+
+
+class GOOD:
+    pass

resources/test/fixtures/N802.py

@@ -0,0 +1,26 @@
+def Bad():
+    pass
+
+
+def _Bad():
+    pass
+
+
+def BAD():
+    pass
+
+
+def BAD_FUNC():
+    pass
+
+
+def good():
+    pass
+
+
+def _good():
+    pass
+
+
+def good_func():
+    pass

resources/test/fixtures/N803.py

@@ -0,0 +1,7 @@
+def func(a, A):
+    return a, A
+
+
+class Class:
+    def method(self, a, A):
+        return a, A

resources/test/fixtures/N804.py

@@ -0,0 +1,19 @@
+class Class:
+    @classmethod
+    def bad_class_method(this):
+        pass
+
+    @classmethod
+    def good_class_method(cls):
+        pass
+
+    def method(self):
+        pass
+
+    @staticmethod
+    def static_method(x):
+        return x
+
+
+def func(x):
+    return x

resources/test/fixtures/N805.py

@@ -0,0 +1,26 @@
+import random
+
+
+class Class:
+    def bad_method(this):
+        pass
+
+    if random.random(0, 2) == 0:
+
+        def extra_bad_method(this):
+            pass
+
+    def good_method(self):
+        pass
+
+    @classmethod
+    def class_method(cls):
+        pass
+
+    @staticmethod
+    def static_method(x):
+        return x
+
+
+def func(x):
+    return x

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/U004.py

@@ -0,0 +1,141 @@
+class A:
+    ...
+
+
+class A(object):
+    ...
+
+
+class A(
+    object,
+):
+    ...
+
+
+class A(
+    object,
+    #
+):
+    ...
+
+
+class A(
+    #
+    object,
+):
+    ...
+
+
+class A(
+    #
+    object
+):
+    ...
+
+
+class A(
+    object
+    #
+):
+    ...
+
+
+class A(
+    #
+    object,
+    #
+):
+    ...
+
+
+class A(
+    #
+    object,
+    #
+):
+    ...
+
+
+class A(
+    #
+    object
+    #
+):
+    ...
+
+
+class A(
+    #
+    object
+    #
+):
+    ...
+
+
+class B(A, object):
+    ...
+
+
+class B(object, A):
+    ...
+
+
+class B(
+    object,
+    A,
+):
+    ...
+
+
+class B(
+    A,
+    object,
+):
+    ...
+
+
+class B(
+    object,
+    # Comment on A.
+    A,
+):
+    ...
+
+
+class B(
+    # Comment on A.
+    A,
+    object,
+):
+    ...
+
+
+def f():
+    class A(object):
+        ...
+
+
+class A(
+    object,
+):
+    ...
+
+
+class A(
+    object,  # )
+):
+    ...
+
+
+class A(
+    object  # )
+    ,
+):
+    ...
+
+
+object = A
+
+
+class B(object):
+    ...

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