Bump version to 0.0.177

Fix quotes in SIM118 error message (#1204 )
Add notes around python-lsp-ruff (#1202 )
2022-12-11 22:38:52 -05:00 · 2022-12-11 22:30:39 -05:00 · 2022-12-11 17:36:20 -05:00 · 2022-12-11 17:13:09 -05:00 · 2022-12-11 13:31:14 -05:00 · 2022-12-11 10:34:52 -05:00
33 changed files with 560 additions and 98 deletions
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -20,6 +20,9 @@ jobs:
      - uses: actions-rs/toolchain@v1
        with:
          profile: minimal
+          toolchain: nightly-2022-11-01
+          override: true
+          components: rustfmt
      - uses: actions/cache@v3
        env:
          cache-name: cache-cargo
@@ -33,6 +36,12 @@ jobs:
            ${{ runner.os }}-build-
            ${{ runner.os }}-
      - run: cargo build --all --release
+      - run: ./target/release/ruff_dev generate-rules-table
+      - run: ./target/release/ruff_dev generate-options
+      - run: git diff --quiet README.md || echo "::error file=README.md::This file is outdated. You may have to rerun 'cargo dev generate-options' and/or 'cargo dev generate-rules-table'."
+      - run: ./target/release/ruff_dev generate-check-code-prefix && cargo fmt -- src/checks_gen.rs
+      - run: git diff --quiet src/checks_gen.rs || echo "::error file=src/checks_gen.rs::This file is outdated. You may have to rerun 'cargo dev generate-check-code-prefix'."
+      - run: git diff --exit-code -- README.md src/checks_gen.rs

  cargo_fmt:
    name: "cargo fmt"
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,6 +1,6 @@
 repos:
  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.175
+    rev: v0.0.177
    hooks:
      - id: ruff

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -724,7 +724,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"

 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.175-dev.0"
+version = "0.0.177-dev.0"
 dependencies = [
 "anyhow",
 "clap 4.0.29",
@@ -1821,7 +1821,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.0.175"
+version = "0.0.177"
 dependencies = [
 "annotate-snippets 0.9.1",
 "anyhow",
@@ -1874,7 +1874,7 @@ dependencies = [

 [[package]]
 name = "ruff_dev"
-version = "0.0.175"
+version = "0.0.177"
 dependencies = [
 "anyhow",
 "clap 4.0.29",
@@ -1892,7 +1892,7 @@ dependencies = [

 [[package]]
 name = "ruff_macros"
-version = "0.0.175"
+version = "0.0.177"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,7 +6,7 @@ members = [

 [package]
 name = "ruff"
-version = "0.0.175"
+version = "0.0.177"
 edition = "2021"
 rust-version = "1.65.0"

@@ -41,7 +41,7 @@ quick-junit = { version = "0.3.2" }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
 ropey = { version = "1.5.0", features = ["cr_lines", "simd"], default-features = false }
-ruff_macros = { version = "0.0.175", path = "ruff_macros" }
+ruff_macros = { version = "0.0.177", path = "ruff_macros" }
 rustc-hash = { version = "1.1.0" }
 rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "2edd0d264c50c7807bcff03a52a6509e8b7f187f" }
 rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "2edd0d264c50c7807bcff03a52a6509e8b7f187f" }
--- a/25
+++ b/25
@@ -438,6 +438,31 @@ are:
    SOFTWARE.
  """

+- flake8-simplify, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2020 Martin Thoma
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  """
+
 - isort, licensed as follows:
  """
    The MIT License (MIT)
--- a/README.md
+++ b/README.md
@@ -90,6 +90,7 @@ of [Conda](https://docs.conda.io/en/latest/):
   1. [flake8-print (T20)](#flake8-print-t20)
   1. [flake8-quotes (Q)](#flake8-quotes-q)
   1. [flake8-return (RET)](#flake8-return-ret)
+   1. [flake8-simplify (SIM)](#flake8-simplify-sim)
   1. [flake8-tidy-imports (TID)](#flake8-tidy-imports-tid)
   1. [flake8-unused-arguments (ARG)](#flake8-unused-arguments-arg)
   1. [eradicate (ERA)](#eradicate-era)
@@ -154,7 +155,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.175
+    rev: v0.0.177
    hooks:
      - id: ruff
 ```
@@ -369,7 +370,7 @@ For targeted exclusions across entire files (e.g., "Ignore all F841 violations i
 ### "Action Comments"

 Ruff respects `isort`'s ["Action Comments"](https://pycqa.github.io/isort/docs/configuration/action_comments.html)
-(`# isort: skip_file`, `# isort: on`, `# isort: off`, `# isort: skip`, and `isort: split`), which
+(`# isort: skip_file`, `# isort: on`, `# isort: off`, `# isort: skip`, and `# isort: split`), which
 enable selectively enabling and disabling import sorting for blocks of code and other inline
 configuration.

@@ -716,7 +717,7 @@ For more, see [flake8-comprehensions](https://pypi.org/project/flake8-comprehens
 | 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()` |  |
+| 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)()`) | 🛠 |
@@ -771,6 +772,14 @@ For more, see [flake8-return](https://pypi.org/project/flake8-return/1.2.0/) on
 | RET507 | SuperfluousElseContinue | Unnecessary `else` after `continue` statement |  |
 | RET508 | SuperfluousElseBreak | Unnecessary `else` after `break` statement |  |

+### flake8-simplify (SIM)
+
+For more, see [flake8-simplify](https://pypi.org/project/flake8-simplify/0.19.3/) on PyPI.
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| SIM118 | KeyInDict | Use `key in dict` instead of `key in dict.keys()` | 🛠 |
+
 ### flake8-tidy-imports (TID)

 For more, see [flake8-tidy-imports](https://pypi.org/project/flake8-tidy-imports/4.8.0/) on PyPI.
@@ -843,6 +852,37 @@ For more, see [Pylint](https://pypi.org/project/pylint/2.15.7/) on PyPI.

 Download the [Ruff VS Code extension](https://marketplace.visualstudio.com/items?itemName=charliermarsh.ruff).

+### Language Server Protocol
+
+Ruff is available as a [Language Server Protocol (LSP)](https://microsoft.github.io/language-server-protocol/)
+server, distributed as the [`python-lsp-ruff`](https://github.com/python-lsp/python-lsp-ruff) plugin
+for [`python-lsp-server`](https://github.com/python-lsp/python-lsp-server), both of which are
+installable via [PyPI](https://pypi.org/project/python-lsp-ruff/):
+
+```shell
+pip install python-lsp-server python-lsp-ruff
+```
+
+The LSP server can be used with any editor that supports the Language Server Protocol. For example,
+to use it with Neovim, you would add something like the following to your `init.lua`:
+
+```lua
+require'lspconfig'.pylsp.setup {
+  settings = {
+    pylsp = {
+      plugins = {
+        ruff = {
+          enabled = true
+        }
+      }
+    }
+  },
+}
+```
+
+[`ruffd`](https://github.com/Seamooo/ruffd) is another implementation of the Language Server
+Protocol (LSP) for Ruff, written in Rust.
+
 ### PyCharm

 Ruff can be installed as an [External Tool](https://www.jetbrains.com/help/pycharm/configuring-third-party-tools.html)
@@ -855,10 +895,13 @@ 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)

-### Vim & Neovim (Unofficial)
+### Vim & Neovim

-Ruff is available as part of the [coc-pyright](https://github.com/fannheyward/coc-pyright) extension
-for coc.nvim.
+Ruff can be integrated into any editor that supports the Language Server Protocol (LSP) (see:
+[Language Server Protocol](#language-server-protocol)).
+
+Ruff is also available as part of the [coc-pyright](https://github.com/fannheyward/coc-pyright)
+extension for `coc.nvim`.

 <details>
 <summary>Ruff can also be integrated via <a href="https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#efm"><code>efm</code></a> in just a <a href="https://github.com/JafarAbdi/myconfigs/blob/6f0b6b2450e92ec8fc50422928cd22005b919110/efm-langserver/config.yaml#L14-L20">few lines</a>.</summary>
@@ -914,11 +957,6 @@ null_ls.setup({

 </details>

-### Language Server Protocol (Unofficial)
-
-[`ruffd`](https://github.com/Seamooo/ruffd) is a Rust-based language server for Ruff that implements
-the Language Server Protocol (LSP).
-
 ### GitHub Actions

 GitHub Actions has everything you need to run Ruff out-of-the-box:
@@ -966,9 +1004,8 @@ Under those conditions, Ruff implements every rule in Flake8.
 Ruff also re-implements some of the most popular Flake8 plugins and related code quality tools
 natively, including:

- [`isort`](https://pypi.org/project/isort/)
- [`pydocstyle`](https://pypi.org/project/pydocstyle/)
- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
+- [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
+- [`eradicate`](https://pypi.org/project/eradicate/)
 - [`flake8-2020`](https://pypi.org/project/flake8-2020/)
 - [`flake8-annotations`](https://pypi.org/project/flake8-annotations/)
 - [`flake8-bandit`](https://pypi.org/project/flake8-bandit/) (6/40)
@@ -986,12 +1023,13 @@ natively, including:
 - [`flake8-return`](https://pypi.org/project/flake8-return/)
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-tidy-imports`](https://pypi.org/project/flake8-tidy-imports/) (1/3)
+- [`isort`](https://pypi.org/project/isort/)
 - [`mccabe`](https://pypi.org/project/mccabe/)
- [`yesqa`](https://github.com/asottile/yesqa)
- [`eradicate`](https://pypi.org/project/eradicate/)
- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (16/33)
+- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
+- [`pydocstyle`](https://pypi.org/project/pydocstyle/)
 - [`pygrep-hooks`](https://github.com/pre-commit/pygrep-hooks) (1/10)
- [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
+- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (16/33)
+- [`yesqa`](https://github.com/asottile/yesqa)

 Note that, in some cases, Ruff uses different error code prefixes than would be found in the
 originating Flake8 plugins. For example, Ruff uses `TID252` to represent the `I252` rule from
@@ -1022,8 +1060,6 @@ Pylint parity is being tracked in [#689](https://github.com/charliermarsh/ruff/i

 Today, Ruff can be used to replace Flake8 when used with any of the following plugins:

- [`pydocstyle`](https://pypi.org/project/pydocstyle/)
- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
 - [`flake8-2020`](https://pypi.org/project/flake8-2020/)
 - [`flake8-annotations`](https://pypi.org/project/flake8-annotations/)
 - [`flake8-bandit`](https://pypi.org/project/flake8-bandit/) (6/40)
@@ -1042,6 +1078,8 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-tidy-imports`](https://pypi.org/project/flake8-tidy-imports/) (1/3)
 - [`mccabe`](https://pypi.org/project/mccabe/)
+- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
+- [`pydocstyle`](https://pypi.org/project/pydocstyle/)

 Ruff can also replace [`isort`](https://pypi.org/project/isort/),
 [`yesqa`](https://github.com/asottile/yesqa), [`eradicate`](https://pypi.org/project/eradicate/),
--- a/flake8_to_ruff/Cargo.lock
+++ b/flake8_to_ruff/Cargo.lock
@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"

 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.175"
+version = "0.0.177"
 dependencies = [
 "anyhow",
 "clap",
@@ -1975,7 +1975,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.0.175"
+version = "0.0.177"
 dependencies = [
 "anyhow",
 "bincode",
--- a/flake8_to_ruff/Cargo.toml
+++ b/flake8_to_ruff/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.175-dev.0"
+version = "0.0.177-dev.0"
 edition = "2021"

 [lib]
--- a/flake8_to_ruff/src/plugin.rs
+++ b/flake8_to_ruff/src/plugin.rs
@@ -18,6 +18,7 @@ pub enum Plugin {
    Flake8Print,
    Flake8Quotes,
    Flake8Return,
+    Flake8Simplify,
    Flake8TidyImports,
    McCabe,
    PEP8Naming,
@@ -41,6 +42,7 @@ impl FromStr for Plugin {
            "flake8-print" => Ok(Plugin::Flake8Print),
            "flake8-quotes" => Ok(Plugin::Flake8Quotes),
            "flake8-return" => Ok(Plugin::Flake8Return),
+            "flake8-simplify" => Ok(Plugin::Flake8Simplify),
            "flake8-tidy-imports" => Ok(Plugin::Flake8TidyImports),
            "mccabe" => Ok(Plugin::McCabe),
            "pep8-naming" => Ok(Plugin::PEP8Naming),
@@ -65,6 +67,7 @@ impl Plugin {
            Plugin::Flake8Print => CheckCodePrefix::T2,
            Plugin::Flake8Quotes => CheckCodePrefix::Q,
            Plugin::Flake8Return => CheckCodePrefix::RET,
+            Plugin::Flake8Simplify => CheckCodePrefix::SIM,
            Plugin::Flake8TidyImports => CheckCodePrefix::I25,
            Plugin::McCabe => CheckCodePrefix::C9,
            Plugin::PEP8Naming => CheckCodePrefix::N,
@@ -101,6 +104,7 @@ impl Plugin {
            Plugin::Flake8Print => vec![CheckCodePrefix::T2],
            Plugin::Flake8Quotes => vec![CheckCodePrefix::Q],
            Plugin::Flake8Return => vec![CheckCodePrefix::RET],
+            Plugin::Flake8Simplify => vec![CheckCodePrefix::SIM],
            Plugin::Flake8TidyImports => vec![CheckCodePrefix::I25],
            Plugin::McCabe => vec![CheckCodePrefix::C9],
            Plugin::PEP8Naming => vec![CheckCodePrefix::N],
@@ -397,6 +401,7 @@ pub fn infer_plugins_from_codes(codes: &BTreeSet<CheckCodePrefix>) -> Vec<Plugin
        Plugin::Flake8Print,
        Plugin::Flake8Quotes,
        Plugin::Flake8Return,
+        Plugin::Flake8Simplify,
        Plugin::Flake8TidyImports,
        Plugin::PEP8Naming,
        Plugin::Pyupgrade,
--- a/resources/test/fixtures/flake8_simplify/SIM118.py
+++ b/resources/test/fixtures/flake8_simplify/SIM118.py
@@ -0,0 +1,12 @@
+key in dict.keys() # SIM118
+
+foo["bar"] in dict.keys() # SIM118
+
+foo() in dict.keys() # SIM118
+
+for key in dict.keys(): # SIM118
+    pass
+
+for key in list(dict.keys()):
+    if some_property(key):
+        del dict[key]
--- a/resources/test/fixtures/isort/insert_empty_lines.py
+++ b/resources/test/fixtures/isort/insert_empty_lines.py
@@ -39,3 +39,27 @@ if True:
    import collections
    import typing
    def f(): pass
+
+
+import os
+
+# Comment goes here.
+
+def f():
+    pass
+
+
+import os
+
+# Comment goes here.
+def f():
+    pass
+
+
+import os
+
+# Comment goes here.
+
+# And another.
+def f():
+    pass
--- a/resources/test/fixtures/isort/insert_empty_lines.pyi
+++ b/resources/test/fixtures/isort/insert_empty_lines.pyi
@@ -39,3 +39,27 @@ if True:
    import collections
    import typing
    def f(): pass
+
+
+import os
+
+# Comment goes here.
+
+def f():
+    pass
+
+
+import os
+
+# Comment goes here.
+def f():
+    pass
+
+
+import os
+
+# Comment goes here.
+
+# And another.
+def f():
+    pass
--- a/resources/test/fixtures/pyflakes/F821_6.py
+++ b/resources/test/fixtures/pyflakes/F821_6.py
@@ -0,0 +1,17 @@
+"""Test: annotated global."""
+
+
+n: int
+
+
+def f():
+    print(n)
+
+
+def g():
+    global n
+    n = 1
+
+
+g()
+f()
--- a/ruff_dev/Cargo.toml
+++ b/ruff_dev/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.175"
+version = "0.0.177"
 edition = "2021"

 [dependencies]
--- a/ruff_macros/Cargo.toml
+++ b/ruff_macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_macros"
-version = "0.0.175"
+version = "0.0.177"
 edition = "2021"

 [lib]
--- a/src/check_ast.rs
+++ b/src/check_ast.rs
@@ -37,7 +37,7 @@ use crate::visibility::{module_visibility, transition_scope, Modifier, Visibilit
 use crate::{
    docstrings, flake8_2020, flake8_annotations, flake8_bandit, flake8_blind_except,
    flake8_boolean_trap, flake8_bugbear, flake8_builtins, flake8_comprehensions, flake8_debugger,
-    flake8_import_conventions, flake8_print, flake8_return, flake8_tidy_imports,
+    flake8_import_conventions, flake8_print, flake8_return, flake8_simplify, flake8_tidy_imports,
    flake8_unused_arguments, mccabe, pep8_naming, pycodestyle, pydocstyle, pyflakes, pygrep_hooks,
    pylint, pyupgrade, visibility,
 };
@@ -1059,6 +1059,9 @@ where
                if self.settings.enabled.contains(&CheckCode::PLW0120) {
                    pylint::plugins::useless_else_on_loop(self, stmt, body, orelse);
                }
+                if self.settings.enabled.contains(&CheckCode::SIM118) {
+                    flake8_simplify::plugins::key_in_dict_for(self, target, iter);
+                }
            }
            StmtKind::Try { handlers, .. } => {
                if self.settings.enabled.contains(&CheckCode::F707) {
@@ -1155,7 +1158,13 @@ where
                // If any global bindings don't already exist in the global scope, add it.
                let globals = operations::extract_globals(body);
                for (name, stmt) in operations::extract_globals(body) {
-                    if !self.scopes[GLOBAL_SCOPE_INDEX].values.contains_key(name) {
+                    if self.scopes[GLOBAL_SCOPE_INDEX]
+                        .values
+                        .get(name)
+                        .map_or(true, |index| {
+                            matches!(self.bindings[*index].kind, BindingKind::Annotation)
+                        })
+                    {
                        let index = self.bindings.len();
                        self.bindings.push(Binding {
                            kind: BindingKind::Assignment,
@@ -1207,7 +1216,13 @@ where
                // If any global bindings don't already exist in the global scope, add it.
                let globals = operations::extract_globals(body);
                for (name, stmt) in &globals {
-                    if !self.scopes[GLOBAL_SCOPE_INDEX].values.contains_key(name) {
+                    if self.scopes[GLOBAL_SCOPE_INDEX]
+                        .values
+                        .get(name)
+                        .map_or(true, |index| {
+                            matches!(self.bindings[*index].kind, BindingKind::Annotation)
+                        })
+                    {
                        let index = self.bindings.len();
                        self.bindings.push(Binding {
                            kind: BindingKind::Assignment,
@@ -2078,6 +2093,16 @@ where
                        comparators,
                    );
                }
+
+                if self.settings.enabled.contains(&CheckCode::SIM118) {
+                    flake8_simplify::plugins::key_in_dict_compare(
+                        self,
+                        expr,
+                        left,
+                        ops,
+                        comparators,
+                    );
+                }
            }
            ExprKind::Constant {
                value: Constant::Str(value),
@@ -2717,6 +2742,7 @@ impl<'a> Checker<'a> {
            let mut first_iter = true;
            let mut in_generator = false;
            let mut import_starred = false;
+
            for scope_index in self.scope_stack.iter().rev() {
                let scope = &self.scopes[*scope_index];

--- a/src/check_imports.rs
+++ b/src/check_imports.rs
@@ -37,7 +37,7 @@ pub fn check_imports(
    autofix: bool,
    path: &Path,
 ) -> Vec<Check> {
-    let mut tracker = ImportTracker::new(directives, path);
+    let mut tracker = ImportTracker::new(locator, directives, path);
    for stmt in python_ast {
        tracker.visit_stmt(stmt);
    }
--- a/src/checks.rs
+++ b/src/checks.rs
@@ -206,6 +206,8 @@ pub enum CheckCode {
    YTT301,
    YTT302,
    YTT303,
+    // flake8-simplify
+    SIM118,
    // pyupgrade
    UP001,
    UP003,
@@ -337,6 +339,7 @@ pub enum CheckCategory {
    Flake8Print,
    Flake8Quotes,
    Flake8Return,
+    Flake8Simplify,
    Flake8TidyImports,
    Flake8UnusedArguments,
    Eradicate,
@@ -377,6 +380,7 @@ impl CheckCategory {
            CheckCategory::Flake8Quotes => "flake8-quotes",
            CheckCategory::Flake8Return => "flake8-return",
            CheckCategory::Flake8TidyImports => "flake8-tidy-imports",
+            CheckCategory::Flake8Simplify => "flake8-simplify",
            CheckCategory::Flake8UnusedArguments => "flake8-unused-arguments",
            CheckCategory::Isort => "isort",
            CheckCategory::McCabe => "mccabe",
@@ -406,6 +410,7 @@ impl CheckCategory {
            CheckCategory::Flake8Print => vec![CheckCodePrefix::T20],
            CheckCategory::Flake8Quotes => vec![CheckCodePrefix::Q],
            CheckCategory::Flake8Return => vec![CheckCodePrefix::RET],
+            CheckCategory::Flake8Simplify => vec![CheckCodePrefix::SIM],
            CheckCategory::Flake8TidyImports => vec![CheckCodePrefix::TID],
            CheckCategory::Flake8UnusedArguments => vec![CheckCodePrefix::ARG],
            CheckCategory::Isort => vec![CheckCodePrefix::I],
@@ -481,6 +486,10 @@ impl CheckCategory {
                "https://pypi.org/project/flake8-return/1.2.0/",
                &Platform::PyPI,
            )),
+            CheckCategory::Flake8Simplify => Some((
+                "https://pypi.org/project/flake8-simplify/0.19.3/",
+                &Platform::PyPI,
+            )),
            CheckCategory::Flake8TidyImports => Some((
                "https://pypi.org/project/flake8-tidy-imports/4.8.0/",
                &Platform::PyPI,
@@ -746,6 +755,8 @@ pub enum CheckKind {
    SysVersion0Referenced,
    SysVersionCmpStr10,
    SysVersionSlice1Referenced,
+    // flake8-simplify
+    KeyInDict(String, String),
    // pyupgrade
    TypeOfPrimitive(Primitive),
    UselessMetaclassType,
@@ -1082,6 +1093,8 @@ impl CheckCode {
            CheckCode::YTT303 => CheckKind::SysVersionSlice1Referenced,
            // flake8-blind-except
            CheckCode::BLE001 => CheckKind::BlindExcept("Exception".to_string()),
+            // flake8-simplify
+            CheckCode::SIM118 => CheckKind::KeyInDict("key".to_string(), "dict".to_string()),
            // pyupgrade
            CheckCode::UP001 => CheckKind::UselessMetaclassType,
            CheckCode::UP003 => CheckKind::TypeOfPrimitive(Primitive::Str),
@@ -1442,6 +1455,7 @@ impl CheckCode {
            CheckCode::S105 => CheckCategory::Flake8Bandit,
            CheckCode::S106 => CheckCategory::Flake8Bandit,
            CheckCode::S107 => CheckCategory::Flake8Bandit,
+            CheckCode::SIM118 => CheckCategory::Flake8Simplify,
            CheckCode::T100 => CheckCategory::Flake8Debugger,
            CheckCode::T201 => CheckCategory::Flake8Print,
            CheckCode::T203 => CheckCategory::Flake8Print,
@@ -1650,6 +1664,8 @@ impl CheckKind {
            CheckKind::SysVersion0Referenced => &CheckCode::YTT301,
            CheckKind::SysVersionCmpStr10 => &CheckCode::YTT302,
            CheckKind::SysVersionSlice1Referenced => &CheckCode::YTT303,
+            // flake8-simplify
+            CheckKind::KeyInDict(..) => &CheckCode::SIM118,
            // pyupgrade
            CheckKind::TypeOfPrimitive(_) => &CheckCode::UP003,
            CheckKind::UselessMetaclassType => &CheckCode::UP001,
@@ -2316,6 +2332,10 @@ impl CheckKind {
            CheckKind::SysVersionSlice1Referenced => {
                "`sys.version[:1]` referenced (python10), use `sys.version_info`".to_string()
            }
+            // flake8-simplify
+            CheckKind::KeyInDict(key, dict) => {
+                format!("Use `{key} in {dict}` instead of `{key} in {dict}.keys()`")
+            }
            // pyupgrade
            CheckKind::TypeOfPrimitive(primitive) => {
                format!("Use `{}` instead of `type(...)`", primitive.builtin())
@@ -2660,6 +2680,7 @@ impl CheckKind {
                | CheckKind::ImplicitReturn
                | CheckKind::ImplicitReturnValue
                | CheckKind::IsLiteral
+                | CheckKind::KeyInDict(..)
                | CheckKind::MisplacedComparisonConstant(..)
                | CheckKind::NewLineAfterLastParagraph
                | CheckKind::NewLineAfterSectionName(..)
@@ -2692,6 +2713,7 @@ impl CheckKind {
                | CheckKind::SuperCallWithParameters
                | CheckKind::TrueFalseComparison(..)
                | CheckKind::TypeOfPrimitive(..)
+                | CheckKind::UnnecessaryCallAroundSorted(..)
                | CheckKind::UnnecessaryCollectionCall(..)
                | CheckKind::UnnecessaryComprehension(..)
                | CheckKind::UnnecessaryEncodeUTF8
--- a/src/checks_gen.rs
+++ b/src/checks_gen.rs
@@ -382,6 +382,10 @@ pub enum CheckCodePrefix {
    S105,
    S106,
    S107,
+    SIM,
+    SIM1,
+    SIM11,
+    SIM118,
    T,
    T1,
    T10,
@@ -1494,6 +1498,10 @@ impl CheckCodePrefix {
            CheckCodePrefix::S105 => vec![CheckCode::S105],
            CheckCodePrefix::S106 => vec![CheckCode::S106],
            CheckCodePrefix::S107 => vec![CheckCode::S107],
+            CheckCodePrefix::SIM => vec![CheckCode::SIM118],
+            CheckCodePrefix::SIM1 => vec![CheckCode::SIM118],
+            CheckCodePrefix::SIM11 => vec![CheckCode::SIM118],
+            CheckCodePrefix::SIM118 => vec![CheckCode::SIM118],
            CheckCodePrefix::T => vec![CheckCode::T100, CheckCode::T201, CheckCode::T203],
            CheckCodePrefix::T1 => vec![CheckCode::T100],
            CheckCodePrefix::T10 => vec![CheckCode::T100],
@@ -2203,6 +2211,10 @@ impl CheckCodePrefix {
            CheckCodePrefix::S105 => SuffixLength::Three,
            CheckCodePrefix::S106 => SuffixLength::Three,
            CheckCodePrefix::S107 => SuffixLength::Three,
+            CheckCodePrefix::SIM => SuffixLength::Zero,
+            CheckCodePrefix::SIM1 => SuffixLength::One,
+            CheckCodePrefix::SIM11 => SuffixLength::Two,
+            CheckCodePrefix::SIM118 => SuffixLength::Three,
            CheckCodePrefix::T => SuffixLength::Zero,
            CheckCodePrefix::T1 => SuffixLength::One,
            CheckCodePrefix::T10 => SuffixLength::Two,
@@ -2303,6 +2315,7 @@ pub const CATEGORIES: &[CheckCodePrefix] = &[
    CheckCodePrefix::RET,
    CheckCodePrefix::RUF,
    CheckCodePrefix::S,
+    CheckCodePrefix::SIM,
    CheckCodePrefix::T,
    CheckCodePrefix::TID,
    CheckCodePrefix::UP,
--- a/src/flake8_simplify/mod.rs
+++ b/src/flake8_simplify/mod.rs
@@ -0,0 +1,29 @@
+pub mod plugins;
+
+#[cfg(test)]
+mod tests {
+    use std::convert::AsRef;
+    use std::path::Path;
+
+    use anyhow::Result;
+    use test_case::test_case;
+
+    use crate::checks::CheckCode;
+    use crate::linter::test_path;
+    use crate::settings;
+
+    #[test_case(CheckCode::SIM118, Path::new("SIM118.py"); "SIM118")]
+    fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
+        let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
+        let mut checks = test_path(
+            Path::new("./resources/test/fixtures/flake8_simplify")
+                .join(path)
+                .as_path(),
+            &settings::Settings::for_rule(check_code),
+            true,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+}
--- a/src/flake8_simplify/plugins/key_in_dict.rs
+++ b/src/flake8_simplify/plugins/key_in_dict.rs
@@ -0,0 +1,74 @@
+use rustpython_ast::{Cmpop, Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::autofix::Fix;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckCode, CheckKind};
+
+/// SIM118
+fn key_in_dict(checker: &mut Checker, left: &Expr, right: &Expr, range: Range) {
+    let ExprKind::Call {
+        func,
+        args,
+        keywords,
+    } = &right.node else {
+        return;
+    };
+    if !(args.is_empty() && keywords.is_empty()) {
+        return;
+    }
+
+    let ExprKind::Attribute { attr, value, .. } = &func.node else {
+        return;
+    };
+    if attr != "keys" {
+        return;
+    }
+
+    let mut check = Check::new(
+        CheckKind::KeyInDict(left.to_string(), value.to_string()),
+        range,
+    );
+    if checker.patch(&CheckCode::SIM118) {
+        let content = right.to_string().replace(".keys()", "");
+        check.amend(Fix::replacement(
+            content,
+            right.location,
+            right.end_location.unwrap(),
+        ));
+    }
+    checker.add_check(check);
+}
+
+/// SIM118 in a for loop
+pub fn key_in_dict_for(checker: &mut Checker, target: &Expr, iter: &Expr) {
+    key_in_dict(
+        checker,
+        target,
+        iter,
+        Range {
+            location: target.location,
+            end_location: iter.end_location.unwrap(),
+        },
+    );
+}
+
+/// SIM118 in a comparison
+pub fn key_in_dict_compare(
+    checker: &mut Checker,
+    expr: &Expr,
+    left: &Expr,
+    ops: &[Cmpop],
+    comparators: &[Expr],
+) {
+    if !matches!(ops[..], [Cmpop::In]) {
+        return;
+    }
+
+    if comparators.len() != 1 {
+        return;
+    }
+    let right = comparators.first().unwrap();
+
+    key_in_dict(checker, left, right, Range::from_located(expr));
+}
--- a/src/flake8_simplify/plugins/mod.rs
+++ b/src/flake8_simplify/plugins/mod.rs
@@ -0,0 +1,3 @@
+pub use key_in_dict::{key_in_dict_compare, key_in_dict_for};
+
+mod key_in_dict;
--- a/src/flake8_simplify/snapshots/ruff__flake8_simplifytestsSIM118_SIM118.py.snap
+++ b/src/flake8_simplify/snapshots/ruff__flake8_simplifytestsSIM118_SIM118.py.snap
@@ -0,0 +1,77 @@
+---
+source: src/flake8_simplify/mod.rs
+expression: checks
+---
+- kind:
+    KeyInDict:
+      - key
+      - dict
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 1
+    column: 18
+  fix:
+    content: dict
+    location:
+      row: 1
+      column: 7
+    end_location:
+      row: 1
+      column: 18
+- kind:
+    KeyInDict:
+      - "foo['bar']"
+      - dict
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 25
+  fix:
+    content: dict
+    location:
+      row: 3
+      column: 14
+    end_location:
+      row: 3
+      column: 25
+- kind:
+    KeyInDict:
+      - foo()
+      - dict
+  location:
+    row: 5
+    column: 0
+  end_location:
+    row: 5
+    column: 20
+  fix:
+    content: dict
+    location:
+      row: 5
+      column: 9
+    end_location:
+      row: 5
+      column: 20
+- kind:
+    KeyInDict:
+      - key
+      - dict
+  location:
+    row: 7
+    column: 4
+  end_location:
+    row: 7
+    column: 22
+  fix:
+    content: dict
+    location:
+      row: 7
+      column: 11
+    end_location:
+      row: 7
+      column: 22
+
--- a/src/isort/helpers.rs
+++ b/src/isort/helpers.rs
@@ -0,0 +1,55 @@
+use rustpython_ast::Stmt;
+
+use crate::source_code_locator::SourceCodeLocator;
+
+/// Return `true` if a `Stmt` is preceded by a "comment break"
+pub fn has_comment_break(stmt: &Stmt, locator: &SourceCodeLocator) -> bool {
+    // Starting from the `Stmt` (`def f(): pass`), we want to detect patterns like
+    // this:
+    //
+    //   import os
+    //
+    //   # Detached comment.
+    //
+    //   def f(): pass
+
+    // This should also be detected:
+    //
+    //   import os
+    //
+    //   # Detached comment.
+    //
+    //   # Direct comment.
+    //   def f(): pass
+
+    // But this should not:
+    //
+    //   import os
+    //
+    //   # Direct comment.
+    //   def f(): pass
+    let mut seen_blank = false;
+    for line in locator
+        .slice_source_code_until(&stmt.location)
+        .lines()
+        .rev()
+    {
+        let line = line.trim();
+        if seen_blank {
+            if line.starts_with('#') {
+                return true;
+            } else if !line.is_empty() {
+                break;
+            }
+        } else {
+            if line.is_empty() {
+                seen_blank = true;
+            } else if line.starts_with('#') || line.starts_with('@') {
+                continue;
+            } else {
+                break;
+            }
+        }
+    }
+    false
+}
--- a/src/isort/mod.rs
+++ b/src/isort/mod.rs
@@ -18,6 +18,7 @@ use crate::isort::types::{
 mod categorize;
 mod comments;
 pub mod format;
+mod helpers;
 pub mod plugins;
 pub mod settings;
 mod sorting;
--- a/src/isort/snapshots/ruffisorttests__insert_empty_lines.py.snap
+++ b/src/isort/snapshots/ruffisorttests__insert_empty_lines.py.snap
@@ -49,32 +49,17 @@ expression: checks
      column: 0
 - kind: UnsortedImports
  location:
-    row: 33
+    row: 52
    column: 0
  end_location:
-    row: 35
+    row: 54
    column: 0
  fix:
-    content: "    import collections\n    import typing\n\n"
+    content: "import os\n\n\n"
    location:
-      row: 33
+      row: 52
      column: 0
    end_location:
-      row: 35
-      column: 0
- kind: UnsortedImports
-  location:
-    row: 39
-    column: 0
-  end_location:
-    row: 41
-    column: 0
-  fix:
-    content: "    import collections\n    import typing\n\n"
-    location:
-      row: 39
-      column: 0
-    end_location:
-      row: 41
+      row: 54
      column: 0

--- a/src/isort/snapshots/ruffisorttests__insert_empty_lines.pyi.snap
+++ b/src/isort/snapshots/ruffisorttests__insert_empty_lines.pyi.snap
@@ -47,19 +47,4 @@ expression: checks
    end_location:
      row: 16
      column: 0
- kind: UnsortedImports
-  location:
-    row: 33
-    column: 0
-  end_location:
-    row: 35
-    column: 0
-  fix:
-    content: "    import collections\n    import typing\n\n"
-    location:
-      row: 33
-      column: 0
-    end_location:
-      row: 35
-      column: 0

--- a/src/isort/snapshots/ruffisorttests__trailing_suffix.py.snap
+++ b/src/isort/snapshots/ruffisorttests__trailing_suffix.py.snap
@@ -25,7 +25,7 @@ expression: checks
    row: 6
    column: 13
  fix:
-    content: "    import os\n    import sys\n\n"
+    content: "    import os\n    import sys\n"
    location:
      row: 5
      column: 0
--- a/src/isort/track.rs
+++ b/src/isort/track.rs
@@ -8,20 +8,24 @@ use rustpython_ast::{

 use crate::ast::visitor::Visitor;
 use crate::directives::IsortDirectives;
+use crate::isort::helpers;
+use crate::source_code_locator::SourceCodeLocator;

+#[derive(Debug)]
 pub enum Trailer {
    Sibling,
    ClassDef,
    FunctionDef,
 }

-#[derive(Default)]
+#[derive(Debug, Default)]
 pub struct Block<'a> {
    pub imports: Vec<&'a Stmt>,
    pub trailer: Option<Trailer>,
 }

 pub struct ImportTracker<'a> {
+    locator: &'a SourceCodeLocator<'a>,
    directives: &'a IsortDirectives,
    pyi: bool,
    blocks: Vec<Block<'a>>,
@@ -30,8 +34,13 @@ pub struct ImportTracker<'a> {
 }

 impl<'a> ImportTracker<'a> {
-    pub fn new(directives: &'a IsortDirectives, path: &'a Path) -> Self {
+    pub fn new(
+        locator: &'a SourceCodeLocator<'a>,
+        directives: &'a IsortDirectives,
+        path: &'a Path,
+    ) -> Self {
        Self {
+            locator,
            directives,
            pyi: path.extension().map_or(false, |ext| ext == "pyi"),
            blocks: vec![Block::default()],
@@ -46,31 +55,46 @@ impl<'a> ImportTracker<'a> {
    }

    fn trailer_for(&self, stmt: &'a Stmt) -> Option<Trailer> {
-        if self.pyi {
-            // Black treats interface files differently, limiting to one newline
-            // (`Trailing::Sibling`), and avoiding inserting any newlines in nested function
-            // blocks.
-            if self.nested
-                && matches!(
-                    stmt.node,
-                    StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. }
-                )
-            {
-                None
-            } else {
-                Some(Trailer::Sibling)
-            }
-        } else if self.nested {
-            Some(Trailer::Sibling)
-        } else {
-            Some(match &stmt.node {
-                StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
-                    Trailer::FunctionDef
-                }
-                StmtKind::ClassDef { .. } => Trailer::ClassDef,
-                _ => Trailer::Sibling,
-            })
+        // No need to compute trailers if we won't be finalizing anything.
+        let index = self.blocks.len() - 1;
+        if self.blocks[index].imports.is_empty() {
+            return None;
        }
+
+        // Similar to isort, avoid enforcing any newline behaviors in nested blocks.
+        if self.nested {
+            return None;
+        }
+
+        Some(if self.pyi {
+            // Black treats interface files differently, limiting to one newline
+            // (`Trailing::Sibling`).
+            Trailer::Sibling
+        } else {
+            // If the import block is followed by a class or function, we want to enforce
+            // two blank lines. The exception: if, between the import and the class or
+            // function, we have at least one commented line, followed by at
+            // least one blank line. In that case, we treat it as a regular
+            // sibling (i.e., as if the comment is the next statement, as
+            // opposed to the class or function).
+            match &stmt.node {
+                StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
+                    if helpers::has_comment_break(stmt, self.locator) {
+                        Trailer::Sibling
+                    } else {
+                        Trailer::FunctionDef
+                    }
+                }
+                StmtKind::ClassDef { .. } => {
+                    if helpers::has_comment_break(stmt, self.locator) {
+                        Trailer::Sibling
+                    } else {
+                        Trailer::ClassDef
+                    }
+                }
+                _ => Trailer::Sibling,
+            }
+        })
    }

    fn finalize(&mut self, trailer: Option<Trailer>) {
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -53,6 +53,7 @@ mod flake8_import_conventions;
 mod flake8_print;
 pub mod flake8_quotes;
 mod flake8_return;
+mod flake8_simplify;
 pub mod flake8_tidy_imports;
 mod flake8_unused_arguments;
 pub mod fs;
--- a/src/pyflakes/mod.rs
+++ b/src/pyflakes/mod.rs
@@ -93,6 +93,7 @@ mod tests {
    #[test_case(CheckCode::F821, Path::new("F821_3.py"); "F821_3")]
    #[test_case(CheckCode::F821, Path::new("F821_4.py"); "F821_4")]
    #[test_case(CheckCode::F821, Path::new("F821_5.py"); "F821_5")]
+    #[test_case(CheckCode::F821, Path::new("F821_6.py"); "F821_6")]
    #[test_case(CheckCode::F822, Path::new("F822.py"); "F822")]
    #[test_case(CheckCode::F823, Path::new("F823.py"); "F823")]
    #[test_case(CheckCode::F831, Path::new("F831.py"); "F831")]
--- a/src/pyflakes/snapshots/ruffpyflakestests__F821_F821_6.py.snap
+++ b/src/pyflakes/snapshots/ruffpyflakestests__F821_F821_6.py.snap
@@ -0,0 +1,6 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+[]
+
--- a/src/source_code_locator.rs
+++ b/src/source_code_locator.rs
@@ -31,6 +31,12 @@ impl<'a> SourceCodeLocator<'a> {
        Cow::from(rope.slice(offset..))
    }

+    pub fn slice_source_code_until(&self, location: &Location) -> Cow<'_, str> {
+        let rope = self.get_or_init_rope();
+        let offset = rope.line_to_char(location.row() - 1) + location.column();
+        Cow::from(rope.slice(..offset))
+    }
+
    pub fn slice_source_code_range(&self, range: &Range) -> Cow<'_, str> {
        let rope = self.get_or_init_rope();
        let start = rope.line_to_char(range.location.row() - 1) + range.location.column();
Author	SHA1	Message	Date
Charlie Marsh	19e9eb1af8	Bump version to 0.0.177	2022-12-11 22:38:52 -05:00
Anders Kaseorg	e57044800c	Fix quotes in SIM118 error message (#1204 )	2022-12-11 22:30:39 -05:00
Charlie Marsh	ae8ff7cb7f	Add notes around python-lsp-ruff (#1202 )	2022-12-11 17:36:20 -05:00
Charlie Marsh	c05914f222	Avoid inserting extra newlines for comment-delimited import blocks (#1201 )	2022-12-11 17:13:09 -05:00
Charlie Marsh	24179655b8	Fix 'a test' reference	2022-12-11 13:31:14 -05:00
Charlie Marsh	d27b419e68	Run cargo dev generate-options	2022-12-11 10:34:52 -05:00
Charlie Marsh	9fc7a32a24	Sort list in README	2022-12-11 10:25:27 -05:00
Charlie Marsh	9161b866b5	Bump version to 0.0.176	2022-12-11 10:19:50 -05:00
Reiner Gerecke	38141a6f14	Check for outdated auto-generated files in CI (#1192 )	2022-12-11 10:18:57 -05:00
Charlie Marsh	aa5402fc0e	Add flake8-simplify to flake8-to-ruff	2022-12-11 10:10:46 -05:00
Charlie Marsh	99f077aa4e	Add missing hash in README comment	2022-12-11 10:05:32 -05:00
Reiner Gerecke	7f25d1ec70	Implement SIM118 (key in dict) of flake8-simplify (#1195 )	2022-12-11 10:05:11 -05:00
Charlie Marsh	360b033e04	Avoid F821 false positive on annotated global (#1196 )	2022-12-11 10:04:06 -05:00
Reiner Gerecke	247dcc9f9c	Mark C413 as fixable (#1191 )	2022-12-11 09:07:51 -05:00