Bump version to 0.0.156

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.152
+    rev: v0.0.156
     hooks:
       - id: ruff
 

Cargo.lock

@@ -703,7 +703,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.152-dev.0"
+version = "0.0.156-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.22",
@@ -1837,7 +1837,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.152"
+version = "0.0.156"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1889,13 +1889,14 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.152"
+version = "0.0.156"
 dependencies = [
  "anyhow",
  "clap 4.0.22",
  "codegen",
  "itertools",
  "libcst",
+ "once_cell",
  "ruff",
  "rustpython-ast",
  "rustpython-common",

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.152"
+version = "0.0.156"
 edition = "2021"
 rust-version = "1.65.0"
 

LICENSE

@@ -363,6 +363,31 @@ are:
     THE SOFTWARE.
   """
 
+- flake8-return, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2019 Afonasev Evgeniy
+
+    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)

README.md

@@ -71,28 +71,28 @@ of [Conda](https://docs.conda.io/en/latest/):
 1. [Supported Rules](#supported-rules)
    1. [Pyflakes (F)](#pyflakes)
    1. [pycodestyle (E, W)](#pycodestyle)
+   1. [mccabe (C90)](#mccabe)
    1. [isort (I)](#isort)
    1. [pydocstyle (D)](#pydocstyle)
-   1. [pyupgrade (U)](#pyupgrade)
+   1. [pyupgrade (UP)](#pyupgrade)
    1. [pep8-naming (N)](#pep8-naming)
-   1. [eradicate (ERA)](#eradicate)
+   1. [flake8-2020 (YTT)](#flake8-2020)
+   1. [flake8-annotations (ANN)](#flake8-annotations)
    1. [flake8-bandit (S)](#flake8-bandit)
-   1. [flake8-comprehensions (C4)](#flake8-comprehensions)
+   1. [flake8-blind-except (BLE)](#flake8-blind-except)
    1. [flake8-boolean-trap (FBT)](#flake8-boolean-trap)
    1. [flake8-bugbear (B)](#flake8-bugbear)
    1. [flake8-builtins (A)](#flake8-builtins)
+   1. [flake8-comprehensions (C4)](#flake8-comprehensions)
    1. [flake8-debugger (T10)](#flake8-debugger)
-   1. [flake8-tidy-imports (I25)](#flake8-tidy-imports)
    1. [flake8-print (T20)](#flake8-print)
    1. [flake8-quotes (Q)](#flake8-quotes)
-   1. [flake8-annotations (ANN)](#flake8-annotations)
-   1. [flake8-2020 (YTT)](#flake8-2020)
-   1. [flake8-blind-except (BLE)](#flake8-blind-except)
-   1. [mccabe (C90)](#mccabe)
+   1. [flake8-return (RET)](#flake8-return)
+   1. [flake8-tidy-imports (I25)](#flake8-tidy-imports)
+   1. [eradicate (ERA)](#eradicate)
    1. [pygrep-hooks (PGH)](#pygrep-hooks)
    1. [Pylint (PL)](#pylint)
    1. [Ruff-specific rules (RUF)](#ruff-specific-rules)
-   1. [Meta rules (M)](#meta-rules)
 1. [Editor Integrations](#editor-integrations)
 1. [FAQ](#faq)
 1. [Development](#development)
@@ -145,7 +145,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.152
+    rev: v0.0.156
     hooks:
       - id: ruff
 ```
@@ -316,10 +316,10 @@ Options:
 
 ### 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 omit a lint check entirely, add it to the "ignore" list via [`ignore`](#ignore) or
+[`extend-ignore`](#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 error inline, 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
@@ -334,7 +334,7 @@ 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:
+will apply to the entire string, like so:
 
 ```python
 """Lorem ipsum dolor sit amet.
@@ -343,15 +343,24 @@ Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor i
 """  # noqa: E501
 ```
 
+To ignore all errors across an entire file, Ruff supports Flake8's `# flake8: noqa` directive (or,
+equivalently, `# ruff: noqa`). Adding either of those directives to any part of a file will disable
+error reporting for the entire file.
+
+For targeted exclusions across entire files (e.g., "Ignore all F841 violations in
+`/path/to/file.py`"), see the [`per-file-ignores`](#per-file-ignores) configuration setting.
+
+### Automating `noqa` Directives
+
 Ruff supports several workflows to aid in `noqa` management.
 
-First, Ruff provides a special error code, `M001`, to enforce that your `noqa` directives are
+First, Ruff provides a special error code, `RUF100`, 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`
+thus suppressed). You can run `ruff /path/to/file.py --extend-select RUF100` 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
+You can run `ruff /path/to/file.py --extend-select RUF100 --fix` to automatically remove unused
 `noqa` directives.
 
 Third, Ruff can _automatically add_ `noqa` directives to all failing lines. This is useful when
@@ -441,6 +450,14 @@ For more, see [pycodestyle](https://pypi.org/project/pycodestyle/2.9.1/) on PyPI
 | W292 | NoNewLineAtEndOfFile | No newline at end of file |  |
 | W605 | InvalidEscapeSequence | Invalid escape sequence: '\c' |  |
 
+### mccabe
+
+For more, see [mccabe](https://pypi.org/project/mccabe/0.7.0/) on PyPI.
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| C901 | FunctionIsTooComplex | `...` is too complex (10) |  |
+
 ### isort
 
 For more, see [isort](https://pypi.org/project/isort/5.10.1/) on PyPI.
@@ -506,20 +523,20 @@ For more, see [pyupgrade](https://pypi.org/project/pyupgrade/3.2.0/) on PyPI.
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| U001 | UselessMetaclassType | `__metaclass__ = type` is implied | 🛠 |
-| 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)` | 🛠 |
-| U009 | PEP3120UnnecessaryCodingComment | UTF-8 encoding declaration is unnecessary | 🛠 |
-| U010 | UnnecessaryFutureImport | Unnecessary `__future__` import `...` for target Python version | 🛠 |
-| U011 | UnnecessaryLRUCacheParams | Unnecessary parameters to `functools.lru_cache` | 🛠 |
-| U012 | UnnecessaryEncodeUTF8 | Unnecessary call to `encode` as UTF-8 | 🛠 |
-| U013 | ConvertTypedDictFunctionalToClass | Convert `...` from `TypedDict` functional to class syntax | 🛠 |
-| U014 | ConvertNamedTupleFunctionalToClass | Convert `...` from `NamedTuple` functional to class syntax | 🛠 |
-| U015 | RedundantOpenModes | Unnecessary open mode parameters | 🛠 |
+| UP001 | UselessMetaclassType | `__metaclass__ = type` is implied | 🛠 |
+| UP003 | TypeOfPrimitive | Use `str` instead of `type(...)` | 🛠 |
+| UP004 | UselessObjectInheritance | Class `...` inherits from object | 🛠 |
+| UP005 | DeprecatedUnittestAlias | `assertEquals` is deprecated, use `assertEqual` instead | 🛠 |
+| UP006 | UsePEP585Annotation | Use `list` instead of `List` for type annotations | 🛠 |
+| UP007 | UsePEP604Annotation | Use `X \| Y` for type annotations | 🛠 |
+| UP008 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` | 🛠 |
+| UP009 | PEP3120UnnecessaryCodingComment | UTF-8 encoding declaration is unnecessary | 🛠 |
+| UP010 | UnnecessaryFutureImport | Unnecessary `__future__` import `...` for target Python version | 🛠 |
+| UP011 | UnnecessaryLRUCacheParams | Unnecessary parameters to `functools.lru_cache` | 🛠 |
+| UP012 | UnnecessaryEncodeUTF8 | Unnecessary call to `encode` as UTF-8 | 🛠 |
+| UP013 | ConvertTypedDictFunctionalToClass | Convert `...` from `TypedDict` functional to class syntax | 🛠 |
+| UP014 | ConvertNamedTupleFunctionalToClass | Convert `...` from `NamedTuple` functional to class syntax | 🛠 |
+| UP015 | RedundantOpenModes | Unnecessary open mode parameters | 🛠 |
 
 ### pep8-naming
 
@@ -543,13 +560,40 @@ For more, see [pep8-naming](https://pypi.org/project/pep8-naming/0.13.2/) on PyP
 | N817 | CamelcaseImportedAsAcronym | Camelcase `...` imported as acronym `...` |  |
 | N818 | ErrorSuffixOnExceptionName | Exception name `...` should be named with an Error suffix |  |
 
-### eradicate
+### flake8-2020
 
-For more, see [eradicate](https://pypi.org/project/eradicate/2.1.0/) on PyPI.
+For more, see [flake8-2020](https://pypi.org/project/flake8-2020/1.7.0/) on PyPI.
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| ERA001 | CommentedOutCode | Found commented-out code | 🛠 |
+| YTT101 | SysVersionSlice3Referenced | `sys.version[:3]` referenced (python3.10), use `sys.version_info` |  |
+| YTT102 | SysVersion2Referenced | `sys.version[2]` referenced (python3.10), use `sys.version_info` |  |
+| YTT103 | SysVersionCmpStr3 | `sys.version` compared to string (python3.10), use `sys.version_info` |  |
+| YTT201 | SysVersionInfo0Eq3Referenced | `sys.version_info[0] == 3` referenced (python4), use `>=` |  |
+| YTT202 | SixPY3Referenced | `six.PY3` referenced (python4), use `not six.PY2` |  |
+| YTT203 | SysVersionInfo1CmpInt | `sys.version_info[1]` compared to integer (python4), compare `sys.version_info` to tuple |  |
+| YTT204 | SysVersionInfoMinorCmpInt | `sys.version_info.minor` compared to integer (python4), compare `sys.version_info` to tuple |  |
+| YTT301 | SysVersion0Referenced | `sys.version[0]` referenced (python10), use `sys.version_info` |  |
+| YTT302 | SysVersionCmpStr10 | `sys.version` compared to string (python10), use `sys.version_info` |  |
+| YTT303 | SysVersionSlice1Referenced | `sys.version[:1]` referenced (python10), use `sys.version_info` |  |
+
+### flake8-annotations
+
+For more, see [flake8-annotations](https://pypi.org/project/flake8-annotations/2.9.1/) on PyPI.
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| ANN001 | MissingTypeFunctionArgument | Missing type annotation for function argument `...` |  |
+| ANN002 | MissingTypeArgs | Missing type annotation for `*...` |  |
+| ANN003 | MissingTypeKwargs | Missing type annotation for `**...` |  |
+| ANN101 | MissingTypeSelf | Missing type annotation for `...` in method |  |
+| ANN102 | MissingTypeCls | Missing type annotation for `...` in classmethod |  |
+| ANN201 | MissingReturnTypePublicFunction | Missing return type annotation for public function `...` |  |
+| ANN202 | MissingReturnTypePrivateFunction | Missing return type annotation for private function `...` |  |
+| ANN204 | MissingReturnTypeMagicMethod | Missing return type annotation for magic method `...` |  |
+| ANN205 | MissingReturnTypeStaticMethod | Missing return type annotation for staticmethod `...` |  |
+| ANN206 | MissingReturnTypeClassMethod | Missing return type annotation for classmethod `...` |  |
+| ANN401 | DynamicallyTypedExpression | Dynamically typed expressions (typing.Any) are disallowed in `...` |  |
 
 ### flake8-bandit
 
@@ -564,36 +608,13 @@ For more, see [flake8-bandit](https://pypi.org/project/flake8-bandit/4.1.1/) on
 | S106 | HardcodedPasswordFuncArg | Possible hardcoded password: `"..."` |  |
 | S107 | HardcodedPasswordDefault | Possible hardcoded password: `"..."` |  |
 
-### flake8-comprehensions
+### flake8-blind-except
 
-For more, see [flake8-comprehensions](https://pypi.org/project/flake8-comprehensions/3.10.1/) on PyPI.
+For more, see [flake8-blind-except](https://pypi.org/project/flake8-blind-except/0.2.1/) on PyPI.
 
 | 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-debugger
-
-For more, see [flake8-debugger](https://pypi.org/project/flake8-debugger/4.1.2/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| T100 | Debugger | Import for `...` found |  |
+| BLE001 | BlindExcept | Blind except Exception: statement |  |
 
 ### flake8-boolean-trap
 
@@ -649,13 +670,36 @@ For more, see [flake8-builtins](https://pypi.org/project/flake8-builtins/2.0.1/)
 | A002 | BuiltinArgumentShadowing | Argument `...` is shadowing a python builtin |  |
 | A003 | BuiltinAttributeShadowing | Class attribute `...` is shadowing a python builtin |  |
 
-### flake8-tidy-imports
+### flake8-comprehensions
 
-For more, see [flake8-tidy-imports](https://pypi.org/project/flake8-tidy-imports/4.8.0/) on PyPI.
+For more, see [flake8-comprehensions](https://pypi.org/project/flake8-comprehensions/3.10.1/) on PyPI.
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| I252 | BannedRelativeImport | Relative imports are banned |  |
+| 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-debugger
+
+For more, see [flake8-debugger](https://pypi.org/project/flake8-debugger/4.1.2/) on PyPI.
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| T100 | Debugger | Import for `...` found |  |
 
 ### flake8-print
 
@@ -677,56 +721,36 @@ For more, see [flake8-quotes](https://pypi.org/project/flake8-quotes/3.3.1/) on
 | Q002 | BadQuotesDocstring | Single quote docstring found but double quotes preferred |  |
 | Q003 | AvoidQuoteEscape | Change outer quotes to avoid escaping inner quotes |  |
 
-### flake8-annotations
+### flake8-return
 
-For more, see [flake8-annotations](https://pypi.org/project/flake8-annotations/2.9.1/) on PyPI.
+For more, see [flake8-return](https://pypi.org/project/flake8-return/1.2.0/) on PyPI.
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| ANN001 | MissingTypeFunctionArgument | Missing type annotation for function argument `...` |  |
-| ANN002 | MissingTypeArgs | Missing type annotation for `*...` |  |
-| ANN003 | MissingTypeKwargs | Missing type annotation for `**...` |  |
-| ANN101 | MissingTypeSelf | Missing type annotation for `...` in method |  |
-| ANN102 | MissingTypeCls | Missing type annotation for `...` in classmethod |  |
-| ANN201 | MissingReturnTypePublicFunction | Missing return type annotation for public function `...` |  |
-| ANN202 | MissingReturnTypePrivateFunction | Missing return type annotation for private function `...` |  |
-| ANN204 | MissingReturnTypeMagicMethod | Missing return type annotation for magic method `...` |  |
-| ANN205 | MissingReturnTypeStaticMethod | Missing return type annotation for staticmethod `...` |  |
-| ANN206 | MissingReturnTypeClassMethod | Missing return type annotation for classmethod `...` |  |
-| ANN401 | DynamicallyTypedExpression | Dynamically typed expressions (typing.Any) are disallowed in `...` |  |
+| RET501 | UnnecessaryReturnNone | Do not explicitly `return None` in function if it is the only possible return value | 🛠 |
+| RET502 | ImplicitReturnValue | Do not implicitly `return None` in function able to return non-`None` value | 🛠 |
+| RET503 | ImplicitReturn | Missing explicit `return` at the end of function able to return non-`None` value | 🛠 |
+| RET504 | UnnecessaryAssign | Unnecessary variable assignment before `return` statement |  |
+| RET505 | SuperfluousElseReturn | Unnecessary `else` after `return` statement |  |
+| RET506 | SuperfluousElseRaise | Unnecessary `else` after `raise` statement |  |
+| RET507 | SuperfluousElseContinue | Unnecessary `else` after `continue` statement |  |
+| RET508 | SuperfluousElseBreak | Unnecessary `else` after `break` statement |  |
 
-### flake8-2020
+### flake8-tidy-imports
 
-For more, see [flake8-2020](https://pypi.org/project/flake8-2020/1.7.0/) on PyPI.
+For more, see [flake8-tidy-imports](https://pypi.org/project/flake8-tidy-imports/4.8.0/) on PyPI.
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| YTT101 | SysVersionSlice3Referenced | `sys.version[:3]` referenced (python3.10), use `sys.version_info` |  |
-| YTT102 | SysVersion2Referenced | `sys.version[2]` referenced (python3.10), use `sys.version_info` |  |
-| YTT103 | SysVersionCmpStr3 | `sys.version` compared to string (python3.10), use `sys.version_info` |  |
-| YTT201 | SysVersionInfo0Eq3Referenced | `sys.version_info[0] == 3` referenced (python4), use `>=` |  |
-| YTT202 | SixPY3Referenced | `six.PY3` referenced (python4), use `not six.PY2` |  |
-| YTT203 | SysVersionInfo1CmpInt | `sys.version_info[1]` compared to integer (python4), compare `sys.version_info` to tuple |  |
-| YTT204 | SysVersionInfoMinorCmpInt | `sys.version_info.minor` compared to integer (python4), compare `sys.version_info` to tuple |  |
-| YTT301 | SysVersion0Referenced | `sys.version[0]` referenced (python10), use `sys.version_info` |  |
-| YTT302 | SysVersionCmpStr10 | `sys.version` compared to string (python10), use `sys.version_info` |  |
-| YTT303 | SysVersionSlice1Referenced | `sys.version[:1]` referenced (python10), use `sys.version_info` |  |
+| I252 | BannedRelativeImport | Relative imports are banned |  |
 
-### flake8-blind-except
+### eradicate
 
-For more, see [flake8-blind-except](https://pypi.org/project/flake8-blind-except/0.2.1/) on PyPI.
+For more, see [eradicate](https://pypi.org/project/eradicate/2.1.0/) on PyPI.
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| BLE001 | BlindExcept | Blind except Exception: statement |  |
-
-### mccabe
-
-For more, see [mccabe](https://pypi.org/project/mccabe/0.7.0/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| C901 | FunctionIsTooComplex | `...` is too complex (10) |  |
+| ERA001 | CommentedOutCode | Found commented-out code | 🛠 |
 
 ### pygrep-hooks
 
@@ -742,7 +766,15 @@ For more, see [Pylint](https://pypi.org/project/pylint/2.15.7/) on PyPI.
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
+| PLC0414 | UselessImportAlias | Import alias does not rename original package | 🛠 |
+| PLC2201 | MisplacedComparisonConstant | Comparison should be ... | 🛠 |
+| PLC3002 | UnnecessaryDirectLambdaCall | Lambda expression called directly. Execute the expression inline instead. |  |
 | PLE1142 | AwaitOutsideAsync | `await` should be used within an async function |  |
+| PLR0206 | PropertyWithParameters | Cannot have defined parameters for properties |  |
+| PLR0402 | ConsiderUsingFromImport | Consider using `from ... import ...` |  |
+| PLR1701 | ConsiderMergingIsinstance | Consider merging these isinstance calls: `isinstance(..., (...))` |  |
+| PLR1722 | ConsiderUsingSysExit | Consider using `sys.exit()` | 🛠 |
+| PLW0120 | UselessElseOnLoop | Else clause on loop without a break statement, remove the else and de-indent all the code inside it |  |
 
 ### Ruff-specific rules
 
@@ -751,13 +783,7 @@ For more, see [Pylint](https://pypi.org/project/pylint/2.15.7/) on PyPI.
 | RUF001 | AmbiguousUnicodeCharacterString | String contains ambiguous unicode character '𝐁' (did you mean 'B'?) | 🛠 |
 | RUF002 | AmbiguousUnicodeCharacterDocstring | Docstring contains ambiguous unicode character '𝐁' (did you mean 'B'?) | 🛠 |
 | RUF003 | AmbiguousUnicodeCharacterComment | Comment contains ambiguous unicode character '𝐁' (did you mean 'B'?) |  |
-| RUF101 | ConvertExitToSysExit | `exit()` is only available in the interpreter, use `sys.exit()` instead | 🛠 |
-
-### Meta rules
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| M001 | UnusedNOQA | Unused `noqa` directive | 🛠 |
+| RUF100 | UnusedNOQA | Unused `noqa` directive | 🛠 |
 
 <!-- End auto-generated sections. -->
 
@@ -906,6 +932,7 @@ natively, including:
 - [`flake8-eradicate`](https://pypi.org/project/flake8-eradicate/)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
 - [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
+- [`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)
 - [`mccabe`](https://pypi.org/project/mccabe/)
@@ -953,6 +980,7 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 - [`flake8-eradicate`](https://pypi.org/project/flake8-eradicate/)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
 - [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
+- [`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)
 - [`mccabe`](https://pypi.org/project/mccabe/)
@@ -1760,7 +1788,25 @@ ban-relative-imports = "all"
 
 ### `isort`
 
-#### [`known-first-party`](known-first-party)
+#### [`combine-as-imports`](#combine-as-imports)
+
+Combines as imports on the same line. See isort's [`combine-as-imports`](https://pycqa.github.io/isort/docs/configuration/options.html#combine-as-imports)
+option.
+
+**Default value**: `false`
+
+**Type**: `bool`
+
+**Example usage**:
+
+```toml
+[tool.ruff.isort]
+combine-as-imports = true
+```
+
+---
+
+#### [`known-first-party`](#known-first-party)
 
 A list of modules to consider first-party, regardless of whether they can be identified as such
 via introspection of the local filesystem.
@@ -1778,7 +1824,7 @@ known-first-party = ["src"]
 
 ---
 
-#### [`known-third-party`](known-third-party)
+#### [`known-third-party`](#known-third-party)
 
 A list of modules to consider third-party, regardless of whether they can be identified as such
 via introspection of the local filesystem.
@@ -1796,7 +1842,7 @@ known-third-party = ["fastapi"]
 
 ---
 
-#### [`extra-standard-library`](extra-standard-library)
+#### [`extra-standard-library`](#extra-standard-library)
 
 A list of modules to consider standard-library, in addition to those known to Ruff in advance.
 

create_plugin.sh

@@ -0,0 +1,11 @@
+set -euxo pipefail
+
+NAME=$1
+
+mkdir -p src/$1
+mkdir -p resources/test/fixtures/$1
+touch src/$1/mod.rs
+
+sed -i "" "s/mod flake8_print;/mod flake8_print; mod flake8_return;/g" src/lib.rs
+sed -i "" "s|// flake8-print|// flake8-return\n// flake8-print|g" src/checks.rs
+

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.152"
+version = "0.0.156"
 dependencies = [
  "anyhow",
  "clap",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.152"
+version = "0.0.156"
 dependencies = [
  "anyhow",
  "bincode",

flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.152-dev.0"
+version = "0.0.156-dev.0"
 edition = "2021"
 
 [lib]

flake8_to_ruff/src/plugin.rs

@@ -17,6 +17,7 @@ pub enum Plugin {
     Flake8Eradicate,
     Flake8Print,
     Flake8Quotes,
+    Flake8Return,
     Flake8TidyImports,
     McCabe,
     PEP8Naming,
@@ -39,6 +40,7 @@ impl FromStr for Plugin {
             "flake8-eradicate" => Ok(Plugin::Flake8BlindExcept),
             "flake8-print" => Ok(Plugin::Flake8Print),
             "flake8-quotes" => Ok(Plugin::Flake8Quotes),
+            "flake8-return" => Ok(Plugin::Flake8Return),
             "flake8-tidy-imports" => Ok(Plugin::Flake8TidyImports),
             "mccabe" => Ok(Plugin::McCabe),
             "pep8-naming" => Ok(Plugin::PEP8Naming),
@@ -62,6 +64,7 @@ impl Plugin {
             Plugin::Flake8Eradicate => CheckCodePrefix::ERA,
             Plugin::Flake8Print => CheckCodePrefix::T2,
             Plugin::Flake8Quotes => CheckCodePrefix::Q,
+            Plugin::Flake8Return => CheckCodePrefix::RET,
             Plugin::Flake8TidyImports => CheckCodePrefix::I25,
             Plugin::McCabe => CheckCodePrefix::C9,
             Plugin::PEP8Naming => CheckCodePrefix::N,
@@ -97,6 +100,7 @@ impl Plugin {
             Plugin::Flake8Eradicate => vec![CheckCodePrefix::ERA],
             Plugin::Flake8Print => vec![CheckCodePrefix::T2],
             Plugin::Flake8Quotes => vec![CheckCodePrefix::Q],
+            Plugin::Flake8Return => vec![CheckCodePrefix::RET],
             Plugin::Flake8TidyImports => vec![CheckCodePrefix::I25],
             Plugin::McCabe => vec![CheckCodePrefix::C9],
             Plugin::PEP8Naming => vec![CheckCodePrefix::N],
@@ -389,6 +393,7 @@ pub fn infer_plugins_from_codes(codes: &BTreeSet<CheckCodePrefix>) -> Vec<Plugin
         Plugin::Flake8Eradicate,
         Plugin::Flake8Print,
         Plugin::Flake8Quotes,
+        Plugin::Flake8Return,
         Plugin::Flake8TidyImports,
         Plugin::PEP8Naming,
         Plugin::Pyupgrade,

resources/test/fixtures/flake8_print/T100.py

@@ -2,6 +2,7 @@ breakpoint()
 
 
 import pdb
+import builtins
 from builtins import breakpoint
 from pdb import set_trace as st
 from celery.contrib.rdb import set_trace

resources/test/fixtures/flake8_return/RET501.py

@@ -0,0 +1,4 @@
+def x(y):
+    if not y:
+        return
+    return None  # error

resources/test/fixtures/flake8_return/RET502.py

@@ -0,0 +1,65 @@
+def x(y):
+    if not y:
+        return  # error
+    return 1
+
+
+# without return value
+def x(y):
+    if not y:
+        return
+    return
+
+
+def x(y):
+    if y:
+        return
+    print()
+
+
+# with return value
+def x(y):
+    if not y:
+        return 1
+    return 2
+
+
+def x(y):
+    for i in range(10):
+        if i > 100:
+            return i
+    else:
+        return 1
+
+
+def x(y):
+    try:
+        return 1
+    except:
+        return 2
+
+
+def x(y):
+    try:
+        return 1
+    finally:
+        return 2
+
+
+# inner function
+def x(y):
+    if not y:
+        return 1
+
+    def inner():
+        return
+
+    return 2
+
+
+def x(y):
+    if not y:
+        return
+
+    def inner():
+        return 1

resources/test/fixtures/flake8_return/RET503.py

@@ -0,0 +1,116 @@
+###
+# Errors
+###
+
+# if/elif/else
+def x(y):
+    if not y:
+        return 1
+    # error
+
+
+def x(y):
+    if not y:
+        print()  # error
+    else:
+        return 2
+
+
+def x(y):
+    if not y:
+        return 1
+
+    print()  # error
+
+
+# for
+def x(y):
+    for i in range(10):
+        if i > 10:
+            return i
+    # error
+
+
+def x(y):
+    for i in range(10):
+        if i > 10:
+            return i
+    else:
+        print()  # error
+
+
+###
+# Non-errors
+###
+
+# raise as last return
+def x(y):
+    if not y:
+        return 1
+    raise Exception
+
+
+# last line in while loop
+def x(y):
+    while True:
+        if y > 0:
+            return 1
+        y += 1
+
+
+# exclude empty functions
+def x(y):
+    return None
+
+
+# return inner with statement
+def x(y):
+    with y:
+        return 1
+
+
+async def function():
+    async with thing as foo:
+        return foo.bar
+
+
+# assert as last return
+def x(y):
+    if not y:
+        return 1
+    assert False, "Sanity check"
+
+
+# return value within loop
+def bar1(x, y, z):
+    for i in x:
+        if i > y:
+            break
+        return z
+
+
+def bar3(x, y, z):
+    for i in x:
+        if i > y:
+            if z:
+                break
+        else:
+            return z
+        return None
+
+
+def bar1(x, y, z):
+    for i in x:
+        if i < y:
+            continue
+        return z
+
+
+def bar3(x, y, z):
+    for i in x:
+        if i < y:
+            if z:
+                continue
+        else:
+            return z
+        return None

resources/test/fixtures/flake8_return/RET504.py

@@ -0,0 +1,232 @@
+###
+# Errors
+###
+def x():
+    a = 1
+    return a  # error
+
+
+def x():
+    b, a = 1, 2
+    print(b)
+    return a  # error
+
+
+def x():
+    a = 1
+    print()
+    return a  # error
+
+
+def x():
+    a = 1
+    print(a)
+    a = 2
+    return a  # error
+
+
+def x():
+    a = 1
+    if True:
+        return a  # error
+    a = 2
+    print(a)
+    return a
+
+
+# Can be refactored false positives
+# https://github.com/afonasev/flake8-return/issues/47#issuecomment-1122571066
+def get_bar_if_exists(obj):
+    result = ""
+    if hasattr(obj, "bar"):
+        result = str(obj.bar)
+    return result
+
+
+# https://github.com/afonasev/flake8-return/issues/47#issue-641117366
+def x():
+    formatted = _USER_AGENT_FORMATTER.format(format_string, **values)
+    # clean up after any blank components
+    formatted = formatted.replace("()", "").replace("  ", " ").strip()
+    return formatted
+
+
+# https://github.com/afonasev/flake8-return/issues/47#issue-641117366
+def user_agent_username(username=None):
+
+    if not username:
+        return ""
+
+    username = username.replace(" ", "_")  # Avoid spaces or %20.
+    try:
+        username.encode("ascii")  # just test, but not actually use it
+    except UnicodeEncodeError:
+        username = quote(username.encode("utf-8"))
+    else:
+        # % is legal in the default $wgLegalTitleChars
+        # This is so that ops know the real pywikibot will not
+        # allow a useragent in the username to allow through a hand-coded
+        # percent-encoded value.
+        if "%" in username:
+            username = quote(username)
+    return username
+
+
+###
+# Non-errors
+###
+def x(y):
+    a = 1
+    print(a)
+    return a
+
+
+def x():
+    a = 1
+    if y:
+        return a
+    a = a + 2
+    print(a)
+    return a
+
+
+def x():
+    a = {}
+    a["b"] = 2
+    return a
+
+
+def x():
+    a = []
+    a.append(2)
+    return a
+
+
+def x():
+    a = lambda x: x
+    a()
+    return a
+
+
+# ignore unpacking
+def x():
+    b, a = [1, 2]
+    return a
+
+
+def x():
+    val = ""
+    for i in range(5):
+        val = val + str(i)
+    return val
+
+
+def x():
+    val = ""
+    i = 5
+    while i:
+        val = val + str(i)
+        i = i - x
+    return val
+
+
+# Test cases for using value for assignment then returning it
+# See:https://github.com/afonasev/flake8-return/issues/47
+def resolve_from_url(self, url: str) -> dict:
+    local_match = self.local_scope_re.match(url)
+    if local_match:
+        schema = get_schema(name=local_match.group(1))
+        self.store[url] = schema
+        return schema
+    raise NotImplementedError(...)
+
+
+my_dict = {}
+
+
+def my_func():
+    foo = calculate_foo()
+    my_dict["foo_result"] = foo
+    return foo
+
+
+# Refactored incorrect false positives
+# See test cases above marked: "Can be refactored false positives"
+# https://github.com/afonasev/flake8-return/issues/47#issuecomment-1122571066
+def get_bar_if_exists(obj):
+    if hasattr(obj, "bar"):
+        return str(obj.bar)
+    return ""
+
+
+# https://github.com/afonasev/flake8-return/issues/47#issue-641117366
+def x():
+    formatted = _USER_AGENT_FORMATTER.format(format_string, **values)
+    # clean up after any blank components
+    return formatted.replace("()", "").replace("  ", " ").strip()
+
+
+# https://github.com/afonasev/flake8-return/issues/47#issue-641117366
+def user_agent_username(username=None):
+
+    if not username:
+        return ""
+
+    username = username.replace(" ", "_")  # Avoid spaces or %20.
+    try:
+        username.encode("ascii")  # just test,
+        # but not actually use it
+    except UnicodeEncodeError:
+        username = quote(username.encode("utf-8"))
+    else:
+        # % is legal in the default $wgLegalTitleChars
+        # This is so that ops know the real pywikibot will not
+        # allow a useragent in the username to allow through a
+        # hand-coded percent-encoded value.
+        if "%" in username:
+            username = quote(username)
+    return username
+
+
+# https://github.com/afonasev/flake8-return/issues/116#issue-1367575481
+def no_exception_loop():
+    success = False
+    for _ in range(10):
+        try:
+            success = True
+        except Exception:
+            print("exception")
+    return success
+
+
+# https://github.com/afonasev/flake8-return/issues/116#issue-1367575481
+def no_exception():
+    success = False
+    try:
+        success = True
+    except Exception:
+        print("exception")
+    return success
+
+
+# https://github.com/afonasev/flake8-return/issues/116#issue-1367575481
+def exception():
+    success = True
+    try:
+        print("raising")
+        raise Exception
+    except Exception:
+        success = False
+    return success
+
+
+# https://github.com/afonasev/flake8-return/issues/66
+def close(self):
+    any_failed = False
+    for task in self.tasks:
+        try:
+            task()
+        except BaseException:
+            any_failed = True
+            report(traceback.format_exc())
+    return any_failed

resources/test/fixtures/flake8_return/RET505.py

@@ -0,0 +1,141 @@
+###
+# Error
+###
+def foo2(x, y, w, z):
+    if x:  # [no-else-return]
+        a = 1
+        return y
+    elif z:
+        b = 2
+        return w
+    else:
+        c = 3
+        return z
+
+
+def foo5(x, y, z):
+    if x:  # [no-else-return]
+        if y:
+            a = 4
+        else:
+            b = 2
+        return
+    elif z:
+        c = 2
+    else:
+        c = 3
+    return
+
+
+def foo2(x, y, w, z):
+    if x:
+        a = 1
+    elif z:
+        b = 2
+    else:
+        c = 3
+
+    if x:  # [no-else-return]
+        a = 1
+        return y
+    elif z:
+        b = 2
+        return w
+    else:
+        c = 3
+        return z
+
+
+def foo1(x, y, z):
+    if x:  # [no-else-return]
+        a = 1
+        return y
+    else:
+        b = 2
+        return z
+
+
+def foo3(x, y, z):
+    if x:
+        a = 1
+        if y:  # [no-else-return]
+            b = 2
+            return y
+        else:
+            c = 3
+            return x
+    else:
+        d = 4
+        return z
+
+
+def foo4(x, y):
+    if x:  # [no-else-return]
+        if y:
+            a = 4
+        else:
+            b = 2
+        return
+    else:
+        c = 3
+    return
+
+
+def foo6(x, y):
+    if x:
+        if y:  # [no-else-return]
+            a = 4
+            return
+        else:
+            b = 2
+    else:
+        c = 3
+    return
+
+
+def bar4(x):
+    if x:  # [no-else-return]
+        return True
+    else:
+        try:
+            return False
+        except ValueError:
+            return None
+
+
+###
+# Non-error
+###
+def bar1(x, y, z):
+    if x:
+        return y
+    return z
+
+
+def bar2(w, x, y, z):
+    if x:
+        return y
+    if z:
+        a = 1
+    else:
+        return w
+    return None
+
+
+def bar3(x, y, z):
+    if x:
+        if z:
+            return y
+    else:
+        return z
+    return None
+
+
+x = 0
+
+if x == 1:
+    y = "a"
+elif x == 2:
+    y = "b"
+else:
+    y = "c"

resources/test/fixtures/flake8_return/RET506.py

@@ -0,0 +1,112 @@
+###
+# Errors
+###
+def foo2(x, y, w, z):
+    if x:  # [no-else-raise]
+        a = 1
+        raise Exception(y)
+    elif z:
+        b = 2
+        raise Exception(w)
+    else:
+        c = 3
+        raise Exception(z)
+
+
+def foo5(x, y, z):
+    if x:  # [no-else-raise]
+        if y:
+            a = 4
+        else:
+            b = 2
+        raise Exception(x)
+    elif z:
+        raise Exception(y)
+    else:
+        c = 3
+    raise Exception(z)
+
+
+def foo1(x, y, z):
+    if x:  # [no-else-raise]
+        a = 1
+        raise Exception(y)
+    else:
+        b = 2
+        raise Exception(z)
+
+
+def foo3(x, y, z):
+    if x:
+        a = 1
+        if y:  # [no-else-raise]
+            b = 2
+            raise Exception(y)
+        else:
+            c = 3
+            raise Exception(x)
+    else:
+        d = 4
+        raise Exception(z)
+
+
+def foo4(x, y):
+    if x:  # [no-else-raise]
+        if y:
+            a = 4
+        else:
+            b = 2
+        raise Exception(x)
+    else:
+        c = 3
+    raise Exception(y)
+
+
+def foo6(x, y):
+    if x:
+        if y:  # [no-else-raise]
+            a = 4
+            raise Exception(x)
+        else:
+            b = 2
+    else:
+        c = 3
+    raise Exception(y)
+
+
+def bar4(x):
+    if x:  # [no-else-raise]
+        raise Exception(True)
+    else:
+        try:
+            raise Exception(False)
+        except ValueError:
+            raise Exception(None)
+
+
+###
+# Non-errors
+###
+def bar1(x, y, z):
+    if x:
+        raise Exception(y)
+    raise Exception(z)
+
+
+def bar2(w, x, y, z):
+    if x:
+        raise Exception(y)
+    if z:
+        a = 1
+    else:
+        raise Exception(w)
+    raise Exception(None)
+
+
+def bar3(x, y, z):
+    if x:
+        if z:
+            raise Exception(y)
+    else:
+        raise Exception(z)
+    raise Exception(None)

resources/test/fixtures/flake8_return/RET507.py

@@ -0,0 +1,106 @@
+###
+# Errors
+###
+def foo2(x, y, w, z):
+    for i in x:
+        if i < y:  # [no-else-continue]
+            continue
+        elif i < w:
+            continue
+        else:
+            a = z
+
+
+def foo5(x, y, z):
+    for i in x:
+        if i < y:  # [no-else-continue]
+            if y:
+                a = 4
+            else:
+                b = 2
+            continue
+        elif z:
+            c = 2
+        else:
+            c = 3
+        continue
+
+
+###
+# Non-errors
+###
+def foo1(x, y, z):
+    for i in x:
+        if i < y:  # [no-else-continue]
+            continue
+        else:
+            a = z
+
+
+def foo3(x, y, z):
+    for i in x:
+        if i < y:
+            a = 1
+            if z:  # [no-else-continue]
+                b = 2
+                continue
+            else:
+                c = 3
+                continue
+        else:
+            d = 4
+            continue
+
+
+def foo4(x, y):
+    for i in x:
+        if i < x:  # [no-else-continue]
+            if y:
+                a = 4
+            else:
+                b = 2
+            continue
+        else:
+            c = 3
+        continue
+
+
+def foo6(x, y):
+    for i in x:
+        if i < x:
+            if y:  # [no-else-continue]
+                a = 4
+                continue
+            else:
+                b = 2
+        else:
+            c = 3
+        continue
+
+
+def bar4(x):
+    for i in range(10):
+        if x:  # [no-else-continue]
+            continue
+        else:
+            try:
+                return
+            except ValueError:
+                continue
+
+
+def bar1(x, y, z):
+    for i in x:
+        if i < y:
+            continue
+        return z
+
+
+def bar3(x, y, z):
+    for i in x:
+        if i < y:
+            if z:
+                continue
+        else:
+            return z
+        return None

resources/test/fixtures/flake8_return/RET508.py

@@ -0,0 +1,138 @@
+###
+# Errors
+###
+def foo2(x, y, w, z):
+    for i in x:
+        if i > y:  # [no-else-break]
+            break
+        elif i > w:
+            break
+        else:
+            a = z
+
+
+def foo5(x, y, z):
+    for i in x:
+        if i > y:  # [no-else-break]
+            if y:
+                a = 4
+            else:
+                b = 2
+            break
+        elif z:
+            c = 2
+        else:
+            c = 3
+        break
+
+
+def foo1(x, y, z):
+    for i in x:
+        if i > y:  # [no-else-break]
+            break
+        else:
+            a = z
+
+
+def foo3(x, y, z):
+    for i in x:
+        if i > y:
+            a = 1
+            if z:  # [no-else-break]
+                b = 2
+                break
+            else:
+                c = 3
+                break
+        else:
+            d = 4
+            break
+
+
+def foo4(x, y):
+    for i in x:
+        if i > x:  # [no-else-break]
+            if y:
+                a = 4
+            else:
+                b = 2
+            break
+        else:
+            c = 3
+        break
+
+
+def foo6(x, y):
+    for i in x:
+        if i > x:
+            if y:  # [no-else-break]
+                a = 4
+                break
+            else:
+                b = 2
+        else:
+            c = 3
+        break
+
+
+def bar4(x):
+    for i in range(10):
+        if x:  # [no-else-break]
+            break
+        else:
+            try:
+                return
+            except ValueError:
+                break
+
+
+###
+# Non-errors
+###
+def bar1(x, y, z):
+    for i in x:
+        if i > y:
+            break
+        return z
+
+
+def bar2(w, x, y, z):
+    for i in w:
+        if i > x:
+            break
+        if z < i:
+            a = y
+        else:
+            break
+        return
+
+
+def bar3(x, y, z):
+    for i in x:
+        if i > y:
+            if z:
+                break
+        else:
+            return z
+        return None
+
+
+def nested1(x, y, z):
+    for i in x:
+        if i > x:
+            for j in y:
+                if j < z:
+                    break
+        else:
+            a = z
+
+
+def nested2(x, y, z):
+    for i in x:
+        if i > x:
+            for j in y:
+                if j > z:
+                    break
+                break
+        else:
+            a = z

resources/test/fixtures/isort/combine_as_imports.py

@@ -0,0 +1,4 @@
+from module import Class as C
+from module import CONSTANT
+from module import function
+from module import function as f

resources/test/fixtures/pylint/consider_merging_isinstance.py

@@ -0,0 +1,37 @@
+"""Checks use of consider-merging-isinstance"""
+# pylint:disable=line-too-long, simplifiable-condition
+
+
+def isinstances():
+    "Examples of isinstances"
+    var = range(10)
+
+    # merged
+    if isinstance(var[1], (int, float)):
+        pass
+    result = isinstance(var[2], (int, float))
+
+    # not merged
+    if isinstance(var[3], int) or isinstance(var[3], float) or isinstance(var[3], list) and True:  # [consider-merging-isinstance]
+        pass
+    result = isinstance(var[4], int) or isinstance(var[4], float) or isinstance(var[5], list) and False  # [consider-merging-isinstance]
+
+    result = isinstance(var[5], int) or True or isinstance(var[5], float)  # [consider-merging-isinstance]
+
+    infered_isinstance = isinstance
+    result = infered_isinstance(var[6], int) or infered_isinstance(var[6], float) or infered_isinstance(var[6], list) and False   # [consider-merging-isinstance]
+    result = isinstance(var[10], str) or isinstance(var[10], int) and var[8] * 14 or isinstance(var[10], float) and var[5] * 14.4 or isinstance(var[10], list)   # [consider-merging-isinstance]
+    result = isinstance(var[11], int) or isinstance(var[11], int) or isinstance(var[11], float)   # [consider-merging-isinstance]
+
+    result = isinstance(var[20])
+    result = isinstance()
+
+    # Combination merged and not merged
+    result = isinstance(var[12], (int, float)) or isinstance(var[12], list)  # [consider-merging-isinstance]
+
+    # not merged but valid
+    result = isinstance(var[5], int) and var[5] * 14 or isinstance(var[5], float) and var[5] * 14.4
+    result = isinstance(var[7], int) or not isinstance(var[7], float)
+    result = isinstance(var[6], int) or isinstance(var[7], float)
+    result = isinstance(var[6], int) or isinstance(var[7], int)
+    return result

resources/test/fixtures/pylint/consider_using_sys_exit_0.py

@@ -1,5 +1,7 @@
 exit(0)
+quit(0)
 
 
 def main():
     exit(2)
+    quit(2)

resources/test/fixtures/pylint/consider_using_sys_exit_1.py

@@ -1,10 +1,12 @@
 import sys
 
 exit(0)
+quit(0)
 
 
 def main():
     exit(1)
+    quit(1)
 
 
 sys.exit(2)

resources/test/fixtures/pylint/consider_using_sys_exit_2.py

@@ -1,7 +1,9 @@
 import sys as sys2
 
 exit(0)
+quit(0)
 
 
 def main():
     exit(1)
+    quit(1)

resources/test/fixtures/pylint/consider_using_sys_exit_3.py

@@ -1,7 +1,9 @@
 from sys import exit
 
 exit(0)
+quit(0)
 
 
 def main():
     exit(1)
+    quit(1)

resources/test/fixtures/pylint/consider_using_sys_exit_4.py

@@ -1,7 +1,9 @@
 from sys import exit as exit2
 
 exit(0)
+quit(0)
 
 
 def main():
     exit(1)
+    quit(1)

resources/test/fixtures/pylint/consider_using_sys_exit_5.py

@@ -1,7 +1,9 @@
 from sys import *
 
 exit(0)
+quit(0)
 
 
 def main():
     exit(1)
+    quit(1)

resources/test/fixtures/pylint/consider_using_sys_exit_6.py

@@ -1,12 +1,19 @@
 exit(0)
+quit(0)
 
 
 def exit(e):
     pass
 
 
+def quit(e):
+    pass
+
+
 exit(1)
+quit(1)
 
 
 def main():
     exit(2)
+    quit(2)

resources/test/fixtures/pylint/import_aliasing.py

@@ -0,0 +1,27 @@
+# pylint: disable=unused-import, missing-docstring, invalid-name, reimported, import-error, wrong-import-order, no-name-in-module, shadowed-import
+# Functional tests for import aliasing
+# 1. useless-import-alias
+# 2. consider-using-from-import
+
+import collections as collections  # [useless-import-alias]
+from collections import OrderedDict as OrderedDict  # [useless-import-alias]
+from collections import OrderedDict as o_dict
+import os.path as path  # [consider-using-from-import]
+import os.path as p
+import foo.bar.foobar as foobar  # [consider-using-from-import]
+import os
+import os as OS
+from sys import version
+from . import bar as bar  # [useless-import-alias]
+from . import bar as Bar
+from . import bar
+from ..foo import bar as bar  # [useless-import-alias]
+from ..foo.bar import foobar as foobar  # [useless-import-alias]
+from ..foo.bar import foobar as anotherfoobar
+from . import foo as foo, foo2 as bar2  # [useless-import-alias]
+from . import foo as bar, foo2 as foo2  # [useless-import-alias]
+from . import foo as bar, foo2 as bar2
+from foo.bar import foobar as foobar  # [useless-import-alias]
+from foo.bar import foobar as foo
+from .foo.bar import f as foobar
+from ............a import b  # [relative-beyond-top-level]

resources/test/fixtures/pylint/misplaced_comparison_constant.py

@@ -0,0 +1,50 @@
+"""Check that the constants are on the right side of the comparisons"""
+
+# pylint: disable=singleton-comparison, missing-docstring, too-few-public-methods
+# pylint: disable=comparison-of-constants
+
+class MyClass:
+    def __init__(self):
+        self.attr = 1
+
+    def dummy_return(self):
+        return self.attr
+
+def dummy_return():
+    return 2
+
+def bad_comparisons():
+    """this is not ok"""
+    instance = MyClass()
+    for i in range(10):
+        if 5 <= i:  # [misplaced-comparison-constant]
+            pass
+        if 1 == i:  # [misplaced-comparison-constant]
+            pass
+        if 3 < dummy_return():  # [misplaced-comparison-constant]
+            pass
+        if 4 != instance.dummy_return():  # [misplaced-comparison-constant]
+            pass
+        if 1 == instance.attr:  # [misplaced-comparison-constant]
+            pass
+        if "aaa" == instance.attr: # [misplaced-comparison-constant]
+            pass
+
+def good_comparison():
+    """this is ok"""
+    for i in range(10):
+        if i == 5:
+            pass
+
+def double_comparison():
+    """Check that we return early for non-binary comparison"""
+    for i in range(10):
+        if i == 1 == 2:
+            pass
+        if 2 <= i <= 8:
+            print("Between 2 and 8 inclusive")
+
+def const_comparison():
+    """Check that we return early for comparison of two constants"""
+    if 1 == 2:
+        pass

resources/test/fixtures/pylint/property_with_parameters.py

@@ -0,0 +1,30 @@
+# pylint: disable=missing-docstring, too-few-public-methods
+from abc import ABCMeta, abstractmethod
+
+
+class Cls:
+    @property
+    def attribute(self, param, param1):  # [property-with-parameters]
+        return param + param1
+
+    @property
+    def attribute_keyword_only(self, *, param, param1):  # [property-with-parameters]
+        return param + param1
+
+    @property
+    def attribute_positional_only(self, param, param1, /):  # [property-with-parameters]
+        return param + param1
+
+
+class MyClassBase(metaclass=ABCMeta):
+    """MyClassBase."""
+
+    @property
+    @abstractmethod
+    def example(self):
+        """Getter."""
+
+    @example.setter
+    @abstractmethod
+    def example(self, value):
+        """Setter."""

resources/test/fixtures/pylint/unnecessary_direct_lambda_call.py

@@ -0,0 +1,5 @@
+"""Test unnecessary direct calls to lambda expressions."""
+# pylint: disable=undefined-variable, line-too-long
+
+y = (lambda x: x**2 + 2*x + 1)(a)  # [unnecessary-direct-lambda-call]
+y = max((lambda x: x**2)(a), (lambda x: x+1)(a))  # [unnecessary-direct-lambda-call,unnecessary-direct-lambda-call]

resources/test/fixtures/pylint/useless_else_on_loop.py

@@ -0,0 +1,103 @@
+"""Check for else branches on loops with break and return only."""
+
+
+def test_return_for():
+    """else + return is not acceptable."""
+    for i in range(10):
+        if i % 2:
+            return i
+    else:  # [useless-else-on-loop]
+        print("math is broken")
+    return None
+
+
+def test_return_while():
+    """else + return is not acceptable."""
+    while True:
+        return 1
+    else:  # [useless-else-on-loop]
+        print("math is broken")
+    return None
+
+
+while True:
+
+    def short_fun():
+        """A function with a loop."""
+        for _ in range(10):
+            break
+
+else:  # [useless-else-on-loop]
+    print("or else!")
+
+
+while True:
+    while False:
+        break
+else:  # [useless-else-on-loop]
+    print("or else!")
+
+for j in range(10):
+    pass
+else:  # [useless-else-on-loop]
+    print("fat chance")
+    for j in range(10):
+        break
+
+
+def test_return_for2():
+    """no false positive for break in else
+
+    https://bitbucket.org/logilab/pylint/issue/117/useless-else-on-loop-false-positives
+    """
+    for i in range(10):
+        for _ in range(i):
+            if i % 2:
+                break
+        else:
+            break
+    else:
+        print("great math")
+
+
+def test_break_in_orelse_deep():
+    """no false positive for break in else deeply nested"""
+    for _ in range(10):
+        if 1 < 2:  # pylint: disable=comparison-of-constants
+            for _ in range(3):
+                if 3 < 2:  # pylint: disable=comparison-of-constants
+                    break
+            else:
+                break
+    else:
+        return True
+    return False
+
+
+def test_break_in_orelse_deep2():
+    """should rise a useless-else-on-loop message, as the break statement is only
+    for the inner for loop
+    """
+    for _ in range(10):
+        if 1 < 2:  # pylint: disable=comparison-of-constants
+            for _ in range(3):
+                if 3 < 2:  # pylint: disable=comparison-of-constants
+                    break
+            else:
+                print("all right")
+    else:  # [useless-else-on-loop]
+        return True
+    return False
+
+
+def test_break_in_orelse_deep3():
+    """no false positive for break deeply nested in else"""
+    for _ in range(10):
+        for _ in range(3):
+            pass
+        else:
+            if 1 < 2:  # pylint: disable=comparison-of-constants
+                break
+    else:
+        return True
+    return False

resources/test/fixtures/pyupgrade/U009_4.py

@@ -1,3 +0,0 @@
-# coding=utf8 # noqa: U009
-
-print("Hello world")

resources/test/fixtures/pyupgrade/UP009_4.py

@@ -0,0 +1,3 @@
+# coding=utf8 # noqa: UP009
+
+print("Hello world")

resources/test/fixtures/ruff/flake8_noqa.py

@@ -0,0 +1,7 @@
+# flake8: noqa
+
+import os
+
+
+def f():
+    x = 1

resources/test/fixtures/ruff/redirects.py

@@ -0,0 +1,9 @@
+from typing import Optional
+
+
+def f(x: Optional[str]) -> None:  # noqa: U007
+    ...
+
+
+def f(x: Optional[str]) -> None:  # noqa: UP007
+    ...

resources/test/fixtures/ruff/ruff_noqa.py

@@ -0,0 +1,7 @@
+# ruff: noqa
+
+import os
+
+
+def f():
+    x = 1

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.152"
+version = "0.0.156"
 edition = "2021"
 
 [dependencies]
@@ -9,6 +9,7 @@ clap = { version = "4.0.1", features = ["derive"] }
 codegen = { version = "0.2.0" }
 itertools = { version = "0.10.5" }
 libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a8725d161fe8b3ed73a6758b21e177" }
+once_cell = { version = "1.16.0" }
 ruff = { path = ".." }
 rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "f885db8c61514f069979861f6b3bd83292086231" }
 rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "f885db8c61514f069979861f6b3bd83292086231" }

ruff_dev/src/generate_check_code_prefix.rs

@@ -8,7 +8,7 @@ use anyhow::Result;
 use clap::Parser;
 use codegen::{Scope, Type, Variant};
 use itertools::Itertools;
-use ruff::checks::CheckCode;
+use ruff::checks::{CheckCode, REDIRECTS};
 use strum::IntoEnumIterator;
 
 const FILE: &str = "src/checks_gen.rs";
@@ -26,18 +26,49 @@ pub fn main(cli: &Cli) -> Result<()> {
     // Build up a map from prefix to matching CheckCodes.
     let mut prefix_to_codes: BTreeMap<String, BTreeSet<CheckCode>> = BTreeMap::default();
     for check_code in CheckCode::iter() {
-        let as_ref: String = check_code.as_ref().to_string();
-        let prefix_len = as_ref
+        let code_str: String = check_code.as_ref().to_string();
+        let code_prefix_len = code_str
             .chars()
             .take_while(|char| char.is_alphabetic())
             .count();
-        for i in prefix_len..=as_ref.len() {
-            let prefix = as_ref[..i].to_string();
+        let code_suffix_len = code_str.len() - code_prefix_len;
+        for i in 0..=code_suffix_len {
+            let prefix = code_str[..code_prefix_len + i].to_string();
             let entry = prefix_to_codes.entry(prefix).or_default();
             entry.insert(check_code.clone());
         }
     }
 
+    // Add any aliases (e.g., "U001" to "UP001").
+    for (alias, check_code) in REDIRECTS.iter() {
+        // Compute the length of the prefix and suffix for both codes.
+        let code_str: String = check_code.as_ref().to_string();
+        let code_prefix_len = code_str
+            .chars()
+            .take_while(|char| char.is_alphabetic())
+            .count();
+        let code_suffix_len = code_str.len() - code_prefix_len;
+        let alias_prefix_len = alias
+            .chars()
+            .take_while(|char| char.is_alphabetic())
+            .count();
+        let alias_suffix_len = alias.len() - alias_prefix_len;
+        assert_eq!(code_suffix_len, alias_suffix_len);
+        for i in 0..=code_suffix_len {
+            let source = code_str[..code_prefix_len + i].to_string();
+            let destination = alias[..alias_prefix_len + i].to_string();
+            if source != destination {
+                prefix_to_codes.insert(
+                    destination,
+                    prefix_to_codes
+                        .get(&source)
+                        .unwrap_or_else(|| panic!("Unknown CheckCode: {source:?}"))
+                        .clone(),
+                );
+            }
+        }
+    }
+
     let mut scope = Scope::new();
 
     // Create the `CheckCodePrefix` definition.
@@ -81,13 +112,27 @@ pub fn main(cli: &Cli) -> Result<()> {
         .line("#[allow(clippy::match_same_arms)]")
         .line("match self {");
     for (prefix, codes) in &prefix_to_codes {
-        gen = gen.line(format!(
-            "CheckCodePrefix::{prefix} => vec![{}],",
-            codes
-                .iter()
-                .map(|code| format!("CheckCode::{}", code.as_ref()))
-                .join(", ")
-        ));
+        if let Some(target) = REDIRECTS.get(&prefix.as_str()) {
+            gen = gen.line(format!(
+                "CheckCodePrefix::{prefix} => {{ eprintln!(\"{{}}{{}} {{}}\", \
+                 \"warning\".yellow().bold(), \":\".bold(), \"`{}` has been renamed to \
+                 `{}`\".bold()); \n vec![{}] }}",
+                prefix,
+                target.as_ref(),
+                codes
+                    .iter()
+                    .map(|code| format!("CheckCode::{}", code.as_ref()))
+                    .join(", ")
+            ));
+        } else {
+            gen = gen.line(format!(
+                "CheckCodePrefix::{prefix} => vec![{}],",
+                codes
+                    .iter()
+                    .map(|code| format!("CheckCode::{}", code.as_ref()))
+                    .join(", ")
+            ));
+        }
     }
     gen.line("}");
 
@@ -123,6 +168,8 @@ pub fn main(cli: &Cli) -> Result<()> {
         .push_str("//! File automatically generated by `examples/generate_check_code_prefix.rs`.");
     output.push('\n');
     output.push('\n');
+    output.push_str("use colored::Colorize;");
+    output.push('\n');
     output.push_str("use serde::{{Serialize, Deserialize}};");
     output.push('\n');
     output.push_str("use strum_macros::EnumString;");

src/ast/helpers.rs

@@ -61,15 +61,6 @@ pub fn dealias_call_path<'a>(
     }
 }
 
-/// Return `true` if the `Expr` is a name or attribute reference to `${target}`.
-pub fn match_name_or_attr(expr: &Expr, target: &str) -> bool {
-    match &expr.node {
-        ExprKind::Attribute { attr, .. } => target == attr,
-        ExprKind::Name { id, .. } => target == id,
-        _ => false,
-    }
-}
-
 /// Return `true` if the `Expr` is a reference to `${module}.${target}`.
 ///
 /// Useful for, e.g., ensuring that a `Union` reference represents

src/check_ast.rs

@@ -36,8 +36,8 @@ 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_print, flake8_tidy_imports, mccabe, pep8_naming, pycodestyle, pydocstyle, pyflakes,
-    pygrep_hooks, pylint, pyupgrade, rules,
+    flake8_print, flake8_return, flake8_tidy_imports, mccabe, pep8_naming, pycodestyle, pydocstyle,
+    pyflakes, pygrep_hooks, pylint, pyupgrade,
 };
 
 const GLOBAL_SCOPE_INDEX: usize = 0;
@@ -412,7 +412,7 @@ where
                     }
                 }
 
-                if self.settings.enabled.contains(&CheckCode::U011)
+                if self.settings.enabled.contains(&CheckCode::UP011)
                     && self.settings.target_version >= PythonVersion::Py38
                 {
                     pyupgrade::plugins::unnecessary_lru_cache_params(self, decorator_list);
@@ -421,9 +421,23 @@ where
                 if self.settings.enabled.contains(&CheckCode::B018) {
                     flake8_bugbear::plugins::useless_expression(self, body);
                 }
+
                 if self.settings.enabled.contains(&CheckCode::B019) {
                     flake8_bugbear::plugins::cached_instance_method(self, decorator_list);
                 }
+
+                if self.settings.enabled.contains(&CheckCode::RET501)
+                    || self.settings.enabled.contains(&CheckCode::RET502)
+                    || self.settings.enabled.contains(&CheckCode::RET503)
+                    || self.settings.enabled.contains(&CheckCode::RET504)
+                    || self.settings.enabled.contains(&CheckCode::RET505)
+                    || self.settings.enabled.contains(&CheckCode::RET506)
+                    || self.settings.enabled.contains(&CheckCode::RET507)
+                    || self.settings.enabled.contains(&CheckCode::RET508)
+                {
+                    flake8_return::plugins::function(self, body);
+                }
+
                 if self.settings.enabled.contains(&CheckCode::C901) {
                     if let Some(check) = mccabe::checks::function_is_too_complex(
                         stmt,
@@ -441,6 +455,10 @@ where
                     );
                 }
 
+                if self.settings.enabled.contains(&CheckCode::PLR0206) {
+                    pylint::plugins::property_with_parameters(self, stmt, decorator_list, args);
+                }
+
                 self.check_builtin_shadowing(name, Range::from_located(stmt), true);
 
                 // Visit the decorators and arguments, but avoid the body, which will be
@@ -513,7 +531,7 @@ where
                 decorator_list,
                 body,
             } => {
-                if self.settings.enabled.contains(&CheckCode::U004) {
+                if self.settings.enabled.contains(&CheckCode::UP004) {
                     pyupgrade::plugins::useless_object_inheritance(
                         self, stmt, name, bases, keywords,
                     );
@@ -650,6 +668,14 @@ where
                         }
                     }
 
+                    // pylint
+                    if self.settings.enabled.contains(&CheckCode::PLC0414) {
+                        pylint::plugins::useless_import_alias(self, alias);
+                    }
+                    if self.settings.enabled.contains(&CheckCode::PLR0402) {
+                        pylint::plugins::consider_using_from_import(self, alias);
+                    }
+
                     if let Some(asname) = &alias.node.asname {
                         for alias in names {
                             if let Some(asname) = &alias.node.asname {
@@ -737,7 +763,7 @@ where
                 }
 
                 if let Some("__future__") = module.as_deref() {
-                    if self.settings.enabled.contains(&CheckCode::U010) {
+                    if self.settings.enabled.contains(&CheckCode::UP010) {
                         pyupgrade::plugins::unnecessary_future_import(self, stmt, names);
                     }
                 }
@@ -942,6 +968,11 @@ where
                                 self.add_check(check);
                             }
                         }
+
+                        // pylint
+                        if self.settings.enabled.contains(&CheckCode::PLC0414) {
+                            pylint::plugins::useless_import_alias(self, alias);
+                        }
                     }
                 }
             }
@@ -986,16 +1017,27 @@ where
                     flake8_bugbear::plugins::assert_raises_exception(self, stmt, items);
                 }
             }
-            StmtKind::While { .. } => {
+            StmtKind::While { body, orelse, .. } => {
                 if self.settings.enabled.contains(&CheckCode::B023) {
                     flake8_bugbear::plugins::function_uses_loop_variable(self, &Node::Stmt(stmt));
                 }
+                if self.settings.enabled.contains(&CheckCode::PLW0120) {
+                    pylint::plugins::useless_else_on_loop(self, stmt, body, orelse);
+                }
             }
             StmtKind::For {
-                target, body, iter, ..
+                target,
+                body,
+                iter,
+                orelse,
+                ..
             }
             | StmtKind::AsyncFor {
-                target, body, iter, ..
+                target,
+                body,
+                iter,
+                orelse,
+                ..
             } => {
                 if self.settings.enabled.contains(&CheckCode::B007) {
                     flake8_bugbear::plugins::unused_loop_control_variable(self, target, body);
@@ -1006,6 +1048,9 @@ where
                 if self.settings.enabled.contains(&CheckCode::B023) {
                     flake8_bugbear::plugins::function_uses_loop_variable(self, &Node::Stmt(stmt));
                 }
+                if self.settings.enabled.contains(&CheckCode::PLW0120) {
+                    pylint::plugins::useless_else_on_loop(self, stmt, body, orelse);
+                }
             }
             StmtKind::Try { handlers, .. } => {
                 if self.settings.enabled.contains(&CheckCode::F707) {
@@ -1031,7 +1076,7 @@ where
                         pycodestyle::plugins::do_not_assign_lambda(self, target, value, stmt);
                     }
                 }
-                if self.settings.enabled.contains(&CheckCode::U001) {
+                if self.settings.enabled.contains(&CheckCode::UP001) {
                     pyupgrade::plugins::useless_metaclass_type(self, stmt, value, targets);
                 }
                 if self.settings.enabled.contains(&CheckCode::B003) {
@@ -1044,12 +1089,12 @@ where
                         self.add_check(check);
                     }
                 }
-                if self.settings.enabled.contains(&CheckCode::U013) {
+                if self.settings.enabled.contains(&CheckCode::UP013) {
                     pyupgrade::plugins::convert_typed_dict_functional_to_class(
                         self, stmt, targets, value,
                     );
                 }
-                if self.settings.enabled.contains(&CheckCode::U014) {
+                if self.settings.enabled.contains(&CheckCode::UP014) {
                     pyupgrade::plugins::convert_named_tuple_functional_to_class(
                         self, stmt, targets, value,
                     );
@@ -1221,7 +1266,7 @@ where
             ExprKind::Subscript { value, slice, .. } => {
                 // Ex) Optional[...]
                 if !self.in_deferred_string_type_definition
-                    && self.settings.enabled.contains(&CheckCode::U007)
+                    && self.settings.enabled.contains(&CheckCode::UP007)
                     && (self.settings.target_version >= PythonVersion::Py310
                         || (self.settings.target_version >= PythonVersion::Py37
                             && !self.settings.pyupgrade.keep_runtime_typing
@@ -1264,7 +1309,7 @@ where
                     ExprContext::Load => {
                         // Ex) List[...]
                         if !self.in_deferred_string_type_definition
-                            && self.settings.enabled.contains(&CheckCode::U006)
+                            && self.settings.enabled.contains(&CheckCode::UP006)
                             && (self.settings.target_version >= PythonVersion::Py39
                                 || (self.settings.target_version >= PythonVersion::Py37
                                     && !self.settings.pyupgrade.keep_runtime_typing
@@ -1305,7 +1350,7 @@ where
             ExprKind::Attribute { attr, .. } => {
                 // Ex) typing.List[...]
                 if !self.in_deferred_string_type_definition
-                    && self.settings.enabled.contains(&CheckCode::U006)
+                    && self.settings.enabled.contains(&CheckCode::UP006)
                     && (self.settings.target_version >= PythonVersion::Py39
                         || (self.settings.target_version >= PythonVersion::Py37
                             && self.annotations_future_enabled
@@ -1399,16 +1444,16 @@ where
                 }
 
                 // pyupgrade
-                if self.settings.enabled.contains(&CheckCode::U005) {
+                if self.settings.enabled.contains(&CheckCode::UP005) {
                     pyupgrade::plugins::deprecated_unittest_alias(self, func);
                 }
 
                 // flake8-super
-                if self.settings.enabled.contains(&CheckCode::U008) {
+                if self.settings.enabled.contains(&CheckCode::UP008) {
                     pyupgrade::plugins::super_call_with_parameters(self, expr, func, args);
                 }
 
-                if self.settings.enabled.contains(&CheckCode::U012) {
+                if self.settings.enabled.contains(&CheckCode::UP012) {
                     pyupgrade::plugins::unnecessary_encode_utf8(self, expr, func, args, keywords);
                 }
 
@@ -1667,11 +1712,11 @@ where
                 }
 
                 // pyupgrade
-                if self.settings.enabled.contains(&CheckCode::U003) {
+                if self.settings.enabled.contains(&CheckCode::UP003) {
                     pyupgrade::plugins::type_of_primitive(self, expr, func, args);
                 }
 
-                if self.settings.enabled.contains(&CheckCode::U015) {
+                if self.settings.enabled.contains(&CheckCode::UP015) {
                     pyupgrade::plugins::redundant_open_modes(self, expr);
                 }
 
@@ -1708,9 +1753,12 @@ where
                     pygrep_hooks::checks::no_eval(self, func);
                 }
 
-                // Ruff
-                if self.settings.enabled.contains(&CheckCode::RUF101) {
-                    rules::plugins::convert_exit_to_sys_exit(self, func);
+                // pylint
+                if self.settings.enabled.contains(&CheckCode::PLC3002) {
+                    pylint::plugins::unnecessary_direct_lambda_call(self, expr, func);
+                }
+                if self.settings.enabled.contains(&CheckCode::PLR1722) {
+                    pylint::plugins::consider_using_sys_exit(self, func);
                 }
             }
             ExprKind::Dict { keys, .. } => {
@@ -1973,6 +2021,16 @@ where
                         .into_iter(),
                     );
                 }
+
+                if self.settings.enabled.contains(&CheckCode::PLC2201) {
+                    pylint::plugins::misplaced_comparison_constant(
+                        self,
+                        expr,
+                        left,
+                        ops,
+                        comparators,
+                    );
+                }
             }
             ExprKind::Constant {
                 value: Constant::Str(value),
@@ -2054,6 +2112,11 @@ where
                 }
                 self.push_scope(Scope::new(ScopeKind::Generator));
             }
+            ExprKind::BoolOp { op, values } => {
+                if self.settings.enabled.contains(&CheckCode::PLR1701) {
+                    pylint::plugins::consider_merging_isinstance(self, expr, op, values);
+                }
+            }
             _ => {}
         };
 

src/check_lines.rs

@@ -7,12 +7,12 @@ use rustpython_parser::ast::Location;
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
-use crate::checks::{Check, CheckCode, CheckKind};
+use crate::checks::{Check, CheckCode, CheckKind, REDIRECTS};
 use crate::noqa;
-use crate::noqa::Directive;
+use crate::noqa::{is_file_exempt, Directive};
 use crate::settings::Settings;
 
-// Regex from PEP263
+// Regex from PEP263.
 static CODING_COMMENT_REGEX: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"^[ \t\f]*#.*?coding[:=][ \t]*utf-?8").unwrap());
 
@@ -43,9 +43,9 @@ pub fn check_lines(
     autofix: bool,
     ignore_noqa: bool,
 ) {
-    let enforce_unnecessary_coding_comment = settings.enabled.contains(&CheckCode::U009);
+    let enforce_unnecessary_coding_comment = settings.enabled.contains(&CheckCode::UP009);
     let enforce_line_too_long = settings.enabled.contains(&CheckCode::E501);
-    let enforce_noqa = settings.enabled.contains(&CheckCode::M001);
+    let enforce_noqa = settings.enabled.contains(&CheckCode::RUF100);
 
     let mut noqa_directives: IntMap<usize, (Directive, Vec<&str>)> = IntMap::default();
     let mut line_checks = vec![];
@@ -58,8 +58,11 @@ pub fn check_lines(
     }
 
     macro_rules! add_if {
-        ($check:expr, $noqa:expr) => {{
-            match $noqa {
+        ($check:expr, $noqa_lineno:expr, $line:expr) => {{
+            match noqa_directives
+                .entry($noqa_lineno)
+                .or_insert_with(|| (noqa::extract_noqa_directive($line), vec![]))
+            {
                 (Directive::All(..), matches) => {
                     matches.push($check.kind.code().as_ref());
                     if ignore_noqa {
@@ -67,7 +70,7 @@ pub fn check_lines(
                     }
                 }
                 (Directive::Codes(.., codes), matches) => {
-                    if codes.contains(&$check.kind.code().as_ref()) {
+                    if noqa::includes($check.kind.code(), codes) {
                         matches.push($check.kind.code().as_ref());
                         if ignore_noqa {
                             line_checks.push($check);
@@ -83,12 +86,18 @@ pub fn check_lines(
 
     let lines: Vec<&str> = contents.lines().collect();
     for (lineno, line) in lines.iter().enumerate() {
+        // If we hit an exemption for the entire file, bail.
+        if is_file_exempt(line) {
+            checks.drain(..);
+            return;
+        }
+
         // Grab the noqa (logical) line number for the current (physical) line.
         // If there are newlines at the end of the file, they won't be represented in
         // `noqa_line_for`, so fallback to the current line.
         let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
 
-        // Enforce unnecessary coding comments (U009).
+        // Enforce unnecessary coding comments (UP009).
         if enforce_unnecessary_coding_comment {
             if lineno < 2 {
                 // PEP3120 makes utf-8 the default encoding.
@@ -106,11 +115,7 @@ pub fn check_lines(
                             Location::new(lineno + 2, 0),
                         ));
                     }
-
-                    let noqa = noqa_directives.entry(noqa_lineno).or_insert_with(|| {
-                        (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![])
-                    });
-                    add_if!(check, noqa);
+                    add_if!(check, noqa_lineno, lines[noqa_lineno]);
                 }
             }
         }
@@ -135,7 +140,7 @@ pub fn check_lines(
                     ignored.push(index);
                 }
                 (Directive::Codes(.., codes), matches) => {
-                    if codes.contains(&check.kind.code().as_ref()) {
+                    if noqa::includes(check.kind.code(), codes) {
                         matches.push(check.kind.code().as_ref());
                         ignored.push(index);
                     }
@@ -155,11 +160,7 @@ pub fn check_lines(
                         end_location: Location::new(lineno + 1, line_length),
                     },
                 );
-
-                let noqa = noqa_directives
-                    .entry(noqa_lineno)
-                    .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
-                add_if!(check, noqa);
+                add_if!(check, noqa_lineno, lines[noqa_lineno]);
             }
         }
     }
@@ -179,14 +180,11 @@ pub fn check_lines(
 
             let lineno = lines.len() - 1;
             let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
-            let noqa = noqa_directives
-                .entry(noqa_lineno)
-                .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
-            add_if!(check, noqa);
+            add_if!(check, noqa_lineno, lines[noqa_lineno]);
         }
     }
 
-    // Enforce that the noqa directive was actually used (M001).
+    // Enforce that the noqa directive was actually used (RUF100).
     if enforce_noqa {
         for (row, (directive, matches)) in noqa_directives {
             match directive {
@@ -212,6 +210,7 @@ pub fn check_lines(
                     let mut invalid_codes = vec![];
                     let mut valid_codes = vec![];
                     for code in codes {
+                        let code = REDIRECTS.get(code).map_or(code, AsRef::as_ref);
                         if matches.contains(&code) || settings.external.contains(code) {
                             valid_codes.push(code.to_string());
                         } else {
@@ -269,13 +268,12 @@ mod tests {
     #[test]
     fn e501_non_ascii_char() {
         let line = "'\u{4e9c}' * 2"; // 7 in UTF-32, 9 in UTF-8.
-        let noqa_line_for: IntMap<usize, usize> = IntMap::default();
         let check_with_max_line_length = |line_length: usize| {
             let mut checks: Vec<Check> = vec![];
             check_lines(
                 &mut checks,
                 line,
-                &noqa_line_for,
+                &IntMap::default(),
                 &Settings {
                     line_length,
                     ..Settings::for_rule(CheckCode::E501)

src/checks.rs

@@ -2,6 +2,8 @@ use std::fmt;
 use std::str::FromStr;
 
 use itertools::Itertools;
+use once_cell::sync::Lazy;
+use rustc_hash::FxHashMap;
 use rustpython_parser::ast::Location;
 use serde::{Deserialize, Serialize};
 use strum_macros::{AsRefStr, Display, EnumIter, EnumString};
@@ -90,8 +92,16 @@ pub enum CheckCode {
     F831,
     F841,
     F901,
-    // pylint errors
+    // pylint
+    PLC0414,
+    PLC2201,
+    PLC3002,
     PLE1142,
+    PLR0206,
+    PLR0402,
+    PLR1701,
+    PLR1722,
+    PLW0120,
     // flake8-builtins
     A001,
     A002,
@@ -149,6 +159,15 @@ pub enum CheckCode {
     C901,
     // flake8-tidy-imports
     I252,
+    // flake8-return
+    RET501,
+    RET502,
+    RET503,
+    RET504,
+    RET505,
+    RET506,
+    RET507,
+    RET508,
     // flake8-print
     T201,
     T203,
@@ -181,20 +200,20 @@ pub enum CheckCode {
     YTT302,
     YTT303,
     // pyupgrade
-    U001,
-    U003,
-    U004,
-    U005,
-    U006,
-    U007,
-    U008,
-    U009,
-    U010,
-    U011,
-    U012,
-    U013,
-    U014,
-    U015,
+    UP001,
+    UP003,
+    UP004,
+    UP005,
+    UP006,
+    UP007,
+    UP008,
+    UP009,
+    UP010,
+    UP011,
+    UP012,
+    UP013,
+    UP014,
+    UP015,
     // pydocstyle
     D100,
     D101,
@@ -275,9 +294,7 @@ pub enum CheckCode {
     RUF001,
     RUF002,
     RUF003,
-    RUF101,
-    // Meta
-    M001,
+    RUF100,
     // pygrep-hooks
     PGH001,
 }
@@ -286,28 +303,28 @@ pub enum CheckCode {
 pub enum CheckCategory {
     Pyflakes,
     Pycodestyle,
+    McCabe,
     Isort,
     Pydocstyle,
     Pyupgrade,
     PEP8Naming,
-    Eradicate,
+    Flake82020,
+    Flake8Annotations,
     Flake8Bandit,
-    Flake8Comprehensions,
-    Flake8Debugger,
+    Flake8BlindExcept,
     Flake8BooleanTrap,
     Flake8Bugbear,
     Flake8Builtins,
-    Flake8TidyImports,
+    Flake8Comprehensions,
+    Flake8Debugger,
     Flake8Print,
     Flake8Quotes,
-    Flake8Annotations,
-    Flake82020,
-    Flake8BlindExcept,
-    McCabe,
+    Flake8Return,
+    Flake8TidyImports,
+    Eradicate,
     PygrepHooks,
     Pylint,
     Ruff,
-    Meta,
 }
 
 pub enum Platform {
@@ -339,16 +356,16 @@ impl CheckCategory {
             CheckCategory::Flake8Debugger => "flake8-debugger",
             CheckCategory::Flake8Print => "flake8-print",
             CheckCategory::Flake8Quotes => "flake8-quotes",
+            CheckCategory::Flake8Return => "flake8-return",
             CheckCategory::Flake8TidyImports => "flake8-tidy-imports",
             CheckCategory::Isort => "isort",
             CheckCategory::McCabe => "mccabe",
-            CheckCategory::Meta => "Meta rules",
             CheckCategory::PEP8Naming => "pep8-naming",
             CheckCategory::Pycodestyle => "pycodestyle",
             CheckCategory::Pydocstyle => "pydocstyle",
             CheckCategory::Pyflakes => "Pyflakes",
-            CheckCategory::Pylint => "Pylint",
             CheckCategory::PygrepHooks => "pygrep-hooks",
+            CheckCategory::Pylint => "Pylint",
             CheckCategory::Pyupgrade => "pyupgrade",
             CheckCategory::Ruff => "Ruff-specific rules",
         }
@@ -403,6 +420,10 @@ impl CheckCategory {
                 "https://pypi.org/project/flake8-quotes/3.3.1/",
                 &Platform::PyPI,
             )),
+            CheckCategory::Flake8Return => Some((
+                "https://pypi.org/project/flake8-return/1.2.0/",
+                &Platform::PyPI,
+            )),
             CheckCategory::Flake8TidyImports => Some((
                 "https://pypi.org/project/flake8-tidy-imports/4.8.0/",
                 &Platform::PyPI,
@@ -413,7 +434,6 @@ impl CheckCategory {
             CheckCategory::McCabe => {
                 Some(("https://pypi.org/project/mccabe/0.7.0/", &Platform::PyPI))
             }
-            CheckCategory::Meta => None,
             CheckCategory::PEP8Naming => Some((
                 "https://pypi.org/project/pep8-naming/0.13.2/",
                 &Platform::PyPI,
@@ -476,6 +496,21 @@ impl fmt::Display for DeferralKeyword {
     }
 }
 
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Branch {
+    Elif,
+    Else,
+}
+
+impl fmt::Display for Branch {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Branch::Elif => fmt.write_str("elif"),
+            Branch::Else => fmt.write_str("else"),
+        }
+    }
+}
+
 #[derive(AsRefStr, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum CheckKind {
     // pycodestyle errors
@@ -539,8 +574,16 @@ pub enum CheckKind {
     UnusedImport(String, bool),
     UnusedVariable(String),
     YieldOutsideFunction(DeferralKeyword),
-    // pylint errors
+    // pylint
+    ConsiderMergingIsinstance(String, Vec<String>),
+    UselessImportAlias,
+    MisplacedComparisonConstant(String),
+    UnnecessaryDirectLambdaCall,
+    PropertyWithParameters,
+    ConsiderUsingFromImport(String, String),
     AwaitOutsideAsync,
+    UselessElseOnLoop,
+    ConsiderUsingSysExit,
     // flake8-builtins
     BuiltinVariableShadowing(String),
     BuiltinArgumentShadowing(String),
@@ -596,6 +639,15 @@ pub enum CheckKind {
     Debugger(DebuggerUsingType),
     // flake8-tidy-imports
     BannedRelativeImport(Strictness),
+    // flake8-return
+    UnnecessaryReturnNone,
+    ImplicitReturnValue,
+    ImplicitReturn,
+    UnnecessaryAssign,
+    SuperfluousElseReturn(Branch),
+    SuperfluousElseRaise(Branch),
+    SuperfluousElseContinue(Branch),
+    SuperfluousElseBreak(Branch),
     // flake8-print
     PrintFound,
     PPrintFound,
@@ -726,8 +778,6 @@ pub enum CheckKind {
     AmbiguousUnicodeCharacterString(char, char),
     AmbiguousUnicodeCharacterDocstring(char, char),
     AmbiguousUnicodeCharacterComment(char, char),
-    ConvertExitToSysExit,
-    // Meta
     UnusedNOQA(Option<Vec<String>>),
 }
 
@@ -736,7 +786,7 @@ impl CheckCode {
     /// physical lines).
     pub fn lint_source(&self) -> &'static LintSource {
         match self {
-            CheckCode::E501 | CheckCode::W292 | CheckCode::M001 | CheckCode::U009 => {
+            CheckCode::E501 | CheckCode::W292 | CheckCode::RUF100 | CheckCode::UP009 => {
                 &LintSource::Lines
             }
             CheckCode::ERA001
@@ -824,8 +874,20 @@ impl CheckCode {
             CheckCode::F831 => CheckKind::DuplicateArgumentName,
             CheckCode::F841 => CheckKind::UnusedVariable("...".to_string()),
             CheckCode::F901 => CheckKind::RaiseNotImplemented,
-            // pylint errors
+            // pylint
+            CheckCode::PLC0414 => CheckKind::UselessImportAlias,
+            CheckCode::PLC2201 => CheckKind::MisplacedComparisonConstant("...".to_string()),
+            CheckCode::PLC3002 => CheckKind::UnnecessaryDirectLambdaCall,
             CheckCode::PLE1142 => CheckKind::AwaitOutsideAsync,
+            CheckCode::PLR0402 => {
+                CheckKind::ConsiderUsingFromImport("...".to_string(), "...".to_string())
+            }
+            CheckCode::PLR0206 => CheckKind::PropertyWithParameters,
+            CheckCode::PLR1701 => {
+                CheckKind::ConsiderMergingIsinstance("...".to_string(), vec!["...".to_string()])
+            }
+            CheckCode::PLR1722 => CheckKind::ConsiderUsingSysExit,
+            CheckCode::PLW0120 => CheckKind::UselessElseOnLoop,
             // flake8-builtins
             CheckCode::A001 => CheckKind::BuiltinVariableShadowing("...".to_string()),
             CheckCode::A002 => CheckKind::BuiltinArgumentShadowing("...".to_string()),
@@ -896,6 +958,15 @@ impl CheckCode {
             CheckCode::T100 => CheckKind::Debugger(DebuggerUsingType::Import("...".to_string())),
             // flake8-tidy-imports
             CheckCode::I252 => CheckKind::BannedRelativeImport(Strictness::All),
+            // flake8-return
+            CheckCode::RET501 => CheckKind::UnnecessaryReturnNone,
+            CheckCode::RET502 => CheckKind::ImplicitReturnValue,
+            CheckCode::RET503 => CheckKind::ImplicitReturn,
+            CheckCode::RET504 => CheckKind::UnnecessaryAssign,
+            CheckCode::RET505 => CheckKind::SuperfluousElseReturn(Branch::Else),
+            CheckCode::RET506 => CheckKind::SuperfluousElseRaise(Branch::Else),
+            CheckCode::RET507 => CheckKind::SuperfluousElseContinue(Branch::Else),
+            CheckCode::RET508 => CheckKind::SuperfluousElseBreak(Branch::Else),
             // flake8-print
             CheckCode::T201 => CheckKind::PrintFound,
             CheckCode::T203 => CheckKind::PPrintFound,
@@ -930,23 +1001,23 @@ impl CheckCode {
             // flake8-blind-except
             CheckCode::BLE001 => CheckKind::BlindExcept,
             // pyupgrade
-            CheckCode::U001 => CheckKind::UselessMetaclassType,
-            CheckCode::U003 => CheckKind::TypeOfPrimitive(Primitive::Str),
-            CheckCode::U004 => CheckKind::UselessObjectInheritance("...".to_string()),
-            CheckCode::U005 => CheckKind::DeprecatedUnittestAlias(
+            CheckCode::UP001 => CheckKind::UselessMetaclassType,
+            CheckCode::UP003 => CheckKind::TypeOfPrimitive(Primitive::Str),
+            CheckCode::UP004 => CheckKind::UselessObjectInheritance("...".to_string()),
+            CheckCode::UP005 => CheckKind::DeprecatedUnittestAlias(
                 "assertEquals".to_string(),
                 "assertEqual".to_string(),
             ),
-            CheckCode::U006 => CheckKind::UsePEP585Annotation("List".to_string()),
-            CheckCode::U007 => CheckKind::UsePEP604Annotation,
-            CheckCode::U008 => CheckKind::SuperCallWithParameters,
-            CheckCode::U009 => CheckKind::PEP3120UnnecessaryCodingComment,
-            CheckCode::U010 => CheckKind::UnnecessaryFutureImport(vec!["...".to_string()]),
-            CheckCode::U011 => CheckKind::UnnecessaryLRUCacheParams,
-            CheckCode::U012 => CheckKind::UnnecessaryEncodeUTF8,
-            CheckCode::U013 => CheckKind::ConvertTypedDictFunctionalToClass("...".to_string()),
-            CheckCode::U014 => CheckKind::ConvertNamedTupleFunctionalToClass("...".to_string()),
-            CheckCode::U015 => CheckKind::RedundantOpenModes,
+            CheckCode::UP006 => CheckKind::UsePEP585Annotation("List".to_string()),
+            CheckCode::UP007 => CheckKind::UsePEP604Annotation,
+            CheckCode::UP008 => CheckKind::SuperCallWithParameters,
+            CheckCode::UP009 => CheckKind::PEP3120UnnecessaryCodingComment,
+            CheckCode::UP010 => CheckKind::UnnecessaryFutureImport(vec!["...".to_string()]),
+            CheckCode::UP011 => CheckKind::UnnecessaryLRUCacheParams,
+            CheckCode::UP012 => CheckKind::UnnecessaryEncodeUTF8,
+            CheckCode::UP013 => CheckKind::ConvertTypedDictFunctionalToClass("...".to_string()),
+            CheckCode::UP014 => CheckKind::ConvertNamedTupleFunctionalToClass("...".to_string()),
+            CheckCode::UP015 => CheckKind::RedundantOpenModes,
             // pydocstyle
             CheckCode::D100 => CheckKind::PublicModule,
             CheckCode::D101 => CheckKind::PublicClass,
@@ -1046,9 +1117,7 @@ impl CheckCode {
             CheckCode::RUF001 => CheckKind::AmbiguousUnicodeCharacterString('𝐁', 'B'),
             CheckCode::RUF002 => CheckKind::AmbiguousUnicodeCharacterDocstring('𝐁', 'B'),
             CheckCode::RUF003 => CheckKind::AmbiguousUnicodeCharacterComment('𝐁', 'B'),
-            CheckCode::RUF101 => CheckKind::ConvertExitToSysExit,
-            // Meta
-            CheckCode::M001 => CheckKind::UnusedNOQA(None),
+            CheckCode::RUF100 => CheckKind::UnusedNOQA(None),
         }
     }
 
@@ -1220,7 +1289,6 @@ impl CheckCode {
             CheckCode::FBT003 => CheckCategory::Flake8BooleanTrap,
             CheckCode::I001 => CheckCategory::Isort,
             CheckCode::I252 => CheckCategory::Flake8TidyImports,
-            CheckCode::M001 => CheckCategory::Meta,
             CheckCode::N801 => CheckCategory::PEP8Naming,
             CheckCode::N802 => CheckCategory::PEP8Naming,
             CheckCode::N803 => CheckCategory::PEP8Naming,
@@ -1237,15 +1305,31 @@ impl CheckCode {
             CheckCode::N817 => CheckCategory::PEP8Naming,
             CheckCode::N818 => CheckCategory::PEP8Naming,
             CheckCode::PGH001 => CheckCategory::PygrepHooks,
+            CheckCode::PLC0414 => CheckCategory::Pylint,
+            CheckCode::PLC2201 => CheckCategory::Pylint,
+            CheckCode::PLC3002 => CheckCategory::Pylint,
             CheckCode::PLE1142 => CheckCategory::Pylint,
+            CheckCode::PLR0206 => CheckCategory::Pylint,
+            CheckCode::PLR0402 => CheckCategory::Pylint,
+            CheckCode::PLR1701 => CheckCategory::Pylint,
+            CheckCode::PLR1722 => CheckCategory::Pylint,
+            CheckCode::PLW0120 => CheckCategory::Pylint,
             CheckCode::Q000 => CheckCategory::Flake8Quotes,
             CheckCode::Q001 => CheckCategory::Flake8Quotes,
             CheckCode::Q002 => CheckCategory::Flake8Quotes,
             CheckCode::Q003 => CheckCategory::Flake8Quotes,
+            CheckCode::RET501 => CheckCategory::Flake8Return,
+            CheckCode::RET502 => CheckCategory::Flake8Return,
+            CheckCode::RET503 => CheckCategory::Flake8Return,
+            CheckCode::RET504 => CheckCategory::Flake8Return,
+            CheckCode::RET505 => CheckCategory::Flake8Return,
+            CheckCode::RET506 => CheckCategory::Flake8Return,
+            CheckCode::RET507 => CheckCategory::Flake8Return,
+            CheckCode::RET508 => CheckCategory::Flake8Return,
             CheckCode::RUF001 => CheckCategory::Ruff,
             CheckCode::RUF002 => CheckCategory::Ruff,
             CheckCode::RUF003 => CheckCategory::Ruff,
-            CheckCode::RUF101 => CheckCategory::Ruff,
+            CheckCode::RUF100 => CheckCategory::Ruff,
             CheckCode::S101 => CheckCategory::Flake8Bandit,
             CheckCode::S102 => CheckCategory::Flake8Bandit,
             CheckCode::S104 => CheckCategory::Flake8Bandit,
@@ -1255,20 +1339,20 @@ impl CheckCode {
             CheckCode::T100 => CheckCategory::Flake8Debugger,
             CheckCode::T201 => CheckCategory::Flake8Print,
             CheckCode::T203 => CheckCategory::Flake8Print,
-            CheckCode::U001 => CheckCategory::Pyupgrade,
-            CheckCode::U003 => CheckCategory::Pyupgrade,
-            CheckCode::U004 => CheckCategory::Pyupgrade,
-            CheckCode::U005 => CheckCategory::Pyupgrade,
-            CheckCode::U006 => CheckCategory::Pyupgrade,
-            CheckCode::U007 => CheckCategory::Pyupgrade,
-            CheckCode::U008 => CheckCategory::Pyupgrade,
-            CheckCode::U009 => CheckCategory::Pyupgrade,
-            CheckCode::U010 => CheckCategory::Pyupgrade,
-            CheckCode::U011 => CheckCategory::Pyupgrade,
-            CheckCode::U012 => CheckCategory::Pyupgrade,
-            CheckCode::U013 => CheckCategory::Pyupgrade,
-            CheckCode::U014 => CheckCategory::Pyupgrade,
-            CheckCode::U015 => CheckCategory::Pyupgrade,
+            CheckCode::UP001 => CheckCategory::Pyupgrade,
+            CheckCode::UP003 => CheckCategory::Pyupgrade,
+            CheckCode::UP004 => CheckCategory::Pyupgrade,
+            CheckCode::UP005 => CheckCategory::Pyupgrade,
+            CheckCode::UP006 => CheckCategory::Pyupgrade,
+            CheckCode::UP007 => CheckCategory::Pyupgrade,
+            CheckCode::UP008 => CheckCategory::Pyupgrade,
+            CheckCode::UP009 => CheckCategory::Pyupgrade,
+            CheckCode::UP010 => CheckCategory::Pyupgrade,
+            CheckCode::UP011 => CheckCategory::Pyupgrade,
+            CheckCode::UP012 => CheckCategory::Pyupgrade,
+            CheckCode::UP013 => CheckCategory::Pyupgrade,
+            CheckCode::UP014 => CheckCategory::Pyupgrade,
+            CheckCode::UP015 => CheckCategory::Pyupgrade,
             CheckCode::W292 => CheckCategory::Pycodestyle,
             CheckCode::W605 => CheckCategory::Pycodestyle,
             CheckCode::YTT101 => CheckCategory::Flake82020,
@@ -1349,8 +1433,16 @@ impl CheckKind {
             // pycodestyle warnings
             CheckKind::NoNewLineAtEndOfFile => &CheckCode::W292,
             CheckKind::InvalidEscapeSequence(_) => &CheckCode::W605,
-            // pylint errors
+            // pylint
+            CheckKind::UselessImportAlias => &CheckCode::PLC0414,
+            CheckKind::MisplacedComparisonConstant(..) => &CheckCode::PLC2201,
+            CheckKind::UnnecessaryDirectLambdaCall => &CheckCode::PLC3002,
             CheckKind::AwaitOutsideAsync => &CheckCode::PLE1142,
+            CheckKind::ConsiderMergingIsinstance(..) => &CheckCode::PLR1701,
+            CheckKind::PropertyWithParameters => &CheckCode::PLR0206,
+            CheckKind::ConsiderUsingFromImport(..) => &CheckCode::PLR0402,
+            CheckKind::ConsiderUsingSysExit => &CheckCode::PLR1722,
+            CheckKind::UselessElseOnLoop => &CheckCode::PLW0120,
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(_) => &CheckCode::A001,
             CheckKind::BuiltinArgumentShadowing(_) => &CheckCode::A002,
@@ -1406,6 +1498,15 @@ impl CheckKind {
             CheckKind::Debugger(_) => &CheckCode::T100,
             // flake8-tidy-imports
             CheckKind::BannedRelativeImport(_) => &CheckCode::I252,
+            // flake8-return
+            CheckKind::UnnecessaryReturnNone => &CheckCode::RET501,
+            CheckKind::ImplicitReturnValue => &CheckCode::RET502,
+            CheckKind::ImplicitReturn => &CheckCode::RET503,
+            CheckKind::UnnecessaryAssign => &CheckCode::RET504,
+            CheckKind::SuperfluousElseReturn(_) => &CheckCode::RET505,
+            CheckKind::SuperfluousElseRaise(_) => &CheckCode::RET506,
+            CheckKind::SuperfluousElseContinue(_) => &CheckCode::RET507,
+            CheckKind::SuperfluousElseBreak(_) => &CheckCode::RET508,
             // flake8-print
             CheckKind::PrintFound => &CheckCode::T201,
             CheckKind::PPrintFound => &CheckCode::T203,
@@ -1438,20 +1539,20 @@ impl CheckKind {
             CheckKind::SysVersionCmpStr10 => &CheckCode::YTT302,
             CheckKind::SysVersionSlice1Referenced => &CheckCode::YTT303,
             // pyupgrade
-            CheckKind::TypeOfPrimitive(_) => &CheckCode::U003,
-            CheckKind::UselessMetaclassType => &CheckCode::U001,
-            CheckKind::DeprecatedUnittestAlias(..) => &CheckCode::U005,
-            CheckKind::UsePEP585Annotation(_) => &CheckCode::U006,
-            CheckKind::UsePEP604Annotation => &CheckCode::U007,
-            CheckKind::UselessObjectInheritance(_) => &CheckCode::U004,
-            CheckKind::SuperCallWithParameters => &CheckCode::U008,
-            CheckKind::PEP3120UnnecessaryCodingComment => &CheckCode::U009,
-            CheckKind::UnnecessaryFutureImport(_) => &CheckCode::U010,
-            CheckKind::UnnecessaryLRUCacheParams => &CheckCode::U011,
-            CheckKind::UnnecessaryEncodeUTF8 => &CheckCode::U012,
-            CheckKind::ConvertTypedDictFunctionalToClass(_) => &CheckCode::U013,
-            CheckKind::ConvertNamedTupleFunctionalToClass(_) => &CheckCode::U014,
-            CheckKind::RedundantOpenModes => &CheckCode::U015,
+            CheckKind::TypeOfPrimitive(_) => &CheckCode::UP003,
+            CheckKind::UselessMetaclassType => &CheckCode::UP001,
+            CheckKind::DeprecatedUnittestAlias(..) => &CheckCode::UP005,
+            CheckKind::UsePEP585Annotation(_) => &CheckCode::UP006,
+            CheckKind::UsePEP604Annotation => &CheckCode::UP007,
+            CheckKind::UselessObjectInheritance(_) => &CheckCode::UP004,
+            CheckKind::SuperCallWithParameters => &CheckCode::UP008,
+            CheckKind::PEP3120UnnecessaryCodingComment => &CheckCode::UP009,
+            CheckKind::UnnecessaryFutureImport(_) => &CheckCode::UP010,
+            CheckKind::UnnecessaryLRUCacheParams => &CheckCode::UP011,
+            CheckKind::UnnecessaryEncodeUTF8 => &CheckCode::UP012,
+            CheckKind::ConvertTypedDictFunctionalToClass(_) => &CheckCode::UP013,
+            CheckKind::ConvertNamedTupleFunctionalToClass(_) => &CheckCode::UP014,
+            CheckKind::RedundantOpenModes => &CheckCode::UP015,
             // pydocstyle
             CheckKind::BlankLineAfterLastSection(_) => &CheckCode::D413,
             CheckKind::BlankLineAfterSection(_) => &CheckCode::D410,
@@ -1536,9 +1637,7 @@ impl CheckKind {
             CheckKind::AmbiguousUnicodeCharacterString(..) => &CheckCode::RUF001,
             CheckKind::AmbiguousUnicodeCharacterDocstring(..) => &CheckCode::RUF002,
             CheckKind::AmbiguousUnicodeCharacterComment(..) => &CheckCode::RUF003,
-            CheckKind::ConvertExitToSysExit => &CheckCode::RUF101,
-            // Meta
-            CheckKind::UnusedNOQA(_) => &CheckCode::M001,
+            CheckKind::UnusedNOQA(_) => &CheckCode::RUF100,
         }
     }
 
@@ -1722,10 +1821,33 @@ impl CheckKind {
             CheckKind::InvalidEscapeSequence(char) => {
                 format!("Invalid escape sequence: '\\{char}'")
             }
-            // pylint errors
+            // pylint
+            CheckKind::UselessImportAlias => {
+                "Import alias does not rename original package".to_string()
+            }
+            CheckKind::ConsiderMergingIsinstance(obj, types) => {
+                let types = types.join(", ");
+                format!("Consider merging these isinstance calls: `isinstance({obj}, ({types}))`")
+            }
+            CheckKind::MisplacedComparisonConstant(comprison) => {
+                format!("Comparison should be {comprison}")
+            }
+            CheckKind::UnnecessaryDirectLambdaCall => "Lambda expression called directly. Execute \
+                                                       the expression inline instead."
+                .to_string(),
+            CheckKind::PropertyWithParameters => {
+                "Cannot have defined parameters for properties".to_string()
+            }
+            CheckKind::ConsiderUsingFromImport(module, name) => {
+                format!("Consider using `from {module} import {name}`")
+            }
             CheckKind::AwaitOutsideAsync => {
                 "`await` should be used within an async function".to_string()
             }
+            CheckKind::UselessElseOnLoop => "Else clause on loop without a break statement, \
+                                             remove the else and de-indent all the code inside it"
+                .to_string(),
+            CheckKind::ConsiderUsingSysExit => "Consider using `sys.exit()`".to_string(),
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(name) => {
                 format!("Variable `{name}` is shadowing a python builtin")
@@ -1936,6 +2058,31 @@ impl CheckKind {
                 }
                 Strictness::All => "Relative imports are banned".to_string(),
             },
+            // flake8-return
+            CheckKind::UnnecessaryReturnNone => "Do not explicitly `return None` in function if \
+                                                 it is the only possible return value"
+                .to_string(),
+            CheckKind::ImplicitReturnValue => "Do not implicitly `return None` in function able \
+                                               to return non-`None` value"
+                .to_string(),
+            CheckKind::ImplicitReturn => "Missing explicit `return` at the end of function able \
+                                          to return non-`None` value"
+                .to_string(),
+            CheckKind::UnnecessaryAssign => {
+                "Unnecessary variable assignment before `return` statement".to_string()
+            }
+            CheckKind::SuperfluousElseReturn(branch) => {
+                format!("Unnecessary `{branch}` after `return` statement")
+            }
+            CheckKind::SuperfluousElseRaise(branch) => {
+                format!("Unnecessary `{branch}` after `raise` statement")
+            }
+            CheckKind::SuperfluousElseContinue(branch) => {
+                format!("Unnecessary `{branch}` after `continue` statement")
+            }
+            CheckKind::SuperfluousElseBreak(branch) => {
+                format!("Unnecessary `{branch}` after `break` statement")
+            }
             // flake8-print
             CheckKind::PrintFound => "`print` found".to_string(),
             CheckKind::PPrintFound => "`pprint` found".to_string(),
@@ -2288,10 +2435,6 @@ impl CheckKind {
                      '{representant}'?)"
                 )
             }
-            CheckKind::ConvertExitToSysExit => "`exit()` is only available in the interpreter, \
-                                                use `sys.exit()` instead"
-                .to_string(),
-            // Meta
             CheckKind::UnusedNOQA(codes) => match codes {
                 None => "Unused `noqa` directive".to_string(),
                 Some(codes) => {
@@ -2343,7 +2486,7 @@ impl CheckKind {
                 | CheckKind::BlankLineBeforeSection(..)
                 | CheckKind::CapitalizeSectionName(..)
                 | CheckKind::CommentedOutCode
-                | CheckKind::ConvertExitToSysExit
+                | CheckKind::ConsiderUsingSysExit
                 | CheckKind::ConvertNamedTupleFunctionalToClass(..)
                 | CheckKind::ConvertTypedDictFunctionalToClass(..)
                 | CheckKind::DashedUnderlineAfterSection(..)
@@ -2352,7 +2495,10 @@ impl CheckKind {
                 | CheckKind::DoNotAssignLambda
                 | CheckKind::DuplicateHandlerException(..)
                 | CheckKind::GetAttrWithConstant
+                | CheckKind::ImplicitReturn
+                | CheckKind::ImplicitReturnValue
                 | CheckKind::IsLiteral
+                | CheckKind::MisplacedComparisonConstant(..)
                 | CheckKind::NewLineAfterLastParagraph
                 | CheckKind::NewLineAfterSectionName(..)
                 | CheckKind::NoBlankLineAfterFunction(..)
@@ -2371,6 +2517,7 @@ impl CheckKind {
                 | CheckKind::PPrintFound
                 | CheckKind::PrintFound
                 | CheckKind::RaiseNotImplemented
+                | CheckKind::RedundantOpenModes
                 | CheckKind::RedundantTupleInExceptionHandler(..)
                 | CheckKind::SectionNameEndsInColon(..)
                 | CheckKind::SectionNotOverIndented(..)
@@ -2385,7 +2532,6 @@ impl CheckKind {
                 | CheckKind::UnnecessaryComprehension(..)
                 | CheckKind::UnnecessaryEncodeUTF8
                 | CheckKind::UnnecessaryFutureImport(..)
-                | CheckKind::RedundantOpenModes
                 | CheckKind::UnnecessaryGeneratorDict
                 | CheckKind::UnnecessaryGeneratorList
                 | CheckKind::UnnecessaryGeneratorSet
@@ -2397,12 +2543,14 @@ impl CheckKind {
                 | CheckKind::UnnecessaryLiteralSet(..)
                 | CheckKind::UnnecessaryLiteralWithinListCall(..)
                 | CheckKind::UnnecessaryLiteralWithinTupleCall(..)
+                | CheckKind::UnnecessaryReturnNone
                 | CheckKind::UnsortedImports
                 | CheckKind::UnusedImport(_, false)
                 | CheckKind::UnusedLoopControlVariable(..)
                 | CheckKind::UnusedNOQA(..)
                 | CheckKind::UsePEP585Annotation(..)
                 | CheckKind::UsePEP604Annotation
+                | CheckKind::UselessImportAlias
                 | CheckKind::UselessMetaclassType
                 | CheckKind::UselessObjectInheritance(..)
         )
@@ -2432,6 +2580,27 @@ impl Check {
     }
 }
 
+/// A hash map from deprecated to latest `CheckCode`.
+pub static REDIRECTS: Lazy<FxHashMap<&'static str, CheckCode>> = Lazy::new(|| {
+    FxHashMap::from_iter([
+        // TODO(charlie): Remove by 2023-01-01.
+        ("U001", CheckCode::UP001),
+        ("U003", CheckCode::UP003),
+        ("U004", CheckCode::UP004),
+        ("U005", CheckCode::UP005),
+        ("U006", CheckCode::UP006),
+        ("U007", CheckCode::UP007),
+        ("U008", CheckCode::UP008),
+        ("U009", CheckCode::UP009),
+        ("U010", CheckCode::UP010),
+        ("U011", CheckCode::UP011),
+        ("U012", CheckCode::UP012),
+        ("U013", CheckCode::UP013),
+        ("U014", CheckCode::UP014),
+        ("U015", CheckCode::UP015),
+    ])
+});
+
 #[cfg(test)]
 mod tests {
     use std::str::FromStr;

src/checks_gen.rs

@@ -1,5 +1,6 @@
 //! File automatically generated by `examples/generate_check_code_prefix.rs`.
 
+use colored::Colorize;
 use serde::{Deserialize, Serialize};
 use strum_macros::EnumString;
 
@@ -255,10 +256,6 @@ pub enum CheckCodePrefix {
     I2,
     I25,
     I252,
-    M,
-    M0,
-    M00,
-    M001,
     N,
     N8,
     N80,
@@ -282,11 +279,43 @@ pub enum CheckCodePrefix {
     PGH0,
     PGH00,
     PGH001,
+    PLC,
+    PLC0,
+    PLC04,
+    PLC041,
+    PLC0414,
+    PLC2,
+    PLC22,
+    PLC220,
+    PLC2201,
+    PLC3,
+    PLC30,
+    PLC300,
+    PLC3002,
     PLE,
     PLE1,
     PLE11,
     PLE114,
     PLE1142,
+    PLR,
+    PLR0,
+    PLR02,
+    PLR020,
+    PLR0206,
+    PLR04,
+    PLR040,
+    PLR0402,
+    PLR1,
+    PLR17,
+    PLR170,
+    PLR1701,
+    PLR172,
+    PLR1722,
+    PLW,
+    PLW0,
+    PLW01,
+    PLW012,
+    PLW0120,
     Q,
     Q0,
     Q00,
@@ -294,6 +323,17 @@ pub enum CheckCodePrefix {
     Q001,
     Q002,
     Q003,
+    RET,
+    RET5,
+    RET50,
+    RET501,
+    RET502,
+    RET503,
+    RET504,
+    RET505,
+    RET506,
+    RET507,
+    RET508,
     RUF,
     RUF0,
     RUF00,
@@ -302,7 +342,7 @@ pub enum CheckCodePrefix {
     RUF003,
     RUF1,
     RUF10,
-    RUF101,
+    RUF100,
     S,
     S1,
     S10,
@@ -338,6 +378,24 @@ pub enum CheckCodePrefix {
     U013,
     U014,
     U015,
+    UP,
+    UP0,
+    UP00,
+    UP001,
+    UP003,
+    UP004,
+    UP005,
+    UP006,
+    UP007,
+    UP008,
+    UP009,
+    UP01,
+    UP010,
+    UP011,
+    UP012,
+    UP013,
+    UP014,
+    UP015,
     W,
     W2,
     W29,
@@ -1080,10 +1138,6 @@ impl CheckCodePrefix {
             CheckCodePrefix::I2 => vec![CheckCode::I252],
             CheckCodePrefix::I25 => vec![CheckCode::I252],
             CheckCodePrefix::I252 => vec![CheckCode::I252],
-            CheckCodePrefix::M => vec![CheckCode::M001],
-            CheckCodePrefix::M0 => vec![CheckCode::M001],
-            CheckCodePrefix::M00 => vec![CheckCode::M001],
-            CheckCodePrefix::M001 => vec![CheckCode::M001],
             CheckCodePrefix::N => vec![
                 CheckCode::N801,
                 CheckCode::N802,
@@ -1156,11 +1210,50 @@ impl CheckCodePrefix {
             CheckCodePrefix::PGH0 => vec![CheckCode::PGH001],
             CheckCodePrefix::PGH00 => vec![CheckCode::PGH001],
             CheckCodePrefix::PGH001 => vec![CheckCode::PGH001],
+            CheckCodePrefix::PLC => {
+                vec![CheckCode::PLC0414, CheckCode::PLC2201, CheckCode::PLC3002]
+            }
+            CheckCodePrefix::PLC0 => vec![CheckCode::PLC0414],
+            CheckCodePrefix::PLC04 => vec![CheckCode::PLC0414],
+            CheckCodePrefix::PLC041 => vec![CheckCode::PLC0414],
+            CheckCodePrefix::PLC0414 => vec![CheckCode::PLC0414],
+            CheckCodePrefix::PLC2 => vec![CheckCode::PLC2201],
+            CheckCodePrefix::PLC22 => vec![CheckCode::PLC2201],
+            CheckCodePrefix::PLC220 => vec![CheckCode::PLC2201],
+            CheckCodePrefix::PLC2201 => vec![CheckCode::PLC2201],
+            CheckCodePrefix::PLC3 => vec![CheckCode::PLC3002],
+            CheckCodePrefix::PLC30 => vec![CheckCode::PLC3002],
+            CheckCodePrefix::PLC300 => vec![CheckCode::PLC3002],
+            CheckCodePrefix::PLC3002 => vec![CheckCode::PLC3002],
             CheckCodePrefix::PLE => vec![CheckCode::PLE1142],
             CheckCodePrefix::PLE1 => vec![CheckCode::PLE1142],
             CheckCodePrefix::PLE11 => vec![CheckCode::PLE1142],
             CheckCodePrefix::PLE114 => vec![CheckCode::PLE1142],
             CheckCodePrefix::PLE1142 => vec![CheckCode::PLE1142],
+            CheckCodePrefix::PLR => vec![
+                CheckCode::PLR0206,
+                CheckCode::PLR0402,
+                CheckCode::PLR1701,
+                CheckCode::PLR1722,
+            ],
+            CheckCodePrefix::PLR0 => vec![CheckCode::PLR0206, CheckCode::PLR0402],
+            CheckCodePrefix::PLR02 => vec![CheckCode::PLR0206],
+            CheckCodePrefix::PLR020 => vec![CheckCode::PLR0206],
+            CheckCodePrefix::PLR0206 => vec![CheckCode::PLR0206],
+            CheckCodePrefix::PLR04 => vec![CheckCode::PLR0402],
+            CheckCodePrefix::PLR040 => vec![CheckCode::PLR0402],
+            CheckCodePrefix::PLR0402 => vec![CheckCode::PLR0402],
+            CheckCodePrefix::PLR1 => vec![CheckCode::PLR1701, CheckCode::PLR1722],
+            CheckCodePrefix::PLR17 => vec![CheckCode::PLR1701, CheckCode::PLR1722],
+            CheckCodePrefix::PLR170 => vec![CheckCode::PLR1701],
+            CheckCodePrefix::PLR1701 => vec![CheckCode::PLR1701],
+            CheckCodePrefix::PLR172 => vec![CheckCode::PLR1722],
+            CheckCodePrefix::PLR1722 => vec![CheckCode::PLR1722],
+            CheckCodePrefix::PLW => vec![CheckCode::PLW0120],
+            CheckCodePrefix::PLW0 => vec![CheckCode::PLW0120],
+            CheckCodePrefix::PLW01 => vec![CheckCode::PLW0120],
+            CheckCodePrefix::PLW012 => vec![CheckCode::PLW0120],
+            CheckCodePrefix::PLW0120 => vec![CheckCode::PLW0120],
             CheckCodePrefix::Q => vec![
                 CheckCode::Q000,
                 CheckCode::Q001,
@@ -1183,20 +1276,58 @@ impl CheckCodePrefix {
             CheckCodePrefix::Q001 => vec![CheckCode::Q001],
             CheckCodePrefix::Q002 => vec![CheckCode::Q002],
             CheckCodePrefix::Q003 => vec![CheckCode::Q003],
+            CheckCodePrefix::RET => vec![
+                CheckCode::RET501,
+                CheckCode::RET502,
+                CheckCode::RET503,
+                CheckCode::RET504,
+                CheckCode::RET505,
+                CheckCode::RET506,
+                CheckCode::RET507,
+                CheckCode::RET508,
+            ],
+            CheckCodePrefix::RET5 => vec![
+                CheckCode::RET501,
+                CheckCode::RET502,
+                CheckCode::RET503,
+                CheckCode::RET504,
+                CheckCode::RET505,
+                CheckCode::RET506,
+                CheckCode::RET507,
+                CheckCode::RET508,
+            ],
+            CheckCodePrefix::RET50 => vec![
+                CheckCode::RET501,
+                CheckCode::RET502,
+                CheckCode::RET503,
+                CheckCode::RET504,
+                CheckCode::RET505,
+                CheckCode::RET506,
+                CheckCode::RET507,
+                CheckCode::RET508,
+            ],
+            CheckCodePrefix::RET501 => vec![CheckCode::RET501],
+            CheckCodePrefix::RET502 => vec![CheckCode::RET502],
+            CheckCodePrefix::RET503 => vec![CheckCode::RET503],
+            CheckCodePrefix::RET504 => vec![CheckCode::RET504],
+            CheckCodePrefix::RET505 => vec![CheckCode::RET505],
+            CheckCodePrefix::RET506 => vec![CheckCode::RET506],
+            CheckCodePrefix::RET507 => vec![CheckCode::RET507],
+            CheckCodePrefix::RET508 => vec![CheckCode::RET508],
             CheckCodePrefix::RUF => vec![
                 CheckCode::RUF001,
                 CheckCode::RUF002,
                 CheckCode::RUF003,
-                CheckCode::RUF101,
+                CheckCode::RUF100,
             ],
             CheckCodePrefix::RUF0 => vec![CheckCode::RUF001, CheckCode::RUF002, CheckCode::RUF003],
             CheckCodePrefix::RUF00 => vec![CheckCode::RUF001, CheckCode::RUF002, CheckCode::RUF003],
             CheckCodePrefix::RUF001 => vec![CheckCode::RUF001],
             CheckCodePrefix::RUF002 => vec![CheckCode::RUF002],
             CheckCodePrefix::RUF003 => vec![CheckCode::RUF003],
-            CheckCodePrefix::RUF1 => vec![CheckCode::RUF101],
-            CheckCodePrefix::RUF10 => vec![CheckCode::RUF101],
-            CheckCodePrefix::RUF101 => vec![CheckCode::RUF101],
+            CheckCodePrefix::RUF1 => vec![CheckCode::RUF100],
+            CheckCodePrefix::RUF10 => vec![CheckCode::RUF100],
+            CheckCodePrefix::RUF100 => vec![CheckCode::RUF100],
             CheckCodePrefix::S => vec![
                 CheckCode::S101,
                 CheckCode::S102,
@@ -1236,69 +1367,245 @@ impl CheckCodePrefix {
             CheckCodePrefix::T201 => vec![CheckCode::T201],
             CheckCodePrefix::T203 => vec![CheckCode::T203],
             CheckCodePrefix::U => vec![
-                CheckCode::U001,
-                CheckCode::U003,
-                CheckCode::U004,
-                CheckCode::U005,
-                CheckCode::U006,
-                CheckCode::U007,
-                CheckCode::U008,
-                CheckCode::U009,
-                CheckCode::U010,
-                CheckCode::U011,
-                CheckCode::U012,
-                CheckCode::U013,
-                CheckCode::U014,
-                CheckCode::U015,
+                CheckCode::UP001,
+                CheckCode::UP003,
+                CheckCode::UP004,
+                CheckCode::UP005,
+                CheckCode::UP006,
+                CheckCode::UP007,
+                CheckCode::UP008,
+                CheckCode::UP009,
+                CheckCode::UP010,
+                CheckCode::UP011,
+                CheckCode::UP012,
+                CheckCode::UP013,
+                CheckCode::UP014,
+                CheckCode::UP015,
             ],
             CheckCodePrefix::U0 => vec![
-                CheckCode::U001,
-                CheckCode::U003,
-                CheckCode::U004,
-                CheckCode::U005,
-                CheckCode::U006,
-                CheckCode::U007,
-                CheckCode::U008,
-                CheckCode::U009,
-                CheckCode::U010,
-                CheckCode::U011,
-                CheckCode::U012,
-                CheckCode::U013,
-                CheckCode::U014,
-                CheckCode::U015,
+                CheckCode::UP001,
+                CheckCode::UP003,
+                CheckCode::UP004,
+                CheckCode::UP005,
+                CheckCode::UP006,
+                CheckCode::UP007,
+                CheckCode::UP008,
+                CheckCode::UP009,
+                CheckCode::UP010,
+                CheckCode::UP011,
+                CheckCode::UP012,
+                CheckCode::UP013,
+                CheckCode::UP014,
+                CheckCode::UP015,
             ],
             CheckCodePrefix::U00 => vec![
-                CheckCode::U001,
-                CheckCode::U003,
-                CheckCode::U004,
-                CheckCode::U005,
-                CheckCode::U006,
-                CheckCode::U007,
-                CheckCode::U008,
-                CheckCode::U009,
+                CheckCode::UP001,
+                CheckCode::UP003,
+                CheckCode::UP004,
+                CheckCode::UP005,
+                CheckCode::UP006,
+                CheckCode::UP007,
+                CheckCode::UP008,
+                CheckCode::UP009,
             ],
-            CheckCodePrefix::U001 => vec![CheckCode::U001],
-            CheckCodePrefix::U003 => vec![CheckCode::U003],
-            CheckCodePrefix::U004 => vec![CheckCode::U004],
-            CheckCodePrefix::U005 => vec![CheckCode::U005],
-            CheckCodePrefix::U006 => vec![CheckCode::U006],
-            CheckCodePrefix::U007 => vec![CheckCode::U007],
-            CheckCodePrefix::U008 => vec![CheckCode::U008],
-            CheckCodePrefix::U009 => vec![CheckCode::U009],
+            CheckCodePrefix::U001 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U001` has been renamed to `UP001`".bold()
+                );
+                vec![CheckCode::UP001]
+            }
+            CheckCodePrefix::U003 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U003` has been renamed to `UP003`".bold()
+                );
+                vec![CheckCode::UP003]
+            }
+            CheckCodePrefix::U004 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U004` has been renamed to `UP004`".bold()
+                );
+                vec![CheckCode::UP004]
+            }
+            CheckCodePrefix::U005 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U005` has been renamed to `UP005`".bold()
+                );
+                vec![CheckCode::UP005]
+            }
+            CheckCodePrefix::U006 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U006` has been renamed to `UP006`".bold()
+                );
+                vec![CheckCode::UP006]
+            }
+            CheckCodePrefix::U007 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U007` has been renamed to `UP007`".bold()
+                );
+                vec![CheckCode::UP007]
+            }
+            CheckCodePrefix::U008 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U008` has been renamed to `UP008`".bold()
+                );
+                vec![CheckCode::UP008]
+            }
+            CheckCodePrefix::U009 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U009` has been renamed to `UP009`".bold()
+                );
+                vec![CheckCode::UP009]
+            }
             CheckCodePrefix::U01 => vec![
-                CheckCode::U010,
-                CheckCode::U011,
-                CheckCode::U012,
-                CheckCode::U013,
-                CheckCode::U014,
-                CheckCode::U015,
+                CheckCode::UP010,
+                CheckCode::UP011,
+                CheckCode::UP012,
+                CheckCode::UP013,
+                CheckCode::UP014,
+                CheckCode::UP015,
             ],
-            CheckCodePrefix::U010 => vec![CheckCode::U010],
-            CheckCodePrefix::U011 => vec![CheckCode::U011],
-            CheckCodePrefix::U012 => vec![CheckCode::U012],
-            CheckCodePrefix::U013 => vec![CheckCode::U013],
-            CheckCodePrefix::U014 => vec![CheckCode::U014],
-            CheckCodePrefix::U015 => vec![CheckCode::U015],
+            CheckCodePrefix::U010 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U010` has been renamed to `UP010`".bold()
+                );
+                vec![CheckCode::UP010]
+            }
+            CheckCodePrefix::U011 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U011` has been renamed to `UP011`".bold()
+                );
+                vec![CheckCode::UP011]
+            }
+            CheckCodePrefix::U012 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U012` has been renamed to `UP012`".bold()
+                );
+                vec![CheckCode::UP012]
+            }
+            CheckCodePrefix::U013 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U013` has been renamed to `UP013`".bold()
+                );
+                vec![CheckCode::UP013]
+            }
+            CheckCodePrefix::U014 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U014` has been renamed to `UP014`".bold()
+                );
+                vec![CheckCode::UP014]
+            }
+            CheckCodePrefix::U015 => {
+                eprintln!(
+                    "{}{} {}",
+                    "warning".yellow().bold(),
+                    ":".bold(),
+                    "`U015` has been renamed to `UP015`".bold()
+                );
+                vec![CheckCode::UP015]
+            }
+            CheckCodePrefix::UP => vec![
+                CheckCode::UP001,
+                CheckCode::UP003,
+                CheckCode::UP004,
+                CheckCode::UP005,
+                CheckCode::UP006,
+                CheckCode::UP007,
+                CheckCode::UP008,
+                CheckCode::UP009,
+                CheckCode::UP010,
+                CheckCode::UP011,
+                CheckCode::UP012,
+                CheckCode::UP013,
+                CheckCode::UP014,
+                CheckCode::UP015,
+            ],
+            CheckCodePrefix::UP0 => vec![
+                CheckCode::UP001,
+                CheckCode::UP003,
+                CheckCode::UP004,
+                CheckCode::UP005,
+                CheckCode::UP006,
+                CheckCode::UP007,
+                CheckCode::UP008,
+                CheckCode::UP009,
+                CheckCode::UP010,
+                CheckCode::UP011,
+                CheckCode::UP012,
+                CheckCode::UP013,
+                CheckCode::UP014,
+                CheckCode::UP015,
+            ],
+            CheckCodePrefix::UP00 => vec![
+                CheckCode::UP001,
+                CheckCode::UP003,
+                CheckCode::UP004,
+                CheckCode::UP005,
+                CheckCode::UP006,
+                CheckCode::UP007,
+                CheckCode::UP008,
+                CheckCode::UP009,
+            ],
+            CheckCodePrefix::UP001 => vec![CheckCode::UP001],
+            CheckCodePrefix::UP003 => vec![CheckCode::UP003],
+            CheckCodePrefix::UP004 => vec![CheckCode::UP004],
+            CheckCodePrefix::UP005 => vec![CheckCode::UP005],
+            CheckCodePrefix::UP006 => vec![CheckCode::UP006],
+            CheckCodePrefix::UP007 => vec![CheckCode::UP007],
+            CheckCodePrefix::UP008 => vec![CheckCode::UP008],
+            CheckCodePrefix::UP009 => vec![CheckCode::UP009],
+            CheckCodePrefix::UP01 => vec![
+                CheckCode::UP010,
+                CheckCode::UP011,
+                CheckCode::UP012,
+                CheckCode::UP013,
+                CheckCode::UP014,
+                CheckCode::UP015,
+            ],
+            CheckCodePrefix::UP010 => vec![CheckCode::UP010],
+            CheckCodePrefix::UP011 => vec![CheckCode::UP011],
+            CheckCodePrefix::UP012 => vec![CheckCode::UP012],
+            CheckCodePrefix::UP013 => vec![CheckCode::UP013],
+            CheckCodePrefix::UP014 => vec![CheckCode::UP014],
+            CheckCodePrefix::UP015 => vec![CheckCode::UP015],
             CheckCodePrefix::W => vec![CheckCode::W292, CheckCode::W605],
             CheckCodePrefix::W2 => vec![CheckCode::W292],
             CheckCodePrefix::W29 => vec![CheckCode::W292],
@@ -1600,10 +1907,6 @@ impl CheckCodePrefix {
             CheckCodePrefix::I2 => SuffixLength::One,
             CheckCodePrefix::I25 => SuffixLength::Two,
             CheckCodePrefix::I252 => SuffixLength::Three,
-            CheckCodePrefix::M => SuffixLength::Zero,
-            CheckCodePrefix::M0 => SuffixLength::One,
-            CheckCodePrefix::M00 => SuffixLength::Two,
-            CheckCodePrefix::M001 => SuffixLength::Three,
             CheckCodePrefix::N => SuffixLength::Zero,
             CheckCodePrefix::N8 => SuffixLength::One,
             CheckCodePrefix::N80 => SuffixLength::Two,
@@ -1627,11 +1930,43 @@ impl CheckCodePrefix {
             CheckCodePrefix::PGH0 => SuffixLength::One,
             CheckCodePrefix::PGH00 => SuffixLength::Two,
             CheckCodePrefix::PGH001 => SuffixLength::Three,
+            CheckCodePrefix::PLC => SuffixLength::Zero,
+            CheckCodePrefix::PLC0 => SuffixLength::One,
+            CheckCodePrefix::PLC04 => SuffixLength::Two,
+            CheckCodePrefix::PLC041 => SuffixLength::Three,
+            CheckCodePrefix::PLC0414 => SuffixLength::Four,
+            CheckCodePrefix::PLC2 => SuffixLength::One,
+            CheckCodePrefix::PLC22 => SuffixLength::Two,
+            CheckCodePrefix::PLC220 => SuffixLength::Three,
+            CheckCodePrefix::PLC2201 => SuffixLength::Four,
+            CheckCodePrefix::PLC3 => SuffixLength::One,
+            CheckCodePrefix::PLC30 => SuffixLength::Two,
+            CheckCodePrefix::PLC300 => SuffixLength::Three,
+            CheckCodePrefix::PLC3002 => SuffixLength::Four,
             CheckCodePrefix::PLE => SuffixLength::Zero,
             CheckCodePrefix::PLE1 => SuffixLength::One,
             CheckCodePrefix::PLE11 => SuffixLength::Two,
             CheckCodePrefix::PLE114 => SuffixLength::Three,
             CheckCodePrefix::PLE1142 => SuffixLength::Four,
+            CheckCodePrefix::PLR => SuffixLength::Zero,
+            CheckCodePrefix::PLR0 => SuffixLength::One,
+            CheckCodePrefix::PLR02 => SuffixLength::Two,
+            CheckCodePrefix::PLR020 => SuffixLength::Three,
+            CheckCodePrefix::PLR0206 => SuffixLength::Four,
+            CheckCodePrefix::PLR04 => SuffixLength::Two,
+            CheckCodePrefix::PLR040 => SuffixLength::Three,
+            CheckCodePrefix::PLR0402 => SuffixLength::Four,
+            CheckCodePrefix::PLR1 => SuffixLength::One,
+            CheckCodePrefix::PLR17 => SuffixLength::Two,
+            CheckCodePrefix::PLR170 => SuffixLength::Three,
+            CheckCodePrefix::PLR1701 => SuffixLength::Four,
+            CheckCodePrefix::PLR172 => SuffixLength::Three,
+            CheckCodePrefix::PLR1722 => SuffixLength::Four,
+            CheckCodePrefix::PLW => SuffixLength::Zero,
+            CheckCodePrefix::PLW0 => SuffixLength::One,
+            CheckCodePrefix::PLW01 => SuffixLength::Two,
+            CheckCodePrefix::PLW012 => SuffixLength::Three,
+            CheckCodePrefix::PLW0120 => SuffixLength::Four,
             CheckCodePrefix::Q => SuffixLength::Zero,
             CheckCodePrefix::Q0 => SuffixLength::One,
             CheckCodePrefix::Q00 => SuffixLength::Two,
@@ -1639,6 +1974,17 @@ impl CheckCodePrefix {
             CheckCodePrefix::Q001 => SuffixLength::Three,
             CheckCodePrefix::Q002 => SuffixLength::Three,
             CheckCodePrefix::Q003 => SuffixLength::Three,
+            CheckCodePrefix::RET => SuffixLength::Zero,
+            CheckCodePrefix::RET5 => SuffixLength::One,
+            CheckCodePrefix::RET50 => SuffixLength::Two,
+            CheckCodePrefix::RET501 => SuffixLength::Three,
+            CheckCodePrefix::RET502 => SuffixLength::Three,
+            CheckCodePrefix::RET503 => SuffixLength::Three,
+            CheckCodePrefix::RET504 => SuffixLength::Three,
+            CheckCodePrefix::RET505 => SuffixLength::Three,
+            CheckCodePrefix::RET506 => SuffixLength::Three,
+            CheckCodePrefix::RET507 => SuffixLength::Three,
+            CheckCodePrefix::RET508 => SuffixLength::Three,
             CheckCodePrefix::RUF => SuffixLength::Zero,
             CheckCodePrefix::RUF0 => SuffixLength::One,
             CheckCodePrefix::RUF00 => SuffixLength::Two,
@@ -1647,7 +1993,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::RUF003 => SuffixLength::Three,
             CheckCodePrefix::RUF1 => SuffixLength::One,
             CheckCodePrefix::RUF10 => SuffixLength::Two,
-            CheckCodePrefix::RUF101 => SuffixLength::Three,
+            CheckCodePrefix::RUF100 => SuffixLength::Three,
             CheckCodePrefix::S => SuffixLength::Zero,
             CheckCodePrefix::S1 => SuffixLength::One,
             CheckCodePrefix::S10 => SuffixLength::Two,
@@ -1683,6 +2029,24 @@ impl CheckCodePrefix {
             CheckCodePrefix::U013 => SuffixLength::Three,
             CheckCodePrefix::U014 => SuffixLength::Three,
             CheckCodePrefix::U015 => SuffixLength::Three,
+            CheckCodePrefix::UP => SuffixLength::Zero,
+            CheckCodePrefix::UP0 => SuffixLength::One,
+            CheckCodePrefix::UP00 => SuffixLength::Two,
+            CheckCodePrefix::UP001 => SuffixLength::Three,
+            CheckCodePrefix::UP003 => SuffixLength::Three,
+            CheckCodePrefix::UP004 => SuffixLength::Three,
+            CheckCodePrefix::UP005 => SuffixLength::Three,
+            CheckCodePrefix::UP006 => SuffixLength::Three,
+            CheckCodePrefix::UP007 => SuffixLength::Three,
+            CheckCodePrefix::UP008 => SuffixLength::Three,
+            CheckCodePrefix::UP009 => SuffixLength::Three,
+            CheckCodePrefix::UP01 => SuffixLength::Two,
+            CheckCodePrefix::UP010 => SuffixLength::Three,
+            CheckCodePrefix::UP011 => SuffixLength::Three,
+            CheckCodePrefix::UP012 => SuffixLength::Three,
+            CheckCodePrefix::UP013 => SuffixLength::Three,
+            CheckCodePrefix::UP014 => SuffixLength::Three,
+            CheckCodePrefix::UP015 => SuffixLength::Three,
             CheckCodePrefix::W => SuffixLength::Zero,
             CheckCodePrefix::W2 => SuffixLength::One,
             CheckCodePrefix::W29 => SuffixLength::Two,
@@ -1723,15 +2087,19 @@ pub const CATEGORIES: &[CheckCodePrefix] = &[
     CheckCodePrefix::F,
     CheckCodePrefix::FBT,
     CheckCodePrefix::I,
-    CheckCodePrefix::M,
     CheckCodePrefix::N,
     CheckCodePrefix::PGH,
+    CheckCodePrefix::PLC,
     CheckCodePrefix::PLE,
+    CheckCodePrefix::PLR,
+    CheckCodePrefix::PLW,
     CheckCodePrefix::Q,
+    CheckCodePrefix::RET,
     CheckCodePrefix::RUF,
     CheckCodePrefix::S,
     CheckCodePrefix::T,
     CheckCodePrefix::U,
+    CheckCodePrefix::UP,
     CheckCodePrefix::W,
     CheckCodePrefix::YTT,
 ];

src/flake8_annotations/plugins.rs

@@ -211,7 +211,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
                 .chain(args.kwonlyargs.iter())
                 .skip(
                     // If this is a non-static method, skip `cls` or `self`.
-                    usize::from(!visibility::is_staticmethod(stmt)),
+                    usize::from(!visibility::is_staticmethod(checker, stmt)),
                 )
             {
                 // ANN401 for dynamically typed arguments
@@ -283,10 +283,10 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
             }
 
             // ANN101, ANN102
-            if !visibility::is_staticmethod(stmt) {
+            if !visibility::is_staticmethod(checker, stmt) {
                 if let Some(arg) = args.args.first() {
                     if arg.node.annotation.is_none() {
-                        if visibility::is_classmethod(stmt) {
+                        if visibility::is_classmethod(checker, stmt) {
                             if checker.settings.enabled.contains(&CheckCode::ANN102) {
                                 checker.add_check(Check::new(
                                     CheckKind::MissingTypeCls(arg.node.arg.to_string()),
@@ -319,14 +319,14 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
                     return;
                 }
 
-                if visibility::is_classmethod(stmt) {
+                if visibility::is_classmethod(checker, stmt) {
                     if checker.settings.enabled.contains(&CheckCode::ANN206) {
                         checker.add_check(Check::new(
                             CheckKind::MissingReturnTypeClassMethod(name.to_string()),
                             Range::from_located(stmt),
                         ));
                     }
-                } else if visibility::is_staticmethod(stmt) {
+                } else if visibility::is_staticmethod(checker, stmt) {
                     if checker.settings.enabled.contains(&CheckCode::ANN205) {
                         checker.add_check(Check::new(
                             CheckKind::MissingReturnTypeStaticMethod(name.to_string()),

src/flake8_bugbear/plugins/assert_raises_exception.rs

@@ -1,6 +1,6 @@
 use rustpython_ast::{ExprKind, Stmt, Withitem};
 
-use crate::ast::helpers::match_name_or_attr;
+use crate::ast::helpers::match_module_member;
 use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
@@ -12,8 +12,14 @@ pub fn assert_raises_exception(checker: &mut Checker, stmt: &Stmt, items: &[With
         if let ExprKind::Call { func, args, .. } = &item_context.node {
             if args.len() == 1
                 && item.optional_vars.is_none()
-                && match_name_or_attr(func, "assertRaises")
-                && match_name_or_attr(args.first().unwrap(), "Exception")
+                && matches!(&func.node, ExprKind::Attribute { attr, .. } if attr == "assertRaises")
+                && match_module_member(
+                    args.first().unwrap(),
+                    "",
+                    "Exception",
+                    &checker.from_imports,
+                    &checker.import_aliases,
+                )
             {
                 checker.add_check(Check::new(
                     CheckKind::NoAssertRaisesException,

src/flake8_debugger/checks.rs

@@ -41,6 +41,12 @@ pub fn debugger_call(
 
 /// Checks for the presence of a debugger import.
 pub fn debugger_import(stmt: &Stmt, module: Option<&str>, name: &str) -> Option<Check> {
+    // Special-case: allow `import builtins`, which is far more general than (e.g.)
+    // `import celery.contrib.rdb`).
+    if module.is_none() && name == "builtins" {
+        return None;
+    }
+
     if let Some(module) = module {
         if let Some((module_name, member)) = DEBUGGERS
             .iter()

src/flake8_print/snapshots/ruff__flake8_print__tests__T100_T100.py.snap

@@ -26,70 +26,70 @@ expression: checks
     Debugger:
       Import: builtins.breakpoint
   location:
-    row: 5
+    row: 6
     column: 0
   end_location:
-    row: 5
+    row: 6
     column: 31
   fix: ~
 - kind:
     Debugger:
       Import: pdb.set_trace
   location:
-    row: 6
+    row: 7
     column: 0
   end_location:
-    row: 6
+    row: 7
     column: 31
   fix: ~
 - kind:
     Debugger:
       Import: celery.contrib.rdb.set_trace
   location:
-    row: 7
+    row: 8
     column: 0
   end_location:
-    row: 7
+    row: 8
     column: 40
   fix: ~
 - kind:
     Debugger:
       Import: celery.contrib.rdb
   location:
-    row: 9
+    row: 10
     column: 0
   end_location:
-    row: 9
+    row: 10
     column: 25
   fix: ~
 - kind:
     Debugger:
       Call: breakpoint
   location:
-    row: 12
+    row: 13
     column: 0
   end_location:
-    row: 12
+    row: 13
     column: 12
   fix: ~
 - kind:
     Debugger:
       Call: set_trace
   location:
-    row: 13
+    row: 14
     column: 0
   end_location:
-    row: 13
+    row: 14
     column: 4
   fix: ~
 - kind:
     Debugger:
       Call: set_trace
   location:
-    row: 14
+    row: 15
     column: 0
   end_location:
-    row: 14
+    row: 15
     column: 11
   fix: ~
 

src/flake8_return/helpers.rs

@@ -0,0 +1,18 @@
+use rustpython_ast::{Constant, Expr, ExprKind, Stmt};
+
+/// Return `true` if a function's return statement include at least one
+/// non-`None` value.
+pub fn result_exists(returns: &[(&Stmt, Option<&Expr>)]) -> bool {
+    returns.iter().any(|(_, expr)| {
+        expr.map(|expr| {
+            !matches!(
+                expr.node,
+                ExprKind::Constant {
+                    value: Constant::None,
+                    ..
+                }
+            )
+        })
+        .unwrap_or(false)
+    })
+}

src/flake8_return/mod.rs

@@ -0,0 +1,37 @@
+mod helpers;
+pub mod plugins;
+mod visitor;
+
+#[cfg(test)]
+mod tests {
+    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::RET501, Path::new("RET501.py"); "RET501")]
+    #[test_case(CheckCode::RET502, Path::new("RET502.py"); "RET502")]
+    #[test_case(CheckCode::RET503, Path::new("RET503.py"); "RET503")]
+    #[test_case(CheckCode::RET504, Path::new("RET504.py"); "RET504")]
+    #[test_case(CheckCode::RET505, Path::new("RET505.py"); "RET505")]
+    #[test_case(CheckCode::RET506, Path::new("RET506.py"); "RET506")]
+    #[test_case(CheckCode::RET507, Path::new("RET507.py"); "RET507")]
+    #[test_case(CheckCode::RET508, Path::new("RET508.py"); "RET508")]
+    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_return")
+                .join(path)
+                .as_path(),
+            &Settings::for_rule(check_code),
+            true,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
+}

src/flake8_return/plugins.rs

@@ -0,0 +1,343 @@
+use itertools::Itertools;
+use rustpython_ast::{Constant, Expr, ExprKind, Location, Stmt, StmtKind};
+
+use crate::ast::types::Range;
+use crate::ast::visitor::Visitor;
+use crate::ast::whitespace::indentation;
+use crate::autofix::Fix;
+use crate::check_ast::Checker;
+use crate::checks::{Branch, CheckCode, CheckKind};
+use crate::flake8_return::helpers::result_exists;
+use crate::flake8_return::visitor::{ReturnVisitor, Stack};
+use crate::Check;
+
+/// RET501
+fn unnecessary_return_none(checker: &mut Checker, stack: &Stack) {
+    for (stmt, expr) in &stack.returns {
+        if let Some(expr) = expr {
+            if matches!(
+                expr.node,
+                ExprKind::Constant {
+                    value: Constant::None,
+                    ..
+                }
+            ) {
+                let mut check =
+                    Check::new(CheckKind::UnnecessaryReturnNone, Range::from_located(stmt));
+                if checker.patch(&CheckCode::RET501) {
+                    check.amend(Fix::replacement(
+                        "return".to_string(),
+                        stmt.location,
+                        stmt.end_location.unwrap(),
+                    ));
+                }
+                checker.add_check(check);
+            }
+        }
+    }
+}
+
+/// RET502
+fn implicit_return_value(checker: &mut Checker, stack: &Stack) {
+    for (stmt, expr) in &stack.returns {
+        if expr.is_none() {
+            let mut check = Check::new(CheckKind::ImplicitReturnValue, Range::from_located(stmt));
+            if checker.patch(&CheckCode::RET502) {
+                check.amend(Fix::replacement(
+                    "return None".to_string(),
+                    stmt.location,
+                    stmt.end_location.unwrap(),
+                ));
+            }
+            checker.add_check(check);
+        }
+    }
+}
+
+/// RET503
+fn implicit_return(checker: &mut Checker, last_stmt: &Stmt) {
+    match &last_stmt.node {
+        StmtKind::If { body, orelse, .. } => {
+            if body.is_empty() || orelse.is_empty() {
+                checker.add_check(Check::new(
+                    CheckKind::ImplicitReturn,
+                    Range::from_located(last_stmt),
+                ));
+                return;
+            }
+
+            if let Some(last_stmt) = body.last() {
+                implicit_return(checker, last_stmt);
+            }
+            if let Some(last_stmt) = orelse.last() {
+                implicit_return(checker, last_stmt);
+            }
+        }
+        StmtKind::For { body, orelse, .. } | StmtKind::AsyncFor { body, orelse, .. } => {
+            if let Some(last_stmt) = orelse.last() {
+                implicit_return(checker, last_stmt);
+            } else if let Some(last_stmt) = body.last() {
+                implicit_return(checker, last_stmt);
+            }
+        }
+        StmtKind::With { body, .. } | StmtKind::AsyncWith { body, .. } => {
+            if let Some(last_stmt) = body.last() {
+                implicit_return(checker, last_stmt);
+            }
+        }
+        StmtKind::Assert { test, .. }
+            if matches!(
+                test.node,
+                ExprKind::Constant {
+                    value: Constant::Bool(false),
+                    ..
+                }
+            ) => {}
+        StmtKind::Return { .. }
+        | StmtKind::While { .. }
+        | StmtKind::Raise { .. }
+        | StmtKind::Try { .. } => {}
+        _ => {
+            let mut check = Check::new(CheckKind::ImplicitReturn, Range::from_located(last_stmt));
+            if checker.patch(&CheckCode::RET503) {
+                let mut content = String::new();
+                content.push_str(&indentation(checker, last_stmt));
+                content.push_str("return None");
+                content.push('\n');
+                check.amend(Fix::insertion(
+                    content,
+                    Location::new(last_stmt.end_location.unwrap().row() + 1, 0),
+                ));
+            }
+            checker.add_check(check);
+        }
+    }
+}
+
+fn has_refs_before_next_assign(id: &str, return_location: Location, stack: &Stack) -> bool {
+    let mut before_assign: &Location = &Location::default();
+    let mut after_assign: Option<&Location> = None;
+    if let Some(assigns) = stack.assigns.get(&id) {
+        for location in assigns.iter().sorted() {
+            if location.row() > return_location.row() {
+                after_assign = Some(location);
+                break;
+            }
+            if location.row() <= return_location.row() {
+                before_assign = location;
+            }
+        }
+    }
+
+    if let Some(refs) = stack.refs.get(&id) {
+        for location in refs {
+            if location.row() == return_location.row() {
+                continue;
+            }
+            if let Some(after_assign) = after_assign {
+                if before_assign.row() < location.row() && location.row() <= after_assign.row() {
+                    return true;
+                }
+            } else if before_assign.row() < location.row() {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn has_refs_or_assigns_within_try_or_loop(id: &str, stack: &Stack) -> bool {
+    if let Some(refs) = stack.refs.get(&id) {
+        for location in refs {
+            for (try_location, try_end_location) in &stack.tries {
+                if try_location.row() < location.row() && location.row() <= try_end_location.row() {
+                    return true;
+                }
+            }
+            for (loop_location, loop_end_location) in &stack.loops {
+                if loop_location.row() < location.row() && location.row() <= loop_end_location.row()
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    if let Some(refs) = stack.assigns.get(&id) {
+        for location in refs {
+            for (try_location, try_end_location) in &stack.tries {
+                if try_location.row() < location.row() && location.row() <= try_end_location.row() {
+                    return true;
+                }
+            }
+            for (loop_location, loop_end_location) in &stack.loops {
+                if loop_location.row() < location.row() && location.row() <= loop_end_location.row()
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}
+
+/// RET504
+fn unnecessary_assign(checker: &mut Checker, stack: &Stack, expr: &Expr) {
+    if let ExprKind::Name { id, .. } = &expr.node {
+        if !stack.assigns.contains_key(id.as_str()) {
+            return;
+        }
+
+        if !stack.refs.contains_key(id.as_str()) {
+            checker.add_check(Check::new(
+                CheckKind::UnnecessaryAssign,
+                Range::from_located(expr),
+            ));
+            return;
+        }
+
+        if has_refs_before_next_assign(id, expr.location, stack)
+            || has_refs_or_assigns_within_try_or_loop(id, stack)
+        {
+            return;
+        }
+
+        checker.add_check(Check::new(
+            CheckKind::UnnecessaryAssign,
+            Range::from_located(expr),
+        ));
+    }
+}
+
+/// RET505, RET506, RET507, RET508
+fn superfluous_else_node(checker: &mut Checker, stmt: &Stmt, branch: Branch) -> bool {
+    if let StmtKind::If { body, .. } = &stmt.node {
+        for child in body {
+            if matches!(child.node, StmtKind::Return { .. }) {
+                if checker.settings.enabled.contains(&CheckCode::RET505) {
+                    checker.add_check(Check::new(
+                        CheckKind::SuperfluousElseReturn(branch),
+                        Range::from_located(stmt),
+                    ));
+                }
+                return true;
+            }
+            if matches!(child.node, StmtKind::Break) {
+                if checker.settings.enabled.contains(&CheckCode::RET508) {
+                    checker.add_check(Check::new(
+                        CheckKind::SuperfluousElseBreak(branch),
+                        Range::from_located(stmt),
+                    ));
+                }
+                return true;
+            }
+            if matches!(child.node, StmtKind::Raise { .. }) {
+                if checker.settings.enabled.contains(&CheckCode::RET506) {
+                    checker.add_check(Check::new(
+                        CheckKind::SuperfluousElseRaise(branch),
+                        Range::from_located(stmt),
+                    ));
+                }
+                return true;
+            }
+            if matches!(child.node, StmtKind::Continue) {
+                if checker.settings.enabled.contains(&CheckCode::RET507) {
+                    checker.add_check(Check::new(
+                        CheckKind::SuperfluousElseContinue(branch),
+                        Range::from_located(stmt),
+                    ));
+                }
+                return true;
+            }
+        }
+    }
+    false
+}
+
+/// RET505, RET506, RET507, RET508
+fn superfluous_elif(checker: &mut Checker, stack: &Stack) -> bool {
+    for stmt in &stack.elifs {
+        if superfluous_else_node(checker, stmt, Branch::Elif) {
+            return true;
+        }
+    }
+    false
+}
+
+/// RET505, RET506, RET507, RET508
+fn superfluous_else(checker: &mut Checker, stack: &Stack) -> bool {
+    for stmt in &stack.ifs {
+        if let StmtKind::If { orelse, .. } = &stmt.node {
+            if !orelse.is_empty() {
+                if superfluous_else_node(checker, stmt, Branch::Else) {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}
+
+/// Run all checks from the `flake8-return` plugin.
+pub fn function(checker: &mut Checker, body: &[Stmt]) {
+    // Skip empty functions.
+    if body.is_empty() {
+        return;
+    }
+
+    // Find the last statement in the function.
+    let last_stmt = body.last().unwrap();
+
+    // Skip functions that consist of a single return statement.
+    if body.len() == 1 && matches!(last_stmt.node, StmtKind::Return { .. }) {
+        return;
+    }
+
+    // Traverse the function body, to collect the stack.
+    let stack = {
+        let mut visitor = ReturnVisitor::default();
+        for stmt in body {
+            visitor.visit_stmt(stmt);
+        }
+        visitor.stack
+    };
+
+    if checker.settings.enabled.contains(&CheckCode::RET505)
+        || checker.settings.enabled.contains(&CheckCode::RET506)
+        || checker.settings.enabled.contains(&CheckCode::RET507)
+        || checker.settings.enabled.contains(&CheckCode::RET508)
+    {
+        if superfluous_elif(checker, &stack) {
+            return;
+        }
+        if superfluous_else(checker, &stack) {
+            return;
+        }
+    }
+
+    // Skip any functions without return statements.
+    if stack.returns.is_empty() {
+        return;
+    }
+
+    if !result_exists(&stack.returns) {
+        if checker.settings.enabled.contains(&CheckCode::RET501) {
+            unnecessary_return_none(checker, &stack);
+        }
+        return;
+    }
+
+    if checker.settings.enabled.contains(&CheckCode::RET502) {
+        implicit_return_value(checker, &stack);
+    }
+    if checker.settings.enabled.contains(&CheckCode::RET503) {
+        implicit_return(checker, last_stmt);
+    }
+
+    if checker.settings.enabled.contains(&CheckCode::RET504) {
+        for (_, expr) in &stack.returns {
+            if let Some(expr) = expr {
+                unnecessary_assign(checker, &stack, expr);
+            }
+        }
+    }
+}

src/flake8_return/snapshots/ruff__flake8_return__tests__RET501_RET501.py.snap

@@ -0,0 +1,20 @@
+---
+source: src/flake8_return/mod.rs
+expression: checks
+---
+- kind: UnnecessaryReturnNone
+  location:
+    row: 4
+    column: 4
+  end_location:
+    row: 4
+    column: 15
+  fix:
+    content: return
+    location:
+      row: 4
+      column: 4
+    end_location:
+      row: 4
+      column: 15
+

src/flake8_return/snapshots/ruff__flake8_return__tests__RET502_RET502.py.snap

@@ -0,0 +1,20 @@
+---
+source: src/flake8_return/mod.rs
+expression: checks
+---
+- kind: ImplicitReturnValue
+  location:
+    row: 3
+    column: 8
+  end_location:
+    row: 3
+    column: 14
+  fix:
+    content: return None
+    location:
+      row: 3
+      column: 8
+    end_location:
+      row: 3
+      column: 14
+

src/flake8_return/snapshots/ruff__flake8_return__tests__RET503_RET503.py.snap

@@ -0,0 +1,66 @@
+---
+source: src/flake8_return/mod.rs
+expression: checks
+---
+- kind: ImplicitReturn
+  location:
+    row: 7
+    column: 4
+  end_location:
+    row: 12
+    column: 0
+  fix: ~
+- kind: ImplicitReturn
+  location:
+    row: 14
+    column: 8
+  end_location:
+    row: 14
+    column: 15
+  fix:
+    content: "        return None\n"
+    location:
+      row: 15
+      column: 0
+    end_location:
+      row: 15
+      column: 0
+- kind: ImplicitReturn
+  location:
+    row: 23
+    column: 4
+  end_location:
+    row: 23
+    column: 11
+  fix:
+    content: "    return None\n"
+    location:
+      row: 24
+      column: 0
+    end_location:
+      row: 24
+      column: 0
+- kind: ImplicitReturn
+  location:
+    row: 29
+    column: 8
+  end_location:
+    row: 34
+    column: 0
+  fix: ~
+- kind: ImplicitReturn
+  location:
+    row: 39
+    column: 8
+  end_location:
+    row: 39
+    column: 15
+  fix:
+    content: "        return None\n"
+    location:
+      row: 40
+      column: 0
+    end_location:
+      row: 40
+      column: 0
+

src/flake8_return/snapshots/ruff__flake8_return__tests__RET504_RET504.py.snap

@@ -0,0 +1,61 @@
+---
+source: src/flake8_return/mod.rs
+expression: checks
+---
+- kind: UnnecessaryAssign
+  location:
+    row: 6
+    column: 11
+  end_location:
+    row: 6
+    column: 12
+  fix: ~
+- kind: UnnecessaryAssign
+  location:
+    row: 12
+    column: 11
+  end_location:
+    row: 12
+    column: 12
+  fix: ~
+- kind: UnnecessaryAssign
+  location:
+    row: 18
+    column: 11
+  end_location:
+    row: 18
+    column: 12
+  fix: ~
+- kind: UnnecessaryAssign
+  location:
+    row: 25
+    column: 11
+  end_location:
+    row: 25
+    column: 12
+  fix: ~
+- kind: UnnecessaryAssign
+  location:
+    row: 31
+    column: 15
+  end_location:
+    row: 31
+    column: 16
+  fix: ~
+- kind: UnnecessaryAssign
+  location:
+    row: 43
+    column: 11
+  end_location:
+    row: 43
+    column: 17
+  fix: ~
+- kind: UnnecessaryAssign
+  location:
+    row: 51
+    column: 11
+  end_location:
+    row: 51
+    column: 20
+  fix: ~
+

src/flake8_return/snapshots/ruff__flake8_return__tests__RET505_RET505.py.snap

@@ -0,0 +1,77 @@
+---
+source: src/flake8_return/mod.rs
+expression: checks
+---
+- kind:
+    SuperfluousElseReturn: Elif
+  location:
+    row: 5
+    column: 4
+  end_location:
+    row: 16
+    column: 0
+  fix: ~
+- kind:
+    SuperfluousElseReturn: Elif
+  location:
+    row: 17
+    column: 4
+  end_location:
+    row: 27
+    column: 4
+  fix: ~
+- kind:
+    SuperfluousElseReturn: Elif
+  location:
+    row: 38
+    column: 4
+  end_location:
+    row: 49
+    column: 0
+  fix: ~
+- kind:
+    SuperfluousElseReturn: Else
+  location:
+    row: 50
+    column: 4
+  end_location:
+    row: 58
+    column: 0
+  fix: ~
+- kind:
+    SuperfluousElseReturn: Else
+  location:
+    row: 61
+    column: 8
+  end_location:
+    row: 67
+    column: 4
+  fix: ~
+- kind:
+    SuperfluousElseReturn: Else
+  location:
+    row: 73
+    column: 4
+  end_location:
+    row: 81
+    column: 4
+  fix: ~
+- kind:
+    SuperfluousElseReturn: Else
+  location:
+    row: 86
+    column: 8
+  end_location:
+    row: 91
+    column: 4
+  fix: ~
+- kind:
+    SuperfluousElseReturn: Else
+  location:
+    row: 97
+    column: 4
+  end_location:
+    row: 109
+    column: 0
+  fix: ~
+

src/flake8_return/snapshots/ruff__flake8_return__tests__RET506_RET506.py.snap

@@ -0,0 +1,68 @@
+---
+source: src/flake8_return/mod.rs
+expression: checks
+---
+- kind:
+    SuperfluousElseRaise: Elif
+  location:
+    row: 5
+    column: 4
+  end_location:
+    row: 16
+    column: 0
+  fix: ~
+- kind:
+    SuperfluousElseRaise: Elif
+  location:
+    row: 17
+    column: 4
+  end_location:
+    row: 27
+    column: 4
+  fix: ~
+- kind:
+    SuperfluousElseRaise: Else
+  location:
+    row: 31
+    column: 4
+  end_location:
+    row: 39
+    column: 0
+  fix: ~
+- kind:
+    SuperfluousElseRaise: Else
+  location:
+    row: 42
+    column: 8
+  end_location:
+    row: 48
+    column: 4
+  fix: ~
+- kind:
+    SuperfluousElseRaise: Else
+  location:
+    row: 54
+    column: 4
+  end_location:
+    row: 62
+    column: 4
+  fix: ~
+- kind:
+    SuperfluousElseRaise: Else
+  location:
+    row: 67
+    column: 8
+  end_location:
+    row: 72
+    column: 4
+  fix: ~
+- kind:
+    SuperfluousElseRaise: Else
+  location:
+    row: 78
+    column: 4
+  end_location:
+    row: 90
+    column: 0
+  fix: ~
+

src/flake8_return/snapshots/ruff__flake8_return__tests__RET507_RET507.py.snap

@@ -0,0 +1,68 @@
+---
+source: src/flake8_return/mod.rs
+expression: checks
+---
+- kind:
+    SuperfluousElseContinue: Elif
+  location:
+    row: 6
+    column: 8
+  end_location:
+    row: 14
+    column: 0
+  fix: ~
+- kind:
+    SuperfluousElseContinue: Elif
+  location:
+    row: 16
+    column: 8
+  end_location:
+    row: 26
+    column: 8
+  fix: ~
+- kind:
+    SuperfluousElseContinue: Else
+  location:
+    row: 34
+    column: 8
+  end_location:
+    row: 40
+    column: 0
+  fix: ~
+- kind:
+    SuperfluousElseContinue: Else
+  location:
+    row: 44
+    column: 12
+  end_location:
+    row: 50
+    column: 8
+  fix: ~
+- kind:
+    SuperfluousElseContinue: Else
+  location:
+    row: 57
+    column: 8
+  end_location:
+    row: 65
+    column: 8
+  fix: ~
+- kind:
+    SuperfluousElseContinue: Else
+  location:
+    row: 71
+    column: 12
+  end_location:
+    row: 76
+    column: 8
+  fix: ~
+- kind:
+    SuperfluousElseContinue: Else
+  location:
+    row: 83
+    column: 8
+  end_location:
+    row: 92
+    column: 0
+  fix: ~
+

src/flake8_return/snapshots/ruff__flake8_return__tests__RET508_RET508.py.snap

@@ -0,0 +1,68 @@
+---
+source: src/flake8_return/mod.rs
+expression: checks
+---
+- kind:
+    SuperfluousElseBreak: Elif
+  location:
+    row: 6
+    column: 8
+  end_location:
+    row: 14
+    column: 0
+  fix: ~
+- kind:
+    SuperfluousElseBreak: Elif
+  location:
+    row: 16
+    column: 8
+  end_location:
+    row: 26
+    column: 8
+  fix: ~
+- kind:
+    SuperfluousElseBreak: Else
+  location:
+    row: 31
+    column: 8
+  end_location:
+    row: 37
+    column: 0
+  fix: ~
+- kind:
+    SuperfluousElseBreak: Else
+  location:
+    row: 41
+    column: 12
+  end_location:
+    row: 47
+    column: 8
+  fix: ~
+- kind:
+    SuperfluousElseBreak: Else
+  location:
+    row: 54
+    column: 8
+  end_location:
+    row: 62
+    column: 8
+  fix: ~
+- kind:
+    SuperfluousElseBreak: Else
+  location:
+    row: 68
+    column: 12
+  end_location:
+    row: 73
+    column: 8
+  fix: ~
+- kind:
+    SuperfluousElseBreak: Else
+  location:
+    row: 80
+    column: 8
+  end_location:
+    row: 92
+    column: 0
+  fix: ~
+

src/flake8_return/visitor.rs

@@ -0,0 +1,119 @@
+use rustc_hash::FxHashMap;
+use rustpython_ast::{Expr, ExprKind, Location, Stmt, StmtKind};
+
+use crate::ast::visitor;
+use crate::ast::visitor::Visitor;
+
+#[derive(Default)]
+pub struct Stack<'a> {
+    pub returns: Vec<(&'a Stmt, Option<&'a Expr>)>,
+    pub ifs: Vec<&'a Stmt>,
+    pub elifs: Vec<&'a Stmt>,
+    pub refs: FxHashMap<&'a str, Vec<Location>>,
+    pub assigns: FxHashMap<&'a str, Vec<Location>>,
+    pub loops: Vec<(Location, Location)>,
+    pub tries: Vec<(Location, Location)>,
+}
+
+#[derive(Default)]
+pub struct ReturnVisitor<'a> {
+    pub stack: Stack<'a>,
+}
+
+impl<'a> ReturnVisitor<'a> {
+    fn visit_assign_target(&mut self, expr: &'a Expr) {
+        match &expr.node {
+            ExprKind::Tuple { elts, .. } => {
+                for elt in elts {
+                    self.visit_assign_target(elt);
+                }
+                return;
+            }
+            ExprKind::Name { id, .. } => {
+                self.stack
+                    .assigns
+                    .entry(id)
+                    .or_insert_with(Vec::new)
+                    .push(expr.location);
+                return;
+            }
+            _ => {}
+        }
+        visitor::walk_expr(self, expr);
+    }
+}
+
+impl<'a> Visitor<'a> for ReturnVisitor<'a> {
+    fn visit_stmt(&mut self, stmt: &'a Stmt) {
+        match &stmt.node {
+            StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
+                // Don't recurse.
+            }
+            StmtKind::Return { value } => {
+                self.stack
+                    .returns
+                    .push((stmt, value.as_ref().map(|expr| &**expr)));
+                visitor::walk_stmt(self, stmt);
+            }
+            StmtKind::If { orelse, .. } => {
+                if orelse.len() == 1 && matches!(orelse.first().unwrap().node, StmtKind::If { .. })
+                {
+                    self.stack.elifs.push(stmt);
+                } else {
+                    self.stack.ifs.push(stmt);
+                }
+                visitor::walk_stmt(self, stmt);
+            }
+            StmtKind::Assign { targets, value, .. } => {
+                if let ExprKind::Name { id, .. } = &value.node {
+                    self.stack
+                        .refs
+                        .entry(id)
+                        .or_insert_with(Vec::new)
+                        .push(value.location);
+                }
+
+                visitor::walk_expr(self, value);
+
+                if let Some(target) = targets.first() {
+                    // Skip unpacking assignments, like `x, y = my_object`.
+                    if matches!(target.node, ExprKind::Tuple { .. })
+                        && !matches!(value.node, ExprKind::Tuple { .. })
+                    {
+                        return;
+                    }
+
+                    self.visit_assign_target(target);
+                }
+            }
+            StmtKind::For { .. } | StmtKind::AsyncFor { .. } | StmtKind::While { .. } => {
+                self.stack
+                    .loops
+                    .push((stmt.location, stmt.end_location.unwrap()));
+                visitor::walk_stmt(self, stmt);
+            }
+            StmtKind::Try { .. } => {
+                self.stack
+                    .tries
+                    .push((stmt.location, stmt.end_location.unwrap()));
+                visitor::walk_stmt(self, stmt);
+            }
+            _ => {
+                visitor::walk_stmt(self, stmt);
+            }
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &'a Expr) {
+        match &expr.node {
+            ExprKind::Name { id, .. } => {
+                self.stack
+                    .refs
+                    .entry(id)
+                    .or_insert_with(Vec::new)
+                    .push(expr.location);
+            }
+            _ => visitor::walk_expr(self, expr),
+        }
+    }
+}

src/isort/mod.rs

@@ -145,7 +145,7 @@ fn annotate_imports<'a>(
     annotated
 }
 
-fn normalize_imports(imports: Vec<AnnotatedImport>) -> ImportBlock {
+fn normalize_imports(imports: Vec<AnnotatedImport>, combine_as_imports: bool) -> ImportBlock {
     let mut block = ImportBlock::default();
     for import in imports {
         match import {
@@ -191,7 +191,7 @@ fn normalize_imports(imports: Vec<AnnotatedImport>) -> ImportBlock {
             } => {
                 // Associate the comments with the first alias (best effort).
                 if let Some(alias) = names.first() {
-                    if alias.asname.is_none() {
+                    if alias.asname.is_none() || combine_as_imports {
                         let entry = &mut block
                             .import_from
                             .entry(ImportFromData { module, level })
@@ -225,7 +225,7 @@ fn normalize_imports(imports: Vec<AnnotatedImport>) -> ImportBlock {
 
                 // Create an entry for every alias.
                 for alias in names {
-                    if alias.asname.is_none() {
+                    if alias.asname.is_none() || combine_as_imports {
                         let entry = block
                             .import_from
                             .entry(ImportFromData { module, level })
@@ -397,6 +397,7 @@ fn sort_imports(block: ImportBlock) -> OrderedImportBlock {
     ordered
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn format_imports(
     block: &[&Stmt],
     comments: Vec<Comment>,
@@ -405,11 +406,12 @@ pub fn format_imports(
     known_first_party: &BTreeSet<String>,
     known_third_party: &BTreeSet<String>,
     extra_standard_library: &BTreeSet<String>,
+    combine_as_imports: bool,
 ) -> String {
     let block = annotate_imports(block, comments);
 
     // Normalize imports (i.e., deduplicate, aggregate `from` imports).
-    let block = normalize_imports(block);
+    let block = normalize_imports(block, combine_as_imports);
 
     // Categorize by type (e.g., first-party vs. third-party).
     let block_by_type = categorize_imports(
@@ -466,9 +468,10 @@ mod tests {
 
     use crate::checks::CheckCode;
     use crate::linter::test_path;
-    use crate::Settings;
+    use crate::{isort, Settings};
 
     #[test_case(Path::new("add_newline_before_comments.py"))]
+    #[test_case(Path::new("combine_as_imports.py"))]
     #[test_case(Path::new("combine_import_froms.py"))]
     #[test_case(Path::new("comments.py"))]
     #[test_case(Path::new("deduplicate_imports.py"))]
@@ -490,7 +493,7 @@ mod tests {
     #[test_case(Path::new("sort_similar_imports.py"))]
     #[test_case(Path::new("trailing_suffix.py"))]
     #[test_case(Path::new("type_comments.py"))]
-    fn isort(path: &Path) -> Result<()> {
+    fn default(path: &Path) -> Result<()> {
         let snapshot = format!("{}", path.to_string_lossy());
         let mut checks = test_path(
             Path::new("./resources/test/fixtures/isort")
@@ -506,4 +509,26 @@ mod tests {
         insta::assert_yaml_snapshot!(snapshot, checks);
         Ok(())
     }
+
+    #[test_case(Path::new("combine_as_imports.py"))]
+    fn combine_as_imports(path: &Path) -> Result<()> {
+        let snapshot = format!("combine_as_imports_{}", path.to_string_lossy());
+        let mut checks = test_path(
+            Path::new("./resources/test/fixtures/isort")
+                .join(path)
+                .as_path(),
+            &Settings {
+                isort: isort::settings::Settings {
+                    combine_as_imports: true,
+                    ..isort::settings::Settings::default()
+                },
+                src: vec![Path::new("resources/test/fixtures/isort").to_path_buf()],
+                ..Settings::for_rule(CheckCode::I001)
+            },
+            true,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(snapshot, checks);
+        Ok(())
+    }
 }

src/isort/plugins.rs

@@ -60,6 +60,7 @@ pub fn check_imports(
         &settings.isort.known_first_party,
         &settings.isort.known_third_party,
         &settings.isort.extra_standard_library,
+        settings.isort.combine_as_imports,
     );
 
     if has_leading_content || has_trailing_content {

src/isort/settings.rs

@@ -7,6 +7,7 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
 pub struct Options {
+    pub combine_as_imports: Option<bool>,
     pub known_first_party: Option<Vec<String>>,
     pub known_third_party: Option<Vec<String>>,
     pub extra_standard_library: Option<Vec<String>>,
@@ -14,6 +15,7 @@ pub struct Options {
 
 #[derive(Debug, Hash, Default)]
 pub struct Settings {
+    pub combine_as_imports: bool,
     pub known_first_party: BTreeSet<String>,
     pub known_third_party: BTreeSet<String>,
     pub extra_standard_library: BTreeSet<String>,
@@ -22,6 +24,7 @@ pub struct Settings {
 impl Settings {
     pub fn from_options(options: Options) -> Self {
         Self {
+            combine_as_imports: options.combine_as_imports.unwrap_or_default(),
             known_first_party: BTreeSet::from_iter(options.known_first_party.unwrap_or_default()),
             known_third_party: BTreeSet::from_iter(options.known_third_party.unwrap_or_default()),
             extra_standard_library: BTreeSet::from_iter(

src/isort/snapshots/ruff__isort__tests__combine_as_imports.py.snap

@@ -0,0 +1,20 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+- kind: UnsortedImports
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 5
+    column: 0
+  fix:
+    content: "from module import CONSTANT, function\nfrom module import Class as C\nfrom module import function as f\n"
+    location:
+      row: 1
+      column: 0
+    end_location:
+      row: 5
+      column: 0
+

src/isort/snapshots/ruff__isort__tests__combine_as_imports_combine_as_imports.py.snap

@@ -0,0 +1,20 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+- kind: UnsortedImports
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 5
+    column: 0
+  fix:
+    content: "from module import CONSTANT, Class as C, function, function as f\n"
+    location:
+      row: 1
+      column: 0
+    end_location:
+      row: 5
+      column: 0
+

src/lib.rs

@@ -51,6 +51,7 @@ mod flake8_comprehensions;
 mod flake8_debugger;
 mod flake8_print;
 pub mod flake8_quotes;
+mod flake8_return;
 pub mod flake8_tidy_imports;
 pub mod fs;
 mod isort;

src/noqa.rs

@@ -8,9 +8,9 @@ use nohash_hasher::IntMap;
 use once_cell::sync::Lazy;
 use regex::Regex;
 
-use crate::checks::{Check, CheckCode};
+use crate::checks::{Check, CheckCode, REDIRECTS};
 
-static NO_QA_REGEX: Lazy<Regex> = Lazy::new(|| {
+static NO_QA_LINE_REGEX: Lazy<Regex> = Lazy::new(|| {
     Regex::new(
         r"(?P<spaces>\s*)(?P<noqa>(?i:# noqa)(?::\s?(?P<codes>([A-Z]+[0-9]+(?:[,\s]+)?)+))?)",
     )
@@ -18,6 +18,18 @@ static NO_QA_REGEX: Lazy<Regex> = Lazy::new(|| {
 });
 static SPLIT_COMMA_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"[,\s]").unwrap());
 
+/// Return `true` if a file is exempt from checking based on the contents of the
+/// given line.
+pub fn is_file_exempt(line: &str) -> bool {
+    let line = line.trim_start();
+    line.starts_with("# flake8: noqa")
+        || line.starts_with("# flake8: NOQA")
+        || line.starts_with("# flake8: NoQA")
+        || line.starts_with("# ruff: noqa")
+        || line.starts_with("# ruff: NOQA")
+        || line.starts_with("# ruff: NoQA")
+}
+
 #[derive(Debug)]
 pub enum Directive<'a> {
     None,
@@ -25,8 +37,9 @@ pub enum Directive<'a> {
     Codes(usize, usize, usize, Vec<&'a str>),
 }
 
+/// Extract the noqa `Directive` from a line of Python source code.
 pub fn extract_noqa_directive(line: &str) -> Directive {
-    match NO_QA_REGEX.captures(line) {
+    match NO_QA_LINE_REGEX.captures(line) {
         Some(caps) => match caps.name("spaces") {
             Some(spaces) => match caps.name("noqa") {
                 Some(noqa) => match caps.name("codes") {
@@ -52,6 +65,19 @@ pub fn extract_noqa_directive(line: &str) -> Directive {
     }
 }
 
+/// Returns `true` if the string list of `codes` includes `code` (or an alias
+/// thereof).
+pub fn includes(needle: &CheckCode, haystack: &[&str]) -> bool {
+    let needle: &str = needle.as_ref();
+    haystack.iter().any(|candidate| {
+        if let Some(candidate) = REDIRECTS.get(candidate) {
+            needle == candidate.as_ref()
+        } else {
+            &needle == candidate
+        }
+    })
+}
+
 pub fn add_noqa(
     path: &Path,
     checks: &[Check],
@@ -70,9 +96,13 @@ fn add_noqa_inner(
     noqa_line_for: &IntMap<usize, usize>,
     external: &BTreeSet<String>,
 ) -> (usize, String) {
-    let lines: Vec<&str> = contents.lines().collect();
     let mut matches_by_line: BTreeMap<usize, BTreeSet<&CheckCode>> = BTreeMap::new();
-    for lineno in 0..lines.len() {
+    for (lineno, line) in contents.lines().enumerate() {
+        // If we hit an exemption for the entire file, bail.
+        if is_file_exempt(line) {
+            return (0, contents.to_string());
+        }
+
         let mut codes: BTreeSet<&CheckCode> = BTreeSet::new();
         for check in checks {
             if check.location.row() == lineno + 1 {
@@ -93,7 +123,7 @@ fn add_noqa_inner(
 
     let mut count: usize = 0;
     let mut output = String::new();
-    for (lineno, line) in lines.iter().enumerate() {
+    for (lineno, line) in contents.lines().enumerate() {
         match matches_by_line.get(&lineno) {
             None => {
                 output.push_str(line);
@@ -155,7 +185,7 @@ fn add_noqa_inner(
                         output.push('\n');
 
                         // Only count if the new line is an actual edit.
-                        if &formatted != line {
+                        if formatted != line {
                             count += 1;
                         }
                     }
@@ -176,20 +206,20 @@ mod tests {
 
     use crate::ast::types::Range;
     use crate::checks::{Check, CheckKind};
-    use crate::noqa::{add_noqa_inner, NO_QA_REGEX};
+    use crate::noqa::{add_noqa_inner, NO_QA_LINE_REGEX};
 
     #[test]
     fn regex() {
-        assert!(NO_QA_REGEX.is_match("# noqa"));
-        assert!(NO_QA_REGEX.is_match("# NoQA"));
+        assert!(NO_QA_LINE_REGEX.is_match("# noqa"));
+        assert!(NO_QA_LINE_REGEX.is_match("# NoQA"));
 
-        assert!(NO_QA_REGEX.is_match("# noqa: F401"));
-        assert!(NO_QA_REGEX.is_match("# NoQA: F401"));
-        assert!(NO_QA_REGEX.is_match("# noqa: F401, E501"));
+        assert!(NO_QA_LINE_REGEX.is_match("# noqa: F401"));
+        assert!(NO_QA_LINE_REGEX.is_match("# NoQA: F401"));
+        assert!(NO_QA_LINE_REGEX.is_match("# noqa: F401, E501"));
 
-        assert!(NO_QA_REGEX.is_match("# noqa:F401"));
-        assert!(NO_QA_REGEX.is_match("# NoQA:F401"));
-        assert!(NO_QA_REGEX.is_match("# noqa:F401, E501"));
+        assert!(NO_QA_LINE_REGEX.is_match("# noqa:F401"));
+        assert!(NO_QA_LINE_REGEX.is_match("# NoQA:F401"));
+        assert!(NO_QA_LINE_REGEX.is_match("# noqa:F401, E501"));
     }
 
     #[test]

src/pydocstyle/plugins.rs

@@ -76,7 +76,7 @@ pub fn not_missing(
             false
         }
         DefinitionKind::Function(stmt) | DefinitionKind::NestedFunction(stmt) => {
-            if is_overload(stmt) {
+            if is_overload(checker, stmt) {
                 true
             } else {
                 if checker.settings.enabled.contains(&CheckCode::D103) {
@@ -89,7 +89,7 @@ pub fn not_missing(
             }
         }
         DefinitionKind::Method(stmt) => {
-            if is_overload(stmt) || is_override(stmt) {
+            if is_overload(checker, stmt) || is_override(checker, stmt) {
                 true
             } else if is_magic(stmt) {
                 if checker.settings.enabled.contains(&CheckCode::D105) {
@@ -835,7 +835,7 @@ pub fn if_needed(checker: &mut Checker, definition: &Definition) {
         | DefinitionKind::NestedFunction(stmt)
         | DefinitionKind::Method(stmt) = definition.kind
         {
-            if is_overload(stmt) {
+            if is_overload(checker, stmt) {
                 checker.add_check(Check::new(
                     CheckKind::SkipDocstring,
                     Range::from_located(stmt),
@@ -1319,7 +1319,7 @@ fn missing_args(checker: &mut Checker, definition: &Definition, docstrings_args:
                     // If this is a non-static method, skip `cls` or `self`.
                     usize::from(
                         matches!(definition.kind, DefinitionKind::Method(_))
-                            && !is_staticmethod(parent),
+                            && !is_staticmethod(checker, parent),
                     ),
                 )
             {

src/pylint/mod.rs

@@ -11,14 +11,28 @@ mod tests {
     use crate::linter::test_path;
     use crate::Settings;
 
-    #[test_case(Path::new("await_outside_async.py"))]
-    fn checks(path: &Path) -> Result<()> {
-        let snapshot = format!("{}", path.to_string_lossy());
+    #[test_case(CheckCode::PLC0414, Path::new("import_aliasing.py"); "PLC0414")]
+    #[test_case(CheckCode::PLC2201, Path::new("misplaced_comparison_constant.py"); "PLC2201")]
+    #[test_case(CheckCode::PLC3002, Path::new("unnecessary_direct_lambda_call.py"); "PLC3002")]
+    #[test_case(CheckCode::PLE1142, Path::new("await_outside_async.py"); "PLE1142")]
+    #[test_case(CheckCode::PLR0206, Path::new("property_with_parameters.py"); "PLR0206")]
+    #[test_case(CheckCode::PLR0402, Path::new("import_aliasing.py"); "PLR0402")]
+    #[test_case(CheckCode::PLR1701, Path::new("consider_merging_isinstance.py"); "PLR1701")]
+    #[test_case(CheckCode::PLR1722, Path::new("consider_using_sys_exit_0.py"); "PLR1722_0")]
+    #[test_case(CheckCode::PLR1722, Path::new("consider_using_sys_exit_1.py"); "PLR1722_1")]
+    #[test_case(CheckCode::PLR1722, Path::new("consider_using_sys_exit_2.py"); "PLR1722_2")]
+    #[test_case(CheckCode::PLR1722, Path::new("consider_using_sys_exit_3.py"); "PLR1722_3")]
+    #[test_case(CheckCode::PLR1722, Path::new("consider_using_sys_exit_4.py"); "PLR1722_4")]
+    #[test_case(CheckCode::PLR1722, Path::new("consider_using_sys_exit_5.py"); "PLR1722_5")]
+    #[test_case(CheckCode::PLR1722, Path::new("consider_using_sys_exit_6.py"); "PLR1722_6")]
+    #[test_case(CheckCode::PLW0120, Path::new("useless_else_on_loop.py"); "PLW0120")]
+    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/pylint")
                 .join(path)
                 .as_path(),
-            &Settings::for_rules(vec![CheckCode::PLE1142]),
+            &Settings::for_rules(vec![check_code]),
             true,
         )?;
         checks.sort_by_key(|check| check.location);

src/pylint/plugins/consider_merging_isinstance.rs

@@ -0,0 +1,50 @@
+use itertools::Itertools;
+use rustc_hash::{FxHashMap, FxHashSet};
+use rustpython_ast::{Boolop, Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::CheckKind;
+use crate::Check;
+
+/// PLR1701
+pub fn consider_merging_isinstance(
+    checker: &mut Checker,
+    expr: &Expr,
+    op: &Boolop,
+    values: &[Expr],
+) {
+    if !matches!(op, Boolop::Or) || !checker.is_builtin("isinstance") {
+        return;
+    }
+
+    let mut obj_to_types: FxHashMap<String, FxHashSet<String>> = FxHashMap::default();
+    for value in values {
+        if let ExprKind::Call { func, args, .. } = &value.node {
+            if matches!(&func.node, ExprKind::Name { id, .. } if id == "isinstance") {
+                if let [obj, types] = &args[..] {
+                    obj_to_types
+                        .entry(obj.to_string())
+                        .or_insert_with(FxHashSet::default)
+                        .extend(match &types.node {
+                            ExprKind::Tuple { elts, .. } => {
+                                elts.iter().map(std::string::ToString::to_string).collect()
+                            }
+                            _ => {
+                                vec![types.to_string()]
+                            }
+                        });
+                }
+            }
+        }
+    }
+
+    for (obj, types) in obj_to_types {
+        if types.len() > 1 {
+            checker.add_check(Check::new(
+                CheckKind::ConsiderMergingIsinstance(obj, types.into_iter().sorted().collect()),
+                Range::from_located(expr),
+            ));
+        }
+    }
+}

src/pylint/plugins/consider_using_from_import.rs

@@ -0,0 +1,20 @@
+use rustpython_ast::Alias;
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::CheckKind;
+use crate::Check;
+
+/// PLR0402
+pub fn consider_using_from_import(checker: &mut Checker, alias: &Alias) {
+    if let Some(asname) = &alias.node.asname {
+        if let Some((module, name)) = alias.node.name.rsplit_once('.') {
+            if name == asname {
+                checker.add_check(Check::new(
+                    CheckKind::ConsiderUsingFromImport(module.to_string(), name.to_string()),
+                    Range::from_located(alias),
+                ));
+            }
+        }
+    }
+}

src/pylint/plugins/consider_using_sys_exit.rs

@@ -19,11 +19,6 @@ fn is_module_star_imported(checker: &Checker, module: &str) -> bool {
     })
 }
 
-/// Return `true` if `exit` is (still) bound as a built-in in the current scope.
-fn has_builtin_exit_in_scope(checker: &Checker) -> bool {
-    !is_module_star_imported(checker, "sys") && checker.is_builtin("exit")
-}
-
 /// Return the appropriate `sys.exit` reference based on the current set of
 /// imports, or `None` is `sys.exit` hasn't been imported.
 fn get_member_import_name_alias(checker: &Checker, module: &str, member: &str) -> Option<String> {
@@ -64,23 +59,28 @@ fn get_member_import_name_alias(checker: &Checker, module: &str, member: &str) -
     })
 }
 
-/// RUF101
-pub fn convert_exit_to_sys_exit(checker: &mut Checker, func: &Expr) {
+/// RUF004
+pub fn consider_using_sys_exit(checker: &mut Checker, func: &Expr) {
     if let ExprKind::Name { id, .. } = &func.node {
-        if id == "exit" {
-            if has_builtin_exit_in_scope(checker) {
-                let mut check =
-                    Check::new(CheckKind::ConvertExitToSysExit, Range::from_located(func));
-                if checker.patch(check.kind.code()) {
-                    if let Some(content) = get_member_import_name_alias(checker, "sys", "exit") {
-                        check.amend(Fix::replacement(
-                            content,
-                            func.location,
-                            func.end_location.unwrap(),
-                        ));
+        for name in ["exit", "quit"] {
+            if id == name {
+                if !(name == "exit" && is_module_star_imported(checker, "sys"))
+                    && checker.is_builtin(name)
+                {
+                    let mut check =
+                        Check::new(CheckKind::ConsiderUsingSysExit, Range::from_located(func));
+                    if checker.patch(check.kind.code()) {
+                        if let Some(content) = get_member_import_name_alias(checker, "sys", "exit")
+                        {
+                            check.amend(Fix::replacement(
+                                content,
+                                func.location,
+                                func.end_location.unwrap(),
+                            ));
+                        }
                     }
+                    checker.add_check(check);
                 }
-                checker.add_check(check);
             }
         }
     }

src/pylint/plugins/misplaced_comparison_constant.rs

@@ -0,0 +1,48 @@
+use rustpython_ast::{Cmpop, Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::autofix::Fix;
+use crate::check_ast::Checker;
+use crate::checks::CheckKind;
+use crate::Check;
+
+/// PLC2201
+pub fn misplaced_comparison_constant(
+    checker: &mut Checker,
+    expr: &Expr,
+    left: &Expr,
+    ops: &[Cmpop],
+    comparators: &[Expr],
+) {
+    if let ([op], [right]) = (ops, comparators) {
+        if matches!(
+            op,
+            Cmpop::Eq | Cmpop::NotEq | Cmpop::Lt | Cmpop::LtE | Cmpop::Gt | Cmpop::GtE,
+        ) && matches!(&left.node, &ExprKind::Constant { .. })
+            && !matches!(&right.node, &ExprKind::Constant { .. })
+        {
+            let reversed_op = match op {
+                Cmpop::Eq => "==",
+                Cmpop::NotEq => "!=",
+                Cmpop::Lt => ">",
+                Cmpop::LtE => ">=",
+                Cmpop::Gt => "<",
+                Cmpop::GtE => "<=",
+                _ => unreachable!("Expected comparison operator"),
+            };
+            let suggestion = format!("{right} {reversed_op} {left}");
+            let mut check = Check::new(
+                CheckKind::MisplacedComparisonConstant(suggestion.clone()),
+                Range::from_located(expr),
+            );
+            if checker.patch(check.kind.code()) {
+                check.amend(Fix::replacement(
+                    suggestion,
+                    expr.location,
+                    expr.end_location.unwrap(),
+                ));
+            }
+            checker.add_check(check);
+        }
+    }
+}

src/pylint/plugins/mod.rs

@@ -0,0 +1,19 @@
+pub use await_outside_async::await_outside_async;
+pub use consider_merging_isinstance::consider_merging_isinstance;
+pub use consider_using_from_import::consider_using_from_import;
+pub use consider_using_sys_exit::consider_using_sys_exit;
+pub use misplaced_comparison_constant::misplaced_comparison_constant;
+pub use property_with_parameters::property_with_parameters;
+pub use unnecessary_direct_lambda_call::unnecessary_direct_lambda_call;
+pub use useless_else_on_loop::useless_else_on_loop;
+pub use useless_import_alias::useless_import_alias;
+
+mod await_outside_async;
+mod consider_merging_isinstance;
+mod consider_using_from_import;
+mod consider_using_sys_exit;
+mod misplaced_comparison_constant;
+mod property_with_parameters;
+mod unnecessary_direct_lambda_call;
+mod useless_else_on_loop;
+mod useless_import_alias;

src/pylint/plugins/property_with_parameters.rs

@@ -0,0 +1,34 @@
+use rustpython_ast::{Arguments, Expr, ExprKind, Stmt};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::CheckKind;
+use crate::Check;
+
+/// PLR0206
+pub fn property_with_parameters(
+    checker: &mut Checker,
+    stmt: &Stmt,
+    decorator_list: &[Expr],
+    args: &Arguments,
+) {
+    if decorator_list
+        .iter()
+        .any(|d| matches!(&d.node, ExprKind::Name { id, .. } if id == "property"))
+    {
+        if checker.is_builtin("property")
+            && args
+                .args
+                .iter()
+                .chain(args.posonlyargs.iter())
+                .chain(args.kwonlyargs.iter())
+                .count()
+                > 1
+        {
+            checker.add_check(Check::new(
+                CheckKind::PropertyWithParameters,
+                Range::from_located(stmt),
+            ));
+        }
+    }
+}

src/pylint/plugins/unnecessary_direct_lambda_call.rs

@@ -0,0 +1,16 @@
+use rustpython_ast::{Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::CheckKind;
+use crate::Check;
+
+/// PLC3002
+pub fn unnecessary_direct_lambda_call(checker: &mut Checker, expr: &Expr, func: &Expr) {
+    if let ExprKind::Lambda { .. } = &func.node {
+        checker.add_check(Check::new(
+            CheckKind::UnnecessaryDirectLambdaCall,
+            Range::from_located(expr),
+        ));
+    }
+}

src/pylint/plugins/useless_else_on_loop.rs

@@ -0,0 +1,41 @@
+use rustpython_ast::{ExcepthandlerKind, Stmt, StmtKind};
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::checks::CheckKind;
+use crate::Check;
+
+fn loop_exits_early(body: &[Stmt]) -> bool {
+    body.iter().any(|stmt| match &stmt.node {
+        StmtKind::If { body, .. } => loop_exits_early(body),
+        StmtKind::Try {
+            body,
+            handlers,
+            orelse,
+            finalbody,
+            ..
+        } => {
+            loop_exits_early(body)
+                || handlers.iter().any(|handler| match &handler.node {
+                    ExcepthandlerKind::ExceptHandler { body, .. } => loop_exits_early(body),
+                })
+                || loop_exits_early(orelse)
+                || loop_exits_early(finalbody)
+        }
+        StmtKind::For { orelse, .. }
+        | StmtKind::AsyncFor { orelse, .. }
+        | StmtKind::While { orelse, .. } => loop_exits_early(orelse),
+        StmtKind::Break { .. } => true,
+        _ => false,
+    })
+}
+
+/// PLW0120
+pub fn useless_else_on_loop(checker: &mut Checker, stmt: &Stmt, body: &[Stmt], orelse: &[Stmt]) {
+    if !orelse.is_empty() && !loop_exits_early(body) {
+        checker.add_check(Check::new(
+            CheckKind::UselessElseOnLoop,
+            Range::from_located(stmt),
+        ));
+    }
+}

src/pylint/plugins/useless_import_alias.rs

@@ -0,0 +1,24 @@
+use rustpython_ast::Alias;
+
+use crate::ast::types::Range;
+use crate::autofix::Fix;
+use crate::check_ast::Checker;
+use crate::checks::CheckKind;
+use crate::Check;
+
+/// PLC0414
+pub fn useless_import_alias(checker: &mut Checker, alias: &Alias) {
+    if let Some(asname) = &alias.node.asname {
+        if !alias.node.name.contains('.') && &alias.node.name == asname {
+            let mut check = Check::new(CheckKind::UselessImportAlias, Range::from_located(alias));
+            if checker.patch(check.kind.code()) {
+                check.amend(Fix::replacement(
+                    asname.to_string(),
+                    alias.location,
+                    alias.end_location.unwrap(),
+                ));
+            }
+            checker.add_check(check);
+        }
+    }
+}

src/pylint/snapshots/ruff__pylint__tests__PLC0414_import_aliasing.py.snap

@@ -0,0 +1,125 @@
+---
+source: src/pylint/mod.rs
+expression: checks
+---
+- kind: UselessImportAlias
+  location:
+    row: 6
+    column: 7
+  end_location:
+    row: 6
+    column: 33
+  fix:
+    content: collections
+    location:
+      row: 6
+      column: 7
+    end_location:
+      row: 6
+      column: 33
+- kind: UselessImportAlias
+  location:
+    row: 7
+    column: 24
+  end_location:
+    row: 7
+    column: 50
+  fix:
+    content: OrderedDict
+    location:
+      row: 7
+      column: 24
+    end_location:
+      row: 7
+      column: 50
+- kind: UselessImportAlias
+  location:
+    row: 15
+    column: 14
+  end_location:
+    row: 15
+    column: 24
+  fix:
+    content: bar
+    location:
+      row: 15
+      column: 14
+    end_location:
+      row: 15
+      column: 24
+- kind: UselessImportAlias
+  location:
+    row: 18
+    column: 18
+  end_location:
+    row: 18
+    column: 28
+  fix:
+    content: bar
+    location:
+      row: 18
+      column: 18
+    end_location:
+      row: 18
+      column: 28
+- kind: UselessImportAlias
+  location:
+    row: 19
+    column: 22
+  end_location:
+    row: 19
+    column: 38
+  fix:
+    content: foobar
+    location:
+      row: 19
+      column: 22
+    end_location:
+      row: 19
+      column: 38
+- kind: UselessImportAlias
+  location:
+    row: 21
+    column: 14
+  end_location:
+    row: 21
+    column: 24
+  fix:
+    content: foo
+    location:
+      row: 21
+      column: 14
+    end_location:
+      row: 21
+      column: 24
+- kind: UselessImportAlias
+  location:
+    row: 22
+    column: 26
+  end_location:
+    row: 22
+    column: 38
+  fix:
+    content: foo2
+    location:
+      row: 22
+      column: 26
+    end_location:
+      row: 22
+      column: 38
+- kind: UselessImportAlias
+  location:
+    row: 24
+    column: 20
+  end_location:
+    row: 24
+    column: 36
+  fix:
+    content: foobar
+    location:
+      row: 24
+      column: 20
+    end_location:
+      row: 24
+      column: 36
+

src/pylint/snapshots/ruff__pylint__tests__PLC2201_misplaced_comparison_constant.py.snap

@@ -0,0 +1,101 @@
+---
+source: src/pylint/mod.rs
+expression: checks
+---
+- kind:
+    MisplacedComparisonConstant: i >= 5
+  location:
+    row: 20
+    column: 11
+  end_location:
+    row: 20
+    column: 17
+  fix:
+    content: i >= 5
+    location:
+      row: 20
+      column: 11
+    end_location:
+      row: 20
+      column: 17
+- kind:
+    MisplacedComparisonConstant: i == 1
+  location:
+    row: 22
+    column: 11
+  end_location:
+    row: 22
+    column: 17
+  fix:
+    content: i == 1
+    location:
+      row: 22
+      column: 11
+    end_location:
+      row: 22
+      column: 17
+- kind:
+    MisplacedComparisonConstant: dummy_return() > 3
+  location:
+    row: 24
+    column: 11
+  end_location:
+    row: 24
+    column: 29
+  fix:
+    content: dummy_return() > 3
+    location:
+      row: 24
+      column: 11
+    end_location:
+      row: 24
+      column: 29
+- kind:
+    MisplacedComparisonConstant: instance.dummy_return() != 4
+  location:
+    row: 26
+    column: 11
+  end_location:
+    row: 26
+    column: 39
+  fix:
+    content: instance.dummy_return() != 4
+    location:
+      row: 26
+      column: 11
+    end_location:
+      row: 26
+      column: 39
+- kind:
+    MisplacedComparisonConstant: instance.attr == 1
+  location:
+    row: 28
+    column: 11
+  end_location:
+    row: 28
+    column: 29
+  fix:
+    content: instance.attr == 1
+    location:
+      row: 28
+      column: 11
+    end_location:
+      row: 28
+      column: 29
+- kind:
+    MisplacedComparisonConstant: "instance.attr == 'aaa'"
+  location:
+    row: 30
+    column: 11
+  end_location:
+    row: 30
+    column: 33
+  fix:
+    content: "instance.attr == 'aaa'"
+    location:
+      row: 30
+      column: 11
+    end_location:
+      row: 30
+      column: 33
+