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.154
+    rev: v0.0.156
     hooks:
       - id: ruff
 

Cargo.lock

@@ -703,7 +703,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.154-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.154"
+version = "0.0.156"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1889,13 +1889,14 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.154"
+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.154"
+version = "0.0.156"
 edition = "2021"
 rust-version = "1.65.0"
 

README.md

@@ -74,7 +74,7 @@ of [Conda](https://docs.conda.io/en/latest/):
    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. [flake8-2020 (YTT)](#flake8-2020)
    1. [flake8-annotations (ANN)](#flake8-annotations)
@@ -87,13 +87,12 @@ of [Conda](https://docs.conda.io/en/latest/):
    1. [flake8-debugger (T10)](#flake8-debugger)
    1. [flake8-print (T20)](#flake8-print)
    1. [flake8-quotes (Q)](#flake8-quotes)
-   1. [flake8-return (ET)](#flake8-return)
+   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)
@@ -146,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.154
+    rev: v0.0.156
     hooks:
       - id: ruff
 ```
@@ -355,13 +354,13 @@ For targeted exclusions across entire files (e.g., "Ignore all F841 violations i
 
 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
@@ -524,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
 
@@ -767,10 +766,15 @@ For more, see [Pylint](https://pypi.org/project/pylint/2.15.7/) on PyPI.
 
 | Code | Name | Message | Fix |
 | ---- | ---- | ------- | --- |
-| PLR1701 | ConsiderMergingIsinstance | Consider merging these isinstance calls: `isinstance(..., (...))` |  |
+| 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. |  |
-| PLR0206 | PropertyWithParameters | Cannot have defined parameters for properties |  |
 | 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
 
@@ -779,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. -->
 
@@ -1790,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.
@@ -1808,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.
@@ -1826,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.
 

flake8_to_ruff/Cargo.lock

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

flake8_to_ruff/Cargo.toml

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

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/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_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/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/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
+    ...

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.154"
+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

@@ -37,7 +37,7 @@ 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_return, flake8_tidy_imports, mccabe, pep8_naming, pycodestyle, pydocstyle,
-    pyflakes, pygrep_hooks, pylint, pyupgrade, rules,
+    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);
@@ -531,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,
                     );
@@ -668,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 {
@@ -755,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);
                     }
                 }
@@ -960,6 +968,11 @@ where
                                 self.add_check(check);
                             }
                         }
+
+                        // pylint
+                        if self.settings.enabled.contains(&CheckCode::PLC0414) {
+                            pylint::plugins::useless_import_alias(self, alias);
+                        }
                     }
                 }
             }
@@ -1004,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);
@@ -1024,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) {
@@ -1049,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) {
@@ -1062,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,
                     );
@@ -1239,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
@@ -1282,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
@@ -1323,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
@@ -1417,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);
                 }
 
@@ -1685,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);
                 }
 
@@ -1730,10 +1757,8 @@ where
                 if self.settings.enabled.contains(&CheckCode::PLC3002) {
                     pylint::plugins::unnecessary_direct_lambda_call(self, expr, func);
                 }
-
-                // Ruff
-                if self.settings.enabled.contains(&CheckCode::RUF101) {
-                    rules::plugins::convert_exit_to_sys_exit(self, func);
+                if self.settings.enabled.contains(&CheckCode::PLR1722) {
+                    pylint::plugins::consider_using_sys_exit(self, func);
                 }
             }
             ExprKind::Dict { keys, .. } => {
@@ -1996,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),

src/check_lines.rs

@@ -7,7 +7,7 @@ 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::{is_file_exempt, Directive};
 use crate::settings::Settings;
@@ -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![];
@@ -70,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);
@@ -97,7 +97,7 @@ pub fn check_lines(
         // `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.
@@ -140,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);
                     }
@@ -184,7 +184,7 @@ pub fn check_lines(
         }
     }
 
-    // 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 {
@@ -210,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 {

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};
@@ -91,10 +93,15 @@ pub enum CheckCode {
     F841,
     F901,
     // pylint
-    PLR1701,
+    PLC0414,
+    PLC2201,
     PLC3002,
-    PLR0206,
     PLE1142,
+    PLR0206,
+    PLR0402,
+    PLR1701,
+    PLR1722,
+    PLW0120,
     // flake8-builtins
     A001,
     A002,
@@ -193,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,
@@ -287,9 +294,7 @@ pub enum CheckCode {
     RUF001,
     RUF002,
     RUF003,
-    RUF101,
-    // Meta
-    M001,
+    RUF100,
     // pygrep-hooks
     PGH001,
 }
@@ -320,7 +325,6 @@ pub enum CheckCategory {
     PygrepHooks,
     Pylint,
     Ruff,
-    Meta,
 }
 
 pub enum Platform {
@@ -356,7 +360,6 @@ impl CheckCategory {
             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",
@@ -431,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,
@@ -574,9 +576,14 @@ pub enum CheckKind {
     YieldOutsideFunction(DeferralKeyword),
     // pylint
     ConsiderMergingIsinstance(String, Vec<String>),
+    UselessImportAlias,
+    MisplacedComparisonConstant(String),
     UnnecessaryDirectLambdaCall,
     PropertyWithParameters,
+    ConsiderUsingFromImport(String, String),
     AwaitOutsideAsync,
+    UselessElseOnLoop,
+    ConsiderUsingSysExit,
     // flake8-builtins
     BuiltinVariableShadowing(String),
     BuiltinArgumentShadowing(String),
@@ -771,8 +778,6 @@ pub enum CheckKind {
     AmbiguousUnicodeCharacterString(char, char),
     AmbiguousUnicodeCharacterDocstring(char, char),
     AmbiguousUnicodeCharacterComment(char, char),
-    ConvertExitToSysExit,
-    // Meta
     UnusedNOQA(Option<Vec<String>>),
 }
 
@@ -781,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
@@ -870,12 +875,19 @@ impl CheckCode {
             CheckCode::F841 => CheckKind::UnusedVariable("...".to_string()),
             CheckCode::F901 => CheckKind::RaiseNotImplemented,
             // 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()),
@@ -989,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,
@@ -1105,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),
         }
     }
 
@@ -1279,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,
@@ -1296,10 +1305,15 @@ 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,
@@ -1315,7 +1329,7 @@ impl CheckCode {
             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,
@@ -1325,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,
@@ -1420,10 +1434,15 @@ impl CheckKind {
             CheckKind::NoNewLineAtEndOfFile => &CheckCode::W292,
             CheckKind::InvalidEscapeSequence(_) => &CheckCode::W605,
             // 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::UnnecessaryDirectLambdaCall => &CheckCode::PLC3002,
+            CheckKind::ConsiderUsingFromImport(..) => &CheckCode::PLR0402,
+            CheckKind::ConsiderUsingSysExit => &CheckCode::PLR1722,
+            CheckKind::UselessElseOnLoop => &CheckCode::PLW0120,
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(_) => &CheckCode::A001,
             CheckKind::BuiltinArgumentShadowing(_) => &CheckCode::A002,
@@ -1520,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,
@@ -1618,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,
         }
     }
 
@@ -1805,19 +1822,32 @@ impl CheckKind {
                 format!("Invalid escape sequence: '\\{char}'")
             }
             // 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")
@@ -2405,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) => {
@@ -2460,7 +2486,7 @@ impl CheckKind {
                 | CheckKind::BlankLineBeforeSection(..)
                 | CheckKind::CapitalizeSectionName(..)
                 | CheckKind::CommentedOutCode
-                | CheckKind::ConvertExitToSysExit
+                | CheckKind::ConsiderUsingSysExit
                 | CheckKind::ConvertNamedTupleFunctionalToClass(..)
                 | CheckKind::ConvertTypedDictFunctionalToClass(..)
                 | CheckKind::DashedUnderlineAfterSection(..)
@@ -2472,6 +2498,7 @@ impl CheckKind {
                 | CheckKind::ImplicitReturn
                 | CheckKind::ImplicitReturnValue
                 | CheckKind::IsLiteral
+                | CheckKind::MisplacedComparisonConstant(..)
                 | CheckKind::NewLineAfterLastParagraph
                 | CheckKind::NewLineAfterSectionName(..)
                 | CheckKind::NoBlankLineAfterFunction(..)
@@ -2523,6 +2550,7 @@ impl CheckKind {
                 | CheckKind::UnusedNOQA(..)
                 | CheckKind::UsePEP585Annotation(..)
                 | CheckKind::UsePEP604Annotation
+                | CheckKind::UselessImportAlias
                 | CheckKind::UselessMetaclassType
                 | CheckKind::UselessObjectInheritance(..)
         )
@@ -2552,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,
@@ -283,6 +280,14 @@ pub enum CheckCodePrefix {
     PGH00,
     PGH001,
     PLC,
+    PLC0,
+    PLC04,
+    PLC041,
+    PLC0414,
+    PLC2,
+    PLC22,
+    PLC220,
+    PLC2201,
     PLC3,
     PLC30,
     PLC300,
@@ -297,10 +302,20 @@ pub enum CheckCodePrefix {
     PLR02,
     PLR020,
     PLR0206,
+    PLR04,
+    PLR040,
+    PLR0402,
     PLR1,
     PLR17,
     PLR170,
     PLR1701,
+    PLR172,
+    PLR1722,
+    PLW,
+    PLW0,
+    PLW01,
+    PLW012,
+    PLW0120,
     Q,
     Q0,
     Q00,
@@ -327,7 +342,7 @@ pub enum CheckCodePrefix {
     RUF003,
     RUF1,
     RUF10,
-    RUF101,
+    RUF100,
     S,
     S1,
     S10,
@@ -363,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,
@@ -1105,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,
@@ -1181,7 +1210,17 @@ impl CheckCodePrefix {
             CheckCodePrefix::PGH0 => vec![CheckCode::PGH001],
             CheckCodePrefix::PGH00 => vec![CheckCode::PGH001],
             CheckCodePrefix::PGH001 => vec![CheckCode::PGH001],
-            CheckCodePrefix::PLC => vec![CheckCode::PLC3002],
+            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],
@@ -1191,15 +1230,30 @@ impl CheckCodePrefix {
             CheckCodePrefix::PLE11 => vec![CheckCode::PLE1142],
             CheckCodePrefix::PLE114 => vec![CheckCode::PLE1142],
             CheckCodePrefix::PLE1142 => vec![CheckCode::PLE1142],
-            CheckCodePrefix::PLR => vec![CheckCode::PLR1701, CheckCode::PLR0206],
-            CheckCodePrefix::PLR0 => vec![CheckCode::PLR0206],
+            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::PLR1 => vec![CheckCode::PLR1701],
-            CheckCodePrefix::PLR17 => vec![CheckCode::PLR1701],
+            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,
@@ -1264,16 +1318,16 @@ impl CheckCodePrefix {
                 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,
@@ -1313,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],
@@ -1677,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,
@@ -1705,6 +1931,14 @@ impl CheckCodePrefix {
             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,
@@ -1719,10 +1953,20 @@ impl CheckCodePrefix {
             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,
@@ -1749,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,
@@ -1785,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,
@@ -1825,18 +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/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/noqa.rs

@@ -8,7 +8,7 @@ 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_LINE_REGEX: Lazy<Regex> = Lazy::new(|| {
     Regex::new(
@@ -37,6 +37,7 @@ 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_LINE_REGEX.captures(line) {
         Some(caps) => match caps.name("spaces") {
@@ -64,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],

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,12 +11,23 @@ mod tests {
     use crate::linter::test_path;
     use crate::Settings;
 
+    #[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!("{}", path.to_string_lossy());
+        let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
         let mut checks = test_path(
             Path::new("./resources/test/fixtures/pylint")
                 .join(path)

src/pylint/plugins.rs

@@ -1,108 +0,0 @@
-use itertools::Itertools;
-use rustc_hash::{FxHashMap, FxHashSet};
-use rustpython_ast::{Arguments, Boolop, Expr, ExprKind, Stmt};
-
-use crate::ast::types::{FunctionScope, Range, ScopeKind};
-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),
-        ));
-    }
-}
-
-/// PLE1142
-pub fn await_outside_async(checker: &mut Checker, expr: &Expr) {
-    if !checker
-        .current_scopes()
-        .find_map(|scope| {
-            if let ScopeKind::Function(FunctionScope { async_, .. }) = &scope.kind {
-                Some(*async_)
-            } else {
-                None
-            }
-        })
-        .unwrap_or(true)
-    {
-        checker.add_check(Check::new(
-            CheckKind::AwaitOutsideAsync,
-            Range::from_located(expr),
-        ));
-    }
-}
-
-/// 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),
-            ));
-        }
-    }
-}
-
-/// 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/await_outside_async.rs

@@ -0,0 +1,26 @@
+use rustpython_ast::Expr;
+
+use crate::ast::types::{FunctionScope, Range, ScopeKind};
+use crate::check_ast::Checker;
+use crate::checks::CheckKind;
+use crate::Check;
+
+/// PLE1142
+pub fn await_outside_async(checker: &mut Checker, expr: &Expr) {
+    if !checker
+        .current_scopes()
+        .find_map(|scope| {
+            if let ScopeKind::Function(FunctionScope { async_, .. }) = &scope.kind {
+                Some(*async_)
+            } else {
+                None
+            }
+        })
+        .unwrap_or(true)
+    {
+        checker.add_check(Check::new(
+            CheckKind::AwaitOutsideAsync,
+            Range::from_located(expr),
+        ));
+    }
+}

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
+

src/pylint/snapshots/ruff__pylint__tests__PLR0402_import_aliasing.py.snap

@@ -0,0 +1,27 @@
+---
+source: src/pylint/mod.rs
+expression: checks
+---
+- kind:
+    ConsiderUsingFromImport:
+      - os
+      - path
+  location:
+    row: 9
+    column: 7
+  end_location:
+    row: 9
+    column: 22
+  fix: ~
+- kind:
+    ConsiderUsingFromImport:
+      - foo.bar
+      - foobar
+  location:
+    row: 11
+    column: 7
+  end_location:
+    row: 11
+    column: 31
+  fix: ~
+

src/pylint/snapshots/ruff__pylint__tests__PLR1722_consider_using_sys_exit_0.py.snap

@@ -0,0 +1,37 @@
+---
+source: src/pylint/mod.rs
+expression: checks
+---
+- kind: ConsiderUsingSysExit
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 1
+    column: 4
+  fix: ~
+- kind: ConsiderUsingSysExit
+  location:
+    row: 2
+    column: 0
+  end_location:
+    row: 2
+    column: 4
+  fix: ~
+- kind: ConsiderUsingSysExit
+  location:
+    row: 6
+    column: 4
+  end_location:
+    row: 6
+    column: 8
+  fix: ~
+- kind: ConsiderUsingSysExit
+  location:
+    row: 7
+    column: 4
+  end_location:
+    row: 7
+    column: 8
+  fix: ~
+

src/pylint/snapshots/ruff__pylint__tests__PLR1722_consider_using_sys_exit_1.py.snap

@@ -0,0 +1,65 @@
+---
+source: src/pylint/mod.rs
+expression: checks
+---
+- kind: ConsiderUsingSysExit
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 4
+  fix:
+    content: sys.exit
+    location:
+      row: 3
+      column: 0
+    end_location:
+      row: 3
+      column: 4
+- kind: ConsiderUsingSysExit
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 4
+    column: 4
+  fix:
+    content: sys.exit
+    location:
+      row: 4
+      column: 0
+    end_location:
+      row: 4
+      column: 4
+- kind: ConsiderUsingSysExit
+  location:
+    row: 8
+    column: 4
+  end_location:
+    row: 8
+    column: 8
+  fix:
+    content: sys.exit
+    location:
+      row: 8
+      column: 4
+    end_location:
+      row: 8
+      column: 8
+- kind: ConsiderUsingSysExit
+  location:
+    row: 9
+    column: 4
+  end_location:
+    row: 9
+    column: 8
+  fix:
+    content: sys.exit
+    location:
+      row: 9
+      column: 4
+    end_location:
+      row: 9
+      column: 8
+

src/pylint/snapshots/ruff__pylint__tests__PLR1722_consider_using_sys_exit_2.py.snap

@@ -0,0 +1,65 @@
+---
+source: src/pylint/mod.rs
+expression: checks
+---
+- kind: ConsiderUsingSysExit
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 4
+  fix:
+    content: sys2.exit
+    location:
+      row: 3
+      column: 0
+    end_location:
+      row: 3
+      column: 4
+- kind: ConsiderUsingSysExit
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 4
+    column: 4
+  fix:
+    content: sys2.exit
+    location:
+      row: 4
+      column: 0
+    end_location:
+      row: 4
+      column: 4
+- kind: ConsiderUsingSysExit
+  location:
+    row: 8
+    column: 4
+  end_location:
+    row: 8
+    column: 8
+  fix:
+    content: sys2.exit
+    location:
+      row: 8
+      column: 4
+    end_location:
+      row: 8
+      column: 8
+- kind: ConsiderUsingSysExit
+  location:
+    row: 9
+    column: 4
+  end_location:
+    row: 9
+    column: 8
+  fix:
+    content: sys2.exit
+    location:
+      row: 9
+      column: 4
+    end_location:
+      row: 9
+      column: 8
+

src/pylint/snapshots/ruff__pylint__tests__PLR1722_consider_using_sys_exit_3.py.snap

@@ -1,35 +1,35 @@
 ---
-source: src/rules/mod.rs
+source: src/pylint/mod.rs
 expression: checks
 ---
-- kind: ConvertExitToSysExit
+- kind: ConsiderUsingSysExit
   location:
-    row: 3
+    row: 4
     column: 0
   end_location:
-    row: 3
+    row: 4
     column: 4
   fix:
-    content: exit2
+    content: exit
     location:
-      row: 3
+      row: 4
       column: 0
     end_location:
-      row: 3
+      row: 4
       column: 4
-- kind: ConvertExitToSysExit
+- kind: ConsiderUsingSysExit
   location:
-    row: 7
+    row: 9
     column: 4
   end_location:
-    row: 7
+    row: 9
     column: 8
   fix:
-    content: exit2
+    content: exit
     location:
-      row: 7
+      row: 9
       column: 4
     end_location:
-      row: 7
+      row: 9
       column: 8
 

src/pylint/snapshots/ruff__pylint__tests__PLR1722_consider_using_sys_exit_4.py.snap

@@ -0,0 +1,65 @@
+---
+source: src/pylint/mod.rs
+expression: checks
+---
+- kind: ConsiderUsingSysExit
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 4
+  fix:
+    content: exit2
+    location:
+      row: 3
+      column: 0
+    end_location:
+      row: 3
+      column: 4
+- kind: ConsiderUsingSysExit
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 4
+    column: 4
+  fix:
+    content: exit2
+    location:
+      row: 4
+      column: 0
+    end_location:
+      row: 4
+      column: 4
+- kind: ConsiderUsingSysExit
+  location:
+    row: 8
+    column: 4
+  end_location:
+    row: 8
+    column: 8
+  fix:
+    content: exit2
+    location:
+      row: 8
+      column: 4
+    end_location:
+      row: 8
+      column: 8
+- kind: ConsiderUsingSysExit
+  location:
+    row: 9
+    column: 4
+  end_location:
+    row: 9
+    column: 8
+  fix:
+    content: exit2
+    location:
+      row: 9
+      column: 4
+    end_location:
+      row: 9
+      column: 8
+

src/pylint/snapshots/ruff__pylint__tests__PLR1722_consider_using_sys_exit_5.py.snap

@@ -1,35 +1,35 @@
 ---
-source: src/rules/mod.rs
+source: src/pylint/mod.rs
 expression: checks
 ---
-- kind: ConvertExitToSysExit
+- kind: ConsiderUsingSysExit
   location:
-    row: 3
+    row: 4
     column: 0
   end_location:
-    row: 3
+    row: 4
     column: 4
   fix:
-    content: sys.exit
+    content: exit
     location:
-      row: 3
+      row: 4
       column: 0
     end_location:
-      row: 3
+      row: 4
       column: 4
-- kind: ConvertExitToSysExit
+- kind: ConsiderUsingSysExit
   location:
-    row: 7
+    row: 9
     column: 4
   end_location:
-    row: 7
+    row: 9
     column: 8
   fix:
-    content: sys.exit
+    content: exit
     location:
-      row: 7
+      row: 9
       column: 4
     end_location:
-      row: 7
+      row: 9
       column: 8
 

src/pylint/snapshots/ruff__pylint__tests__PLR1722_consider_using_sys_exit_6.py.snap

@@ -1,8 +1,8 @@
 ---
-source: src/rules/mod.rs
+source: src/pylint/mod.rs
 expression: checks
 ---
-- kind: ConvertExitToSysExit
+- kind: ConsiderUsingSysExit
   location:
     row: 1
     column: 0
@@ -10,12 +10,12 @@ expression: checks
     row: 1
     column: 4
   fix: ~
-- kind: ConvertExitToSysExit
+- kind: ConsiderUsingSysExit
   location:
-    row: 5
-    column: 4
+    row: 2
+    column: 0
   end_location:
-    row: 5
-    column: 8
+    row: 2
+    column: 4
   fix: ~
 

src/pylint/snapshots/ruff__pylint__tests__PLW0120_useless_else_on_loop.py.snap

@@ -0,0 +1,61 @@
+---
+source: src/pylint/mod.rs
+expression: checks
+---
+- kind: UselessElseOnLoop
+  location:
+    row: 6
+    column: 4
+  end_location:
+    row: 11
+    column: 4
+  fix: ~
+- kind: UselessElseOnLoop
+  location:
+    row: 16
+    column: 4
+  end_location:
+    row: 20
+    column: 4
+  fix: ~
+- kind: UselessElseOnLoop
+  location:
+    row: 23
+    column: 0
+  end_location:
+    row: 34
+    column: 0
+  fix: ~
+- kind: UselessElseOnLoop
+  location:
+    row: 34
+    column: 0
+  end_location:
+    row: 40
+    column: 0
+  fix: ~
+- kind: UselessElseOnLoop
+  location:
+    row: 40
+    column: 0
+  end_location:
+    row: 48
+    column: 0
+  fix: ~
+- kind: UselessElseOnLoop
+  location:
+    row: 81
+    column: 4
+  end_location:
+    row: 90
+    column: 4
+  fix: ~
+- kind: UselessElseOnLoop
+  location:
+    row: 96
+    column: 8
+  end_location:
+    row: 101
+    column: 4
+  fix: ~
+

src/python/typing.rs

@@ -55,6 +55,7 @@ static TYPING_EXTENSIONS: Lazy<FxHashSet<&'static str>> = Lazy::new(|| {
         "get_overloads",
         "is_typeddict",
         "overload",
+        "override",
         "reveal_type",
         "runtime_checkable",
     ])

src/pyupgrade/checks.rs

@@ -8,7 +8,7 @@ use crate::checks::{Check, CheckKind};
 use crate::pyupgrade::types::Primitive;
 use crate::settings::types::PythonVersion;
 
-/// U008
+/// UP008
 pub fn super_args(
     scope: &Scope,
     parents: &[&Stmt],
@@ -74,7 +74,7 @@ pub fn super_args(
     None
 }
 
-/// U001
+/// UP001
 pub fn useless_metaclass_type(targets: &[Expr], value: &Expr, location: Range) -> Option<Check> {
     if targets.len() == 1 {
         if let ExprKind::Name { id, .. } = targets.first().map(|expr| &expr.node).unwrap() {
@@ -90,7 +90,7 @@ pub fn useless_metaclass_type(targets: &[Expr], value: &Expr, location: Range) -
     None
 }
 
-/// U004
+/// UP004
 pub fn useless_object_inheritance(name: &str, bases: &[Expr], scope: &Scope) -> Option<Check> {
     for expr in bases {
         if let ExprKind::Name { id, .. } = &expr.node {
@@ -115,7 +115,7 @@ pub fn useless_object_inheritance(name: &str, bases: &[Expr], scope: &Scope) ->
     None
 }
 
-/// U003
+/// UP003
 pub fn type_of_primitive(func: &Expr, args: &[Expr], location: Range) -> Option<Check> {
     // Validate the arguments.
     if args.len() == 1 {
@@ -139,7 +139,7 @@ pub fn type_of_primitive(func: &Expr, args: &[Expr], location: Range) -> Option<
     None
 }
 
-/// U011
+/// UP011
 pub fn unnecessary_lru_cache_params(
     decorator_list: &[Expr],
     target_version: PythonVersion,

src/pyupgrade/fixes.rs

@@ -135,7 +135,7 @@ pub fn remove_super_arguments(locator: &SourceCodeLocator, expr: &Expr) -> Optio
     None
 }
 
-/// U010
+/// UP010
 pub fn remove_unnecessary_future_import(
     locator: &SourceCodeLocator,
     removable: &[usize],

src/pyupgrade/mod.rs

@@ -17,25 +17,25 @@ mod tests {
     use crate::settings;
     use crate::settings::types::PythonVersion;
 
-    #[test_case(CheckCode::U001, Path::new("U001.py"); "U001")]
-    #[test_case(CheckCode::U003, Path::new("U003.py"); "U003")]
-    #[test_case(CheckCode::U004, Path::new("U004.py"); "U004")]
-    #[test_case(CheckCode::U005, Path::new("U005.py"); "U005")]
-    #[test_case(CheckCode::U006, Path::new("U006.py"); "U006")]
-    #[test_case(CheckCode::U007, Path::new("U007.py"); "U007")]
-    #[test_case(CheckCode::U008, Path::new("U008.py"); "U008")]
-    #[test_case(CheckCode::U009, Path::new("U009_0.py"); "U009_0")]
-    #[test_case(CheckCode::U009, Path::new("U009_1.py"); "U009_1")]
-    #[test_case(CheckCode::U009, Path::new("U009_2.py"); "U009_2")]
-    #[test_case(CheckCode::U009, Path::new("U009_3.py"); "U009_3")]
-    #[test_case(CheckCode::U009, Path::new("U009_4.py"); "U009_4")]
-    #[test_case(CheckCode::U010, Path::new("U010.py"); "U010")]
-    #[test_case(CheckCode::U011, Path::new("U011_0.py"); "U011_0")]
-    #[test_case(CheckCode::U011, Path::new("U011_1.py"); "U011_1")]
-    #[test_case(CheckCode::U012, Path::new("U012.py"); "U012")]
-    #[test_case(CheckCode::U013, Path::new("U013.py"); "U013")]
-    #[test_case(CheckCode::U014, Path::new("U014.py"); "U014")]
-    #[test_case(CheckCode::U015, Path::new("U015.py"); "U015")]
+    #[test_case(CheckCode::UP001, Path::new("UP001.py"); "UP001")]
+    #[test_case(CheckCode::UP003, Path::new("UP003.py"); "UP003")]
+    #[test_case(CheckCode::UP004, Path::new("UP004.py"); "UP004")]
+    #[test_case(CheckCode::UP005, Path::new("UP005.py"); "UP005")]
+    #[test_case(CheckCode::UP006, Path::new("UP006.py"); "UP006")]
+    #[test_case(CheckCode::UP007, Path::new("UP007.py"); "UP007")]
+    #[test_case(CheckCode::UP008, Path::new("UP008.py"); "UP008")]
+    #[test_case(CheckCode::UP009, Path::new("UP009_0.py"); "UP009_0")]
+    #[test_case(CheckCode::UP009, Path::new("UP009_1.py"); "UP009_1")]
+    #[test_case(CheckCode::UP009, Path::new("UP009_2.py"); "UP009_2")]
+    #[test_case(CheckCode::UP009, Path::new("UP009_3.py"); "UP009_3")]
+    #[test_case(CheckCode::UP009, Path::new("UP009_4.py"); "UP009_4")]
+    #[test_case(CheckCode::UP010, Path::new("UP010.py"); "UP010")]
+    #[test_case(CheckCode::UP011, Path::new("UP011_0.py"); "UP011_0")]
+    #[test_case(CheckCode::UP011, Path::new("UP011_1.py"); "UP011_1")]
+    #[test_case(CheckCode::UP012, Path::new("UP012.py"); "UP012")]
+    #[test_case(CheckCode::UP013, Path::new("UP013.py"); "UP013")]
+    #[test_case(CheckCode::UP014, Path::new("UP014.py"); "UP014")]
+    #[test_case(CheckCode::UP015, Path::new("UP015.py"); "UP015")]
     fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
         let mut checks = test_path(
@@ -56,7 +56,7 @@ mod tests {
             Path::new("./resources/test/fixtures/pyupgrade/future_annotations.py"),
             &settings::Settings {
                 target_version: PythonVersion::Py37,
-                ..settings::Settings::for_rule(CheckCode::U006)
+                ..settings::Settings::for_rule(CheckCode::UP006)
             },
             true,
         )?;
@@ -71,7 +71,7 @@ mod tests {
             Path::new("./resources/test/fixtures/pyupgrade/future_annotations.py"),
             &settings::Settings {
                 target_version: PythonVersion::Py310,
-                ..settings::Settings::for_rule(CheckCode::U006)
+                ..settings::Settings::for_rule(CheckCode::UP006)
             },
             true,
         )?;
@@ -86,7 +86,7 @@ mod tests {
             Path::new("./resources/test/fixtures/pyupgrade/future_annotations.py"),
             &settings::Settings {
                 target_version: PythonVersion::Py37,
-                ..settings::Settings::for_rule(CheckCode::U007)
+                ..settings::Settings::for_rule(CheckCode::UP007)
             },
             true,
         )?;
@@ -101,7 +101,7 @@ mod tests {
             Path::new("./resources/test/fixtures/pyupgrade/future_annotations.py"),
             &settings::Settings {
                 target_version: PythonVersion::Py310,
-                ..settings::Settings::for_rule(CheckCode::U007)
+                ..settings::Settings::for_rule(CheckCode::UP007)
             },
             true,
         )?;

src/pyupgrade/plugins/convert_named_tuple_functional_to_class.rs

@@ -181,7 +181,7 @@ fn convert_to_class(
     ))
 }
 
-/// U014
+/// UP014
 pub fn convert_named_tuple_functional_to_class(
     checker: &mut Checker,
     stmt: &Stmt,

src/pyupgrade/plugins/convert_typed_dict_functional_to_class.rs

@@ -218,7 +218,7 @@ fn convert_to_class(
     ))
 }
 
-/// U013
+/// UP013
 pub fn convert_typed_dict_functional_to_class(
     checker: &mut Checker,
     stmt: &Stmt,

src/pyupgrade/plugins/deprecated_unittest_alias.rs

@@ -27,7 +27,7 @@ static DEPRECATED_ALIASES: Lazy<FxHashMap<&'static str, &'static str>> = Lazy::n
     ])
 });
 
-/// U005
+/// UP005
 pub fn deprecated_unittest_alias(checker: &mut Checker, expr: &Expr) {
     if let ExprKind::Attribute { value, attr, .. } = &expr.node {
         if let Some(&target) = DEPRECATED_ALIASES.get(attr.as_str()) {

src/pyupgrade/plugins/redundant_open_modes.rs

@@ -6,7 +6,7 @@ use rustpython_ast::{Constant, Expr, ExprKind, Keyword, KeywordData, Location};
 use rustpython_parser::lexer;
 use rustpython_parser::token::Tok;
 
-use crate::ast::helpers::{self, match_name_or_attr};
+use crate::ast::helpers;
 use crate::ast::types::Range;
 use crate::autofix::Fix;
 use crate::check_ast::Checker;
@@ -64,7 +64,7 @@ fn match_open(expr: &Expr) -> (Option<&Expr>, Vec<Keyword>) {
         keywords,
     } = &expr.node
     {
-        if match_name_or_attr(func, OPEN_FUNC_NAME) {
+        if matches!(&func.node, ExprKind::Name {id, ..} if id == OPEN_FUNC_NAME) {
             // Return the "open mode" parameter and keywords.
             return (args.get(1), keywords.clone());
         }
@@ -146,7 +146,7 @@ fn create_remove_param_fix(
     }
 }
 
-/// U015
+/// UP015
 pub fn redundant_open_modes(checker: &mut Checker, expr: &Expr) {
     // If `open` has been rebound, skip this check entirely.
     if !checker.is_builtin(OPEN_FUNC_NAME) {
@@ -177,7 +177,7 @@ pub fn redundant_open_modes(checker: &mut Checker, expr: &Expr) {
                         value,
                         mode.replacement_value(),
                         checker.locator,
-                        checker.patch(&CheckCode::U015),
+                        checker.patch(&CheckCode::UP015),
                     ));
                 }
             }
@@ -194,7 +194,7 @@ pub fn redundant_open_modes(checker: &mut Checker, expr: &Expr) {
                     mode_param,
                     mode.replacement_value(),
                     checker.locator,
-                    checker.patch(&CheckCode::U015),
+                    checker.patch(&CheckCode::UP015),
                 ));
             }
         }

src/pyupgrade/plugins/super_call_with_parameters.rs

@@ -5,7 +5,7 @@ use crate::check_ast::Checker;
 use crate::pyupgrade;
 use crate::pyupgrade::checks;
 
-/// U008
+/// UP008
 pub fn super_call_with_parameters(checker: &mut Checker, expr: &Expr, func: &Expr, args: &[Expr]) {
     // Only bother going through the super check at all if we're in a `super` call.
     // (We check this in `check_super_args` too, so this is just an optimization.)

src/pyupgrade/plugins/type_of_primitive.rs

@@ -6,7 +6,7 @@ use crate::check_ast::Checker;
 use crate::checks::CheckKind;
 use crate::pyupgrade::checks;
 
-/// U003
+/// UP003
 pub fn type_of_primitive(checker: &mut Checker, expr: &Expr, func: &Expr, args: &[Expr]) {
     if let Some(mut check) = checks::type_of_primitive(func, args, Range::from_located(expr)) {
         if checker.patch(check.kind.code()) {

src/pyupgrade/plugins/unnecessary_encode_utf8.rs

@@ -101,7 +101,7 @@ fn replace_with_bytes_literal(
     check
 }
 
-/// U012
+/// UP012
 pub fn unnecessary_encode_utf8(
     checker: &mut Checker,
     expr: &Expr,
@@ -124,7 +124,7 @@ pub fn unnecessary_encode_utf8(
                             expr,
                             variable,
                             checker.locator,
-                            checker.patch(&CheckCode::U012),
+                            checker.patch(&CheckCode::UP012),
                         ));
                     } else {
                         // "unicode text©".encode("utf-8")
@@ -132,7 +132,7 @@ pub fn unnecessary_encode_utf8(
                             expr,
                             args,
                             kwargs,
-                            checker.patch(&CheckCode::U012),
+                            checker.patch(&CheckCode::UP012),
                         ) {
                             checker.add_check(check);
                         }
@@ -146,7 +146,7 @@ pub fn unnecessary_encode_utf8(
                         expr,
                         args,
                         kwargs,
-                        checker.patch(&CheckCode::U012),
+                        checker.patch(&CheckCode::UP012),
                     ) {
                         checker.add_check(check);
                     }

src/pyupgrade/plugins/unnecessary_future_import.rs

@@ -33,7 +33,7 @@ const PY37_PLUS_REMOVE_FUTURES: &[&str] = &[
     "generator_stop",
 ];
 
-/// U010
+/// UP010
 pub fn unnecessary_future_import(checker: &mut Checker, stmt: &Stmt, names: &[Located<AliasData>]) {
     let target_version = checker.settings.target_version;
 

src/pyupgrade/plugins/unnecessary_lru_cache_params.rs

@@ -4,7 +4,7 @@ use crate::autofix::Fix;
 use crate::check_ast::Checker;
 use crate::pyupgrade::checks;
 
-/// U011
+/// UP011
 pub fn unnecessary_lru_cache_params(checker: &mut Checker, decorator_list: &[Expr]) {
     if let Some(mut check) = checks::unnecessary_lru_cache_params(
         decorator_list,

src/pyupgrade/plugins/use_pep585_annotation.rs

@@ -5,7 +5,7 @@ use crate::autofix::Fix;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 
-/// U006
+/// UP006
 pub fn use_pep585_annotation(checker: &mut Checker, expr: &Expr, id: &str) {
     let replacement = *checker.import_aliases.get(id).unwrap_or(&id);
     let mut check = Check::new(

src/pyupgrade/plugins/use_pep604_annotation.rs

@@ -54,7 +54,7 @@ fn any_arg_is_str(slice: &Expr) -> bool {
     }
 }
 
-/// U007
+/// UP007
 pub fn use_pep604_annotation(checker: &mut Checker, expr: &Expr, value: &Expr, slice: &Expr) {
     // Avoid rewriting forward annotations.
     if any_arg_is_str(slice) {