Bump version to 0.0.66

Cargo.lock

@@ -1907,7 +1907,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.61"
+version = "0.0.66"
 dependencies = [
  "anyhow",
  "bincode",
@@ -1926,6 +1926,7 @@ dependencies = [
  "libcst",
  "log",
  "notify",
+ "num-bigint",
  "once_cell",
  "path-absolutize",
  "rayon",
@@ -1935,6 +1936,8 @@ dependencies = [
  "rustpython-parser",
  "serde",
  "serde_json",
+ "strum",
+ "strum_macros",
  "toml",
  "update-informer",
  "walkdir",
@@ -1955,7 +1958,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.1.0"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=4f457893efc381ad5c432576b24bcc7e4a08c641#4f457893efc381ad5c432576b24bcc7e4a08c641"
+source = "git+https://github.com/charliermarsh/RustPython.git?rev=778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f#778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f"
 dependencies = [
  "num-bigint",
  "rustpython-common",
@@ -1965,7 +1968,7 @@ dependencies = [
 [[package]]
 name = "rustpython-common"
 version = "0.0.0"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=4f457893efc381ad5c432576b24bcc7e4a08c641#4f457893efc381ad5c432576b24bcc7e4a08c641"
+source = "git+https://github.com/charliermarsh/RustPython.git?rev=778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f#778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f"
 dependencies = [
  "ascii",
  "cfg-if 1.0.0",
@@ -1988,7 +1991,7 @@ dependencies = [
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.1.2"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=4f457893efc381ad5c432576b24bcc7e4a08c641#4f457893efc381ad5c432576b24bcc7e4a08c641"
+source = "git+https://github.com/charliermarsh/RustPython.git?rev=778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f#778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f"
 dependencies = [
  "bincode",
  "bitflags",
@@ -2005,7 +2008,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.1.2"
-source = "git+https://github.com/charliermarsh/RustPython.git?rev=4f457893efc381ad5c432576b24bcc7e4a08c641#4f457893efc381ad5c432576b24bcc7e4a08c641"
+source = "git+https://github.com/charliermarsh/RustPython.git?rev=778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f#778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f"
 dependencies = [
  "ahash",
  "anyhow",
@@ -2252,6 +2255,28 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
+[[package]]
+name = "strum"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.24.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn",
+]
+
 [[package]]
 name = "syn"
 version = "1.0.101"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.61"
+version = "0.0.66"
 edition = "2021"
 
 [lib]
@@ -27,14 +27,17 @@ once_cell = { version = "1.13.1" }
 path-absolutize = { version = "3.0.13", features = ["once_cell_cache"] }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/charliermarsh/RustPython.git", rev = "4f457893efc381ad5c432576b24bcc7e4a08c641" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "4f457893efc381ad5c432576b24bcc7e4a08c641" }
-rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "4f457893efc381ad5c432576b24bcc7e4a08c641" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
+rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
 serde = { version = "1.0.143", features = ["derive"] }
 serde_json = { version = "1.0.83" }
 toml = { version = "0.5.9" }
 update-informer = { version = "0.5.0", default_features = false, features = ["pypi"], optional = true }
 walkdir = { version = "2.3.2" }
+strum = { version = "0.24.1", features = ["strum_macros"] }
+strum_macros = "0.24.3"
+num-bigint = "0.4.3"
 
 [dev-dependencies]
 insta = { version = "1.19.1", features = ["yaml"] }

README.md

@@ -286,7 +286,9 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | C405 | UnnecessaryLiteralSet | Unnecessary <list/tuple> literal - rewrite as a set literal |  |  |
 | C406 | UnnecessaryLiteralDict | Unnecessary <list/tuple> literal - rewrite as a dict literal |  |  |
 | C408 | UnnecessaryCollectionCall | Unnecessary <dict/list/tuple> call - rewrite as a literal |  |  |
-| SPR001 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` |  | 🛠 |
+| C409 | UnnecessaryLiteralWithinTupleCall | Unnecessary <list/tuple> literal passed to tuple() - remove the outer call to tuple() |  |  |
+| C410 | UnnecessaryLiteralWithinListCall | Unnecessary <list/tuple> literal passed to list() - rewrite as a list literal |  |  |
+| C415 | UnnecessarySubscriptReversal | Unnecessary subscript reversal of iterable within <reversed/set/sorted>() |  |  |
 | T201 | PrintFound | `print` found |  | 🛠 |
 | T203 | PPrintFound | `pprint` found |  | 🛠 |
 | U001 | UselessMetaclassType | `__metaclass__ = type` is implied |  | 🛠 |
@@ -294,9 +296,11 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | U003 | TypeOfPrimitive | Use `str` instead of `type(...)` |  | 🛠 |
 | U004 | UselessObjectInheritance | Class `...` inherits from object |  | 🛠 |
 | U005 | NoAssertEquals | `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)` |  | 🛠 |
 | M001 | UnusedNOQA | Unused `noqa` directive |  | 🛠 |
 
-
 ## Integrations
 
 ### PyCharm

examples/generate_rules_table.rs

@@ -1,13 +1,12 @@
 /// Generate a Markdown-compatible table of supported lint rules.
-use ruff::checks::{CheckCode, ALL_CHECK_CODES, DEFAULT_CHECK_CODES};
+use strum::IntoEnumIterator;
+
+use ruff::checks::{CheckCode, DEFAULT_CHECK_CODES};
 
 fn main() {
-    let mut check_codes: Vec<CheckCode> = ALL_CHECK_CODES.to_vec();
-    check_codes.sort();
-
     println!("| Code | Name | Message |     |     |");
     println!("| ---- | ---- | ------- | --- | --- |");
-    for check_code in check_codes {
+    for check_code in CheckCode::iter() {
         let check_kind = check_code.kind();
         let default_token = if DEFAULT_CHECK_CODES.contains(&check_code) {
             "✅"
@@ -17,9 +16,9 @@ fn main() {
         let fix_token = if check_kind.fixable() { "🛠" } else { "" };
         println!(
             "| {} | {} | {} | {} | {} |",
-            check_kind.code().as_str(),
-            check_kind.name(),
-            check_kind.body(),
+            check_kind.code().as_ref(),
+            check_kind.as_ref(),
+            check_kind.body().replace("|", r"\|"),
             default_token,
             fix_token
         );

resources/test/fixtures/C409.py

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

resources/test/fixtures/C410.py

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

resources/test/fixtures/C415.py

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

resources/test/fixtures/F401_0.py

@@ -65,3 +65,24 @@ b = Union["Nut", None]
 c = cast("Vegetable", b)
 
 Field = lambda default=MISSING: field(default=default)
+
+
+# Test: access a sub-importation via an alias.
+import pyarrow as pa
+import pyarrow.csv
+
+print(pa.csv.read_csv("test.csv"))
+
+
+# Test: referencing an import via TypeAlias.
+import sys
+
+import numpy as np
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+CustomInt: TypeAlias = "np.int8 | np.int16"

resources/test/fixtures/F401_1.py

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

resources/test/fixtures/F401_2.py

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

resources/test/fixtures/F401_3.py

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

resources/test/fixtures/F401_4.py

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

resources/test/fixtures/F821.py

@@ -122,3 +122,12 @@ class PEP593Test:
         dict["foo", "bar"],  # Expected to fail as undefined.
         123,
     ]
+
+
+def in_ipython_notebook() -> bool:
+    try:
+        # autoimported by notebooks
+        get_ipython()  # type: ignore[name-defined]
+    except NameError:
+        return False  # not in notebook
+    return True

resources/test/fixtures/M001.py

@@ -15,6 +15,9 @@ def f() -> None:
     # Invalid
     d = 1  # noqa: F841, E501
 
+    # Invalid (and unimplemented)
+    d = 1  # noqa: F841, W191
+
 
 # Valid
 _ = """Lorem ipsum dolor sit amet.

resources/test/fixtures/U005.py

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

resources/test/fixtures/U006.py

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

resources/test/fixtures/U007.py

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

src/ast.rs

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

src/ast/checks.rs

@@ -1,6 +1,7 @@
 use std::collections::BTreeSet;
 
 use itertools::izip;
+use num_bigint::BigInt;
 use regex::Regex;
 use rustpython_parser::ast::{
     Arg, ArgData, Arguments, Cmpop, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprKind,
@@ -360,23 +361,6 @@ pub fn check_duplicate_arguments(arguments: &Arguments) -> Vec<Check> {
     checks
 }
 
-/// Check AssertEquals compliance.
-pub fn check_assert_equals(expr: &Expr) -> Option<Check> {
-    if let ExprKind::Attribute { value, attr, .. } = &expr.node {
-        if attr == "assertEquals" {
-            if let ExprKind::Name { id, .. } = &value.node {
-                if id == "self" {
-                    return Some(Check::new(
-                        CheckKind::NoAssertEquals,
-                        Range::from_located(expr),
-                    ));
-                }
-            }
-        }
-    }
-    None
-}
-
 #[derive(Debug, PartialEq)]
 enum DictionaryKey<'a> {
     Constant(&'a Constant),
@@ -773,7 +757,7 @@ pub fn is_super_call_with_arguments(func: &Expr, args: &Vec<Expr>) -> bool {
     }
 }
 
-// flakes8-comprehensions
+// flake8-comprehensions
 /// Check `list(generator)` compliance.
 pub fn unnecessary_generator_list(expr: &Expr, func: &Expr, args: &Vec<Expr>) -> Option<Check> {
     if args.len() == 1 {
@@ -985,6 +969,104 @@ pub fn unnecessary_collection_call(
     None
 }
 
+pub fn unnecessary_literal_within_tuple_call(
+    expr: &Expr,
+    func: &Expr,
+    args: &[Expr],
+) -> Option<Check> {
+    if let ExprKind::Name { id, .. } = &func.node {
+        if id == "tuple" {
+            if let Some(arg) = args.first() {
+                match &arg.node {
+                    ExprKind::Tuple { .. } => {
+                        return Some(Check::new(
+                            CheckKind::UnnecessaryLiteralWithinTupleCall("tuple".to_string()),
+                            Range::from_located(expr),
+                        ));
+                    }
+                    ExprKind::List { .. } => {
+                        return Some(Check::new(
+                            CheckKind::UnnecessaryLiteralWithinTupleCall("list".to_string()),
+                            Range::from_located(expr),
+                        ));
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    None
+}
+
+pub fn unnecessary_literal_within_list_call(
+    expr: &Expr,
+    func: &Expr,
+    args: &[Expr],
+) -> Option<Check> {
+    if let ExprKind::Name { id, .. } = &func.node {
+        if id == "list" {
+            if let Some(arg) = args.first() {
+                match &arg.node {
+                    ExprKind::Tuple { .. } => {
+                        return Some(Check::new(
+                            CheckKind::UnnecessaryLiteralWithinListCall("tuple".to_string()),
+                            Range::from_located(expr),
+                        ));
+                    }
+                    ExprKind::List { .. } => {
+                        return Some(Check::new(
+                            CheckKind::UnnecessaryLiteralWithinListCall("list".to_string()),
+                            Range::from_located(expr),
+                        ));
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    None
+}
+
+pub fn unnecessary_subscript_reversal(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
+    if let Some(first_arg) = args.first() {
+        if let ExprKind::Name { id, .. } = &func.node {
+            if id == "set" || id == "sorted" || id == "reversed" {
+                if let ExprKind::Subscript { slice, .. } = &first_arg.node {
+                    if let ExprKind::Slice { lower, upper, step } = &slice.node {
+                        if lower.is_none() && upper.is_none() {
+                            if let Some(step) = step {
+                                if let ExprKind::UnaryOp {
+                                    op: Unaryop::USub,
+                                    operand,
+                                } = &step.node
+                                {
+                                    if let ExprKind::Constant {
+                                        value: Constant::Int(val),
+                                        ..
+                                    } = &operand.node
+                                    {
+                                        if *val == BigInt::from(1) {
+                                            return Some(Check::new(
+                                                CheckKind::UnnecessarySubscriptReversal(
+                                                    id.to_string(),
+                                                ),
+                                                Range::from_located(expr),
+                                            ));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    None
+}
+
 // flake8-super
 /// Check that `super()` has no args
 pub fn check_super_args(

src/ast/helpers.rs

@@ -0,0 +1,107 @@
+use once_cell::sync::Lazy;
+use regex::Regex;
+use rustpython_ast::{Excepthandler, ExcepthandlerKind, Expr, ExprKind, StmtKind};
+
+use crate::python::typing;
+
+static DUNDER_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"__[^\s]+__").unwrap());
+
+pub enum SubscriptKind {
+    AnnotatedSubscript,
+    PEP593AnnotatedSubscript,
+}
+
+pub fn match_annotated_subscript(expr: &Expr) -> Option<SubscriptKind> {
+    match &expr.node {
+        ExprKind::Attribute { attr, .. } => {
+            if typing::is_annotated_subscript(attr) {
+                Some(SubscriptKind::AnnotatedSubscript)
+            } else if typing::is_pep593_annotated_subscript(attr) {
+                Some(SubscriptKind::PEP593AnnotatedSubscript)
+            } else {
+                None
+            }
+        }
+        ExprKind::Name { id, .. } => {
+            if typing::is_annotated_subscript(id) {
+                Some(SubscriptKind::AnnotatedSubscript)
+            } else if typing::is_pep593_annotated_subscript(id) {
+                Some(SubscriptKind::PEP593AnnotatedSubscript)
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+fn node_name(expr: &Expr) -> Option<&str> {
+    if let ExprKind::Name { id, .. } = &expr.node {
+        Some(id)
+    } else {
+        None
+    }
+}
+
+pub fn match_name_or_attr(expr: &Expr, target: &str) -> bool {
+    match &expr.node {
+        ExprKind::Attribute { attr, .. } => target == attr,
+        ExprKind::Name { id, .. } => target == id,
+        _ => false,
+    }
+}
+
+pub fn is_assignment_to_a_dunder(node: &StmtKind) -> bool {
+    // Check whether it's an assignment to a dunder, with or without a type annotation.
+    // This is what pycodestyle (as of 2.9.1) does.
+    match node {
+        StmtKind::Assign {
+            targets,
+            value: _,
+            type_comment: _,
+        } => {
+            if targets.len() != 1 {
+                return false;
+            }
+            match &targets[0].node {
+                ExprKind::Name { id, ctx: _ } => DUNDER_REGEX.is_match(id),
+                _ => false,
+            }
+        }
+        StmtKind::AnnAssign {
+            target,
+            annotation: _,
+            value: _,
+            simple: _,
+        } => match &target.node {
+            ExprKind::Name { id, ctx: _ } => DUNDER_REGEX.is_match(id),
+            _ => false,
+        },
+        _ => false,
+    }
+}
+
+/// Extract the names of all handled exceptions.
+/// Note that, for now, this only matches on ExprKind::Name, and so won't catch exceptions like
+/// `module.CustomException`. (But will catch all builtin exceptions.)
+pub fn extract_handler_names(handlers: &[Excepthandler]) -> Vec<&str> {
+    let mut handler_names = vec![];
+    for handler in handlers {
+        match &handler.node {
+            ExcepthandlerKind::ExceptHandler { type_, .. } => {
+                if let Some(type_) = type_ {
+                    if let ExprKind::Tuple { elts, .. } = &type_.node {
+                        for type_ in elts {
+                            if let Some(name) = node_name(type_) {
+                                handler_names.push(name);
+                            }
+                        }
+                    } else if let Some(name) = node_name(type_) {
+                        handler_names.push(name);
+                    }
+                }
+            }
+        }
+    }
+    handler_names
+}

src/ast/types.rs

@@ -74,9 +74,9 @@ pub enum BindingKind {
     Export(Vec<String>),
     FutureImportation,
     StarImportation,
-    Importation(String, BindingContext),
-    FromImportation(String, BindingContext),
-    SubmoduleImportation(String, BindingContext),
+    Importation(String, String, BindingContext),
+    FromImportation(String, String, BindingContext),
+    SubmoduleImportation(String, String, BindingContext),
 }
 
 #[derive(Clone, Debug)]

src/ast/visitor.rs

@@ -1,3 +1,4 @@
+use crate::ast::helpers::match_name_or_attr;
 use rustpython_parser::ast::{
     Alias, Arg, Arguments, Boolop, Cmpop, Comprehension, Constant, Excepthandler,
     ExcepthandlerKind, Expr, ExprContext, ExprKind, Keyword, MatchCase, Operator, Pattern,
@@ -148,7 +149,11 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
         } => {
             visitor.visit_annotation(annotation);
             if let Some(expr) = value {
-                visitor.visit_expr(expr);
+                if match_name_or_attr(annotation, "TypeAlias") {
+                    visitor.visit_annotation(expr);
+                } else {
+                    visitor.visit_expr(expr);
+                }
             }
             visitor.visit_expr(target);
         }

src/check_ast.rs

@@ -3,14 +3,14 @@ use std::ops::Deref;
 use std::path::Path;
 
 use log::error;
-use once_cell::sync::Lazy;
-use regex::Regex;
+use rustpython_ast::Location;
 use rustpython_parser::ast::{
     Arg, Arguments, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind,
     KeywordData, Operator, Stmt, StmtKind, Suite,
 };
 use rustpython_parser::parser;
 
+use crate::ast::helpers::{extract_handler_names, match_name_or_attr, SubscriptKind};
 use crate::ast::operations::{extract_all_names, SourceCodeLocator};
 use crate::ast::relocate::relocate_expr;
 use crate::ast::types::{
@@ -18,19 +18,16 @@ use crate::ast::types::{
     ScopeKind,
 };
 use crate::ast::visitor::{walk_excepthandler, Visitor};
-use crate::ast::{checks, operations, visitor};
+use crate::ast::{checks, helpers, operations, visitor};
 use crate::autofix::{fixer, fixes};
 use crate::checks::{Check, CheckCode, CheckKind};
 use crate::plugins;
 use crate::python::builtins::{BUILTINS, MAGIC_GLOBALS};
 use crate::python::future::ALL_FEATURE_NAMES;
-use crate::python::typing;
 use crate::settings::{PythonVersion, Settings};
 
 pub const GLOBAL_SCOPE_INDEX: usize = 0;
 
-static DUNDER_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"__[^\s]+__").unwrap());
-
 pub struct Checker<'a> {
     // Input data.
     path: &'a Path,
@@ -63,6 +60,7 @@ pub struct Checker<'a> {
     seen_docstring: bool,
     futures_allowed: bool,
     annotations_future_enabled: bool,
+    except_handlers: Vec<Vec<&'a str>>,
 }
 
 impl<'a> Checker<'a> {
@@ -77,96 +75,30 @@ impl<'a> Checker<'a> {
             autofix,
             path,
             locator: SourceCodeLocator::new(content),
-            checks: vec![],
-            parents: vec![],
-            parent_stack: vec![],
-            scopes: vec![],
-            scope_stack: vec![],
-            dead_scopes: vec![],
-            deferred_string_annotations: vec![],
-            deferred_annotations: vec![],
-            deferred_functions: vec![],
-            deferred_lambdas: vec![],
-            deferred_assignments: vec![],
-            in_f_string: None,
-            in_annotation: false,
-            in_literal: false,
-            seen_non_import: false,
-            seen_docstring: false,
-            futures_allowed: true,
-            annotations_future_enabled: false,
+            checks: Default::default(),
             deletions: Default::default(),
+            parents: Default::default(),
+            parent_stack: Default::default(),
+            scopes: Default::default(),
+            scope_stack: Default::default(),
+            dead_scopes: Default::default(),
+            deferred_string_annotations: Default::default(),
+            deferred_annotations: Default::default(),
+            deferred_functions: Default::default(),
+            deferred_lambdas: Default::default(),
+            deferred_assignments: Default::default(),
+            in_f_string: None,
+            in_annotation: Default::default(),
+            in_literal: Default::default(),
+            seen_non_import: Default::default(),
+            seen_docstring: Default::default(),
+            futures_allowed: true,
+            annotations_future_enabled: Default::default(),
+            except_handlers: Default::default(),
         }
     }
 }
 
-fn match_name_or_attr(expr: &Expr, target: &str) -> bool {
-    match &expr.node {
-        ExprKind::Attribute { attr, .. } => target == attr,
-        ExprKind::Name { id, .. } => target == id,
-        _ => false,
-    }
-}
-
-enum SubscriptKind {
-    AnnotatedSubscript,
-    PEP593AnnotatedSubscript,
-}
-
-fn match_annotated_subscript(expr: &Expr) -> Option<SubscriptKind> {
-    match &expr.node {
-        ExprKind::Attribute { attr, .. } => {
-            if typing::is_annotated_subscript(attr) {
-                Some(SubscriptKind::AnnotatedSubscript)
-            } else if typing::is_pep593_annotated_subscript(attr) {
-                Some(SubscriptKind::PEP593AnnotatedSubscript)
-            } else {
-                None
-            }
-        }
-        ExprKind::Name { id, .. } => {
-            if typing::is_annotated_subscript(id) {
-                Some(SubscriptKind::AnnotatedSubscript)
-            } else if typing::is_pep593_annotated_subscript(id) {
-                Some(SubscriptKind::PEP593AnnotatedSubscript)
-            } else {
-                None
-            }
-        }
-        _ => None,
-    }
-}
-
-fn is_assignment_to_a_dunder(node: &StmtKind) -> bool {
-    // Check whether it's an assignment to a dunder, with or without a type annotation.
-    // This is what pycodestyle (as of 2.9.1) does.
-    match node {
-        StmtKind::Assign {
-            targets,
-            value: _,
-            type_comment: _,
-        } => {
-            if targets.len() != 1 {
-                return false;
-            }
-            match &targets[0].node {
-                ExprKind::Name { id, ctx: _ } => DUNDER_REGEX.is_match(id),
-                _ => false,
-            }
-        }
-        StmtKind::AnnAssign {
-            target,
-            annotation: _,
-            value: _,
-            simple: _,
-        } => match &target.node {
-            ExprKind::Name { id, ctx: _ } => DUNDER_REGEX.is_match(id),
-            _ => false,
-        },
-        _ => false,
-    }
-}
-
 impl<'a, 'b> Visitor<'b> for Checker<'a>
 where
     'b: 'a,
@@ -227,7 +159,7 @@ where
                 self.futures_allowed = false;
 
                 if !self.seen_non_import
-                    && !is_assignment_to_a_dunder(node)
+                    && !helpers::is_assignment_to_a_dunder(node)
                     && !operations::in_nested_block(&self.parent_stack, &self.parents)
                 {
                     self.seen_non_import = true;
@@ -434,13 +366,16 @@ where
 
                 for alias in names {
                     if alias.node.name.contains('.') && alias.node.asname.is_none() {
-                        // TODO(charlie): Multiple submodule imports with the same parent module
-                        // will be merged into a single binding.
+                        // Given `import foo.bar`, `name` would be "foo", and `full_name` would be
+                        // "foo.bar".
+                        let name = alias.node.name.split('.').next().unwrap();
+                        let full_name = &alias.node.name;
                         self.add_binding(
-                            alias.node.name.split('.').next().unwrap().to_string(),
+                            name.to_string(),
                             Binding {
                                 kind: BindingKind::SubmoduleImportation(
-                                    alias.node.name.to_string(),
+                                    name.to_string(),
+                                    full_name.to_string(),
                                     self.binding_context(),
                                 ),
                                 used: None,
@@ -452,19 +387,17 @@ where
                             self.check_builtin_shadowing(asname, Range::from_located(stmt), false);
                         }
 
+                        // Given `import foo`, `name` and `full_name` would both be `foo`.
+                        // Given `import foo as bar`, `name` would be `bar` and `full_name` would
+                        // be `foo`.
+                        let name = alias.node.asname.as_ref().unwrap_or(&alias.node.name);
+                        let full_name = &alias.node.name;
                         self.add_binding(
-                            alias
-                                .node
-                                .asname
-                                .clone()
-                                .unwrap_or_else(|| alias.node.name.clone()),
+                            name.to_string(),
                             Binding {
                                 kind: BindingKind::Importation(
-                                    alias
-                                        .node
-                                        .asname
-                                        .clone()
-                                        .unwrap_or_else(|| alias.node.name.clone()),
+                                    name.to_string(),
+                                    full_name.to_string(),
                                     self.binding_context(),
                                 ),
                                 used: None,
@@ -493,14 +426,10 @@ where
                 }
 
                 for alias in names {
-                    let name = alias
-                        .node
-                        .asname
-                        .clone()
-                        .unwrap_or_else(|| alias.node.name.clone());
                     if let Some("__future__") = module.as_deref() {
+                        let name = alias.node.asname.as_ref().unwrap_or(&alias.node.name);
                         self.add_binding(
-                            name,
+                            name.to_string(),
                             Binding {
                                 kind: BindingKind::FutureImportation,
                                 used: Some((
@@ -579,18 +508,26 @@ where
                             self.check_builtin_shadowing(asname, Range::from_located(stmt), false);
                         }
 
-                        let binding = Binding {
-                            kind: BindingKind::FromImportation(
-                                match module {
-                                    None => name.clone(),
-                                    Some(parent) => format!("{}.{}", parent, name),
-                                },
-                                self.binding_context(),
-                            ),
-                            used: None,
-                            range: Range::from_located(stmt),
+                        // Given `from foo import bar`, `name` would be "bar" and `full_name` would
+                        // be "foo.bar". Given `from foo import bar as baz`, `name` would be "baz"
+                        // and `full_name` would be "foo.bar".
+                        let name = alias.node.asname.as_ref().unwrap_or(&alias.node.name);
+                        let full_name = match module {
+                            None => alias.node.name.to_string(),
+                            Some(parent) => format!("{}.{}", parent, alias.node.name),
                         };
-                        self.add_binding(name, binding)
+                        self.add_binding(
+                            name.to_string(),
+                            Binding {
+                                kind: BindingKind::FromImportation(
+                                    name.to_string(),
+                                    full_name,
+                                    self.binding_context(),
+                                ),
+                                used: None,
+                                range: Range::from_located(stmt),
+                            },
+                        )
                     }
                 }
             }
@@ -666,6 +603,27 @@ where
                     self.visit_stmt(stmt);
                 }
             }
+            StmtKind::Try {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+            } => {
+                self.except_handlers.push(extract_handler_names(handlers));
+                for stmt in body {
+                    self.visit_stmt(stmt);
+                }
+                self.except_handlers.pop();
+                for excepthandler in handlers {
+                    self.visit_excepthandler(excepthandler)
+                }
+                for stmt in orelse {
+                    self.visit_stmt(stmt);
+                }
+                for stmt in finalbody {
+                    self.visit_stmt(stmt);
+                }
+            }
             _ => visitor::walk_stmt(self, stmt),
         };
 
@@ -698,18 +656,33 @@ where
         let prev_in_annotation = self.in_annotation;
 
         if self.in_annotation && self.annotations_future_enabled {
-            self.deferred_annotations.push((
-                expr,
-                self.scope_stack.clone(),
-                self.parent_stack.clone(),
-            ));
-            visitor::walk_expr(self, expr);
+            if let ExprKind::Constant {
+                value: Constant::Str(value),
+                ..
+            } = &expr.node
+            {
+                self.deferred_string_annotations
+                    .push((Range::from_located(expr), value));
+            } else {
+                self.deferred_annotations.push((
+                    expr,
+                    self.scope_stack.clone(),
+                    self.parent_stack.clone(),
+                ));
+            }
             return;
         }
 
         // Pre-visit.
         match &expr.node {
-            ExprKind::Subscript { value, .. } => {
+            ExprKind::Subscript { value, slice, .. } => {
+                // Ex) typing.List[...]
+                if self.settings.enabled.contains(&CheckCode::U007)
+                    && self.settings.target_version >= PythonVersion::Py39
+                {
+                    plugins::use_pep604_annotation(self, expr, value, slice);
+                }
+
                 if match_name_or_attr(value, "Literal") {
                     self.in_literal = true;
                 }
@@ -731,7 +704,16 @@ where
                 }
             }
             ExprKind::Name { id, ctx } => match ctx {
-                ExprContext::Load => self.handle_node_load(expr),
+                ExprContext::Load => {
+                    // Ex) List[...]
+                    if self.settings.enabled.contains(&CheckCode::U006)
+                        && self.settings.target_version >= PythonVersion::Py39
+                    {
+                        plugins::use_pep585_annotation(self, expr, id);
+                    }
+
+                    self.handle_node_load(expr);
+                }
                 ExprContext::Store => {
                     if self.settings.enabled.contains(&CheckCode::E741) {
                         if let Some(check) = checks::check_ambiguous_variable_name(
@@ -748,6 +730,18 @@ where
                 }
                 ExprContext::Del => self.handle_node_delete(expr),
             },
+            ExprKind::Attribute { value, attr, .. } => {
+                // Ex) typing.List[...]
+                if self.settings.enabled.contains(&CheckCode::U006)
+                    && self.settings.target_version >= PythonVersion::Py39
+                {
+                    if let ExprKind::Name { id, .. } = &value.node {
+                        if id == "typing" {
+                            plugins::use_pep585_annotation(self, expr, attr);
+                        }
+                    }
+                }
+            }
             ExprKind::Call {
                 func,
                 args,
@@ -755,11 +749,11 @@ where
                 ..
             } => {
                 if self.settings.enabled.contains(&CheckCode::U005) {
-                    plugins::assert_equals(self, func);
+                    plugins::deprecated_unittest_alias(self, func);
                 }
 
                 // flake8-super
-                if self.settings.enabled.contains(&CheckCode::SPR001) {
+                if self.settings.enabled.contains(&CheckCode::U008) {
                     plugins::super_call_with_parameters(self, expr, func, args);
                 }
 
@@ -825,6 +819,27 @@ where
                     };
                 }
 
+                if self.settings.enabled.contains(&CheckCode::C409) {
+                    if let Some(check) =
+                        checks::unnecessary_literal_within_tuple_call(expr, func, args)
+                    {
+                        self.checks.push(check);
+                    };
+                }
+
+                if self.settings.enabled.contains(&CheckCode::C410) {
+                    if let Some(check) =
+                        checks::unnecessary_literal_within_list_call(expr, func, args)
+                    {
+                        self.checks.push(check);
+                    };
+                }
+                if self.settings.enabled.contains(&CheckCode::C415) {
+                    if let Some(check) = checks::unnecessary_subscript_reversal(expr, func, args) {
+                        self.checks.push(check);
+                    };
+                }
+
                 // pyupgrade
                 if self.settings.enabled.contains(&CheckCode::U002)
                     && self.settings.target_version >= PythonVersion::Py310
@@ -1109,7 +1124,7 @@ where
                 }
             }
             ExprKind::Subscript { value, slice, ctx } => {
-                match match_annotated_subscript(value) {
+                match helpers::match_annotated_subscript(value) {
                     Some(subscript) => match subscript {
                         // Ex) Optional[int]
                         SubscriptKind::AnnotatedSubscript => {
@@ -1291,6 +1306,47 @@ impl CheckLocator for Checker<'_> {
     }
 }
 
+fn try_mark_used(scope: &mut Scope, scope_id: usize, id: &str, expr: &Expr) -> bool {
+    let alias = if let Some(binding) = scope.values.get_mut(id) {
+        // Mark the binding as used.
+        binding.used = Some((scope_id, Range::from_located(expr)));
+
+        // If the name of the sub-importation is the same as an alias of another importation and the
+        // alias is used, that sub-importation should be marked as used too.
+        //
+        // This handles code like:
+        //   import pyarrow as pa
+        //   import pyarrow.csv
+        //   print(pa.csv.read_csv("test.csv"))
+        if let BindingKind::Importation(name, full_name, _)
+        | BindingKind::FromImportation(name, full_name, _)
+        | BindingKind::SubmoduleImportation(name, full_name, _) = &binding.kind
+        {
+            let has_alias = full_name
+                .split('.')
+                .last()
+                .map(|segment| segment != name)
+                .unwrap_or_default();
+            if has_alias {
+                // Clone the alias. (We'll mutate it below.)
+                full_name.to_string()
+            } else {
+                return true;
+            }
+        } else {
+            return true;
+        }
+    } else {
+        return false;
+    };
+
+    // Mark the sub-importation as used.
+    if let Some(binding) = scope.values.get_mut(&alias) {
+        binding.used = Some((scope_id, Range::from_located(expr)));
+    }
+    true
+}
+
 impl<'a> Checker<'a> {
     pub fn add_check(&mut self, check: Check) {
         self.checks.push(check);
@@ -1374,7 +1430,11 @@ impl<'a> Checker<'a> {
                     && matches!(binding.kind, BindingKind::LoopVar)
                     && matches!(
                         existing.kind,
-                        BindingKind::Importation(_, _) | BindingKind::FromImportation(_, _)
+                        BindingKind::Importation(_, _, _)
+                            | BindingKind::FromImportation(_, _, _)
+                            | BindingKind::SubmoduleImportation(_, _, _)
+                            | BindingKind::StarImportation
+                            | BindingKind::FutureImportation
                     )
                 {
                     self.checks.push(Check::new(
@@ -1413,8 +1473,8 @@ impl<'a> Checker<'a> {
                         continue;
                     }
                 }
-                if let Some(binding) = scope.values.get_mut(id) {
-                    binding.used = Some((scope_id, Range::from_located(expr)));
+
+                if try_mark_used(scope, scope_id, id, expr) {
                     return;
                 }
 
@@ -1449,6 +1509,14 @@ impl<'a> Checker<'a> {
                 if self.path.ends_with("__init__.py") && id == "__path__" {
                     return;
                 }
+
+                // Avoid flagging if NameError is handled.
+                if let Some(handler_names) = self.except_handlers.last() {
+                    if handler_names.contains(&"NameError") {
+                        return;
+                    }
+                }
+
                 self.checks.push(Check::new(
                     CheckKind::UndefinedName(id.clone()),
                     self.locate_check(Range::from_located(expr)),
@@ -1584,14 +1652,37 @@ impl<'a> Checker<'a> {
     where
         'b: 'a,
     {
-        while let Some((location, expression)) = self.deferred_string_annotations.pop() {
+        while let Some((range, expression)) = self.deferred_string_annotations.pop() {
+            // HACK(charlie): We need to modify `range` such that it represents the range of the
+            // expression _within_ the string annotation (as opposed to the range of the string
+            // annotation itself). RustPython seems to return an off-by-one start column for every
+            // string value, so we check for double quotes (which are really triple quotes).
+            let contents = self.locator.slice_source_code_at(&range.location);
+            let range = if contents.starts_with("\"\"") || contents.starts_with("\'\'") {
+                Range {
+                    location: Location::new(range.location.row(), range.location.column() + 2),
+                    end_location: Location::new(
+                        range.end_location.row(),
+                        range.end_location.column() - 2,
+                    ),
+                }
+            } else {
+                Range {
+                    location: Location::new(range.location.row(), range.location.column()),
+                    end_location: Location::new(
+                        range.end_location.row(),
+                        range.end_location.column() - 1,
+                    ),
+                }
+            };
+
             if let Ok(mut expr) = parser::parse_expression(expression, "<filename>") {
-                relocate_expr(&mut expr, location);
+                relocate_expr(&mut expr, range);
                 allocator.push(expr);
             } else if self.settings.enabled.contains(&CheckCode::F722) {
                 self.checks.push(Check::new(
                     CheckKind::ForwardAnnotationSyntaxError(expression.to_string()),
-                    self.locate_check(location),
+                    self.locate_check(range),
                 ));
             }
         }
@@ -1726,7 +1817,7 @@ impl<'a> Checker<'a> {
 
                     if !used {
                         match &binding.kind {
-                            BindingKind::FromImportation(full_name, context) => {
+                            BindingKind::FromImportation(_, full_name, context) => {
                                 let full_names = unused
                                     .entry((
                                         ImportKind::ImportFrom,
@@ -1736,8 +1827,8 @@ impl<'a> Checker<'a> {
                                     .or_default();
                                 full_names.push(full_name);
                             }
-                            BindingKind::Importation(full_name, context)
-                            | BindingKind::SubmoduleImportation(full_name, context) => {
+                            BindingKind::Importation(_, full_name, context)
+                            | BindingKind::SubmoduleImportation(_, full_name, context) => {
                                 let full_names = unused
                                     .entry((
                                         ImportKind::Import,

src/check_lines.rs

@@ -1,8 +1,8 @@
 use std::collections::BTreeMap;
 
-use crate::ast::types::Range;
 use rustpython_parser::ast::Location;
 
+use crate::ast::types::Range;
 use crate::autofix::fixer;
 use crate::checks::{Check, CheckCode, CheckKind, Fix};
 use crate::noqa;
@@ -66,12 +66,12 @@ pub fn check_lines(
 
                 match noqa {
                     (Directive::All(_, _), matches) => {
-                        matches.push(check.kind.code().as_str());
+                        matches.push(check.kind.code().as_ref());
                         ignored.push(index)
                     }
                     (Directive::Codes(_, _, codes), matches) => {
-                        if codes.contains(&check.kind.code().as_str()) {
-                            matches.push(check.kind.code().as_str());
+                        if codes.contains(&check.kind.code().as_ref()) {
+                            matches.push(check.kind.code().as_ref());
                             ignored.push(index);
                         }
                     }
@@ -98,11 +98,11 @@ pub fn check_lines(
 
                 match noqa {
                     (Directive::All(_, _), matches) => {
-                        matches.push(check.kind.code().as_str());
+                        matches.push(check.kind.code().as_ref());
                     }
                     (Directive::Codes(_, _, codes), matches) => {
-                        if codes.contains(&check.kind.code().as_str()) {
-                            matches.push(check.kind.code().as_str());
+                        if codes.contains(&check.kind.code().as_ref()) {
+                            matches.push(check.kind.code().as_ref());
                         } else {
                             line_checks.push(check);
                         }
@@ -138,11 +138,11 @@ pub fn check_lines(
 
             match noqa {
                 (Directive::All(_, _), matches) => {
-                    matches.push(check.kind.code().as_str());
+                    matches.push(check.kind.code().as_ref());
                 }
                 (Directive::Codes(_, _, codes), matches) => {
-                    if codes.contains(&check.kind.code().as_str()) {
-                        matches.push(check.kind.code().as_str());
+                    if codes.contains(&check.kind.code().as_ref()) {
+                        matches.push(check.kind.code().as_ref());
                     } else {
                         line_checks.push(check);
                     }
@@ -184,15 +184,15 @@ pub fn check_lines(
                     let mut valid_codes = vec![];
                     for code in codes {
                         if !matches.contains(&code) {
-                            invalid_codes.push(code);
+                            invalid_codes.push(code.to_string());
                         } else {
-                            valid_codes.push(code);
+                            valid_codes.push(code.to_string());
                         }
                     }
 
                     if !invalid_codes.is_empty() {
                         let mut check = Check::new(
-                            CheckKind::UnusedNOQA(Some(invalid_codes.join(", "))),
+                            CheckKind::UnusedNOQA(Some(invalid_codes)),
                             Range {
                                 location: Location::new(row + 1, start + 1),
                                 end_location: Location::new(row + 1, end + 1),

src/checks.rs

@@ -1,11 +1,10 @@
-use std::str::FromStr;
-
-use crate::ast::checks::Primitive;
-use anyhow::Result;
 use itertools::Itertools;
 use rustpython_parser::ast::Location;
 use serde::{Deserialize, Serialize};
+use std::str::FromStr;
+use strum_macros::{AsRefStr, EnumIter, EnumString};
 
+use crate::ast::checks::Primitive;
 use crate::ast::types::Range;
 
 pub const DEFAULT_CHECK_CODES: [CheckCode; 43] = [
@@ -57,82 +56,20 @@ pub const DEFAULT_CHECK_CODES: [CheckCode; 43] = [
     CheckCode::F901,
 ];
 
-pub const ALL_CHECK_CODES: [CheckCode; 63] = [
-    // pycodestyle errors
-    CheckCode::E402,
-    CheckCode::E501,
-    CheckCode::E711,
-    CheckCode::E712,
-    CheckCode::E713,
-    CheckCode::E714,
-    CheckCode::E721,
-    CheckCode::E722,
-    CheckCode::E731,
-    CheckCode::E741,
-    CheckCode::E742,
-    CheckCode::E743,
-    CheckCode::E902,
-    CheckCode::E999,
-    // pycodestyle warnings
-    CheckCode::W292,
-    // pyflakes
-    CheckCode::F401,
-    CheckCode::F402,
-    CheckCode::F403,
-    CheckCode::F404,
-    CheckCode::F405,
-    CheckCode::F406,
-    CheckCode::F407,
-    CheckCode::F541,
-    CheckCode::F601,
-    CheckCode::F602,
-    CheckCode::F621,
-    CheckCode::F622,
-    CheckCode::F631,
-    CheckCode::F632,
-    CheckCode::F633,
-    CheckCode::F634,
-    CheckCode::F701,
-    CheckCode::F702,
-    CheckCode::F704,
-    CheckCode::F706,
-    CheckCode::F707,
-    CheckCode::F722,
-    CheckCode::F821,
-    CheckCode::F822,
-    CheckCode::F823,
-    CheckCode::F831,
-    CheckCode::F841,
-    CheckCode::F901,
-    // flake8-builtins
-    CheckCode::A001,
-    CheckCode::A002,
-    CheckCode::A003,
-    // flake8-comprehensions
-    CheckCode::C400,
-    CheckCode::C401,
-    CheckCode::C402,
-    CheckCode::C403,
-    CheckCode::C404,
-    CheckCode::C405,
-    CheckCode::C406,
-    CheckCode::C408,
-    // flake8-super
-    CheckCode::SPR001,
-    // flake8-print
-    CheckCode::T201,
-    CheckCode::T203,
-    // pyupgrade
-    CheckCode::U001,
-    CheckCode::U002,
-    CheckCode::U003,
-    CheckCode::U004,
-    CheckCode::U005,
-    // Meta
-    CheckCode::M001,
-];
-
-#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize, Hash, PartialOrd, Ord)]
+#[derive(
+    AsRefStr,
+    EnumIter,
+    EnumString,
+    Debug,
+    PartialEq,
+    Eq,
+    Clone,
+    Serialize,
+    Deserialize,
+    Hash,
+    PartialOrd,
+    Ord,
+)]
 pub enum CheckCode {
     // pycodestyle errors
     E402,
@@ -193,8 +130,9 @@ pub enum CheckCode {
     C405,
     C406,
     C408,
-    // flake8-super
-    SPR001,
+    C409,
+    C410,
+    C415,
     // flake8-print
     T201,
     T203,
@@ -204,170 +142,106 @@ pub enum CheckCode {
     U003,
     U004,
     U005,
+    U006,
+    U007,
+    U008,
     // Meta
     M001,
 }
 
-impl FromStr for CheckCode {
-    type Err = anyhow::Error;
+#[allow(clippy::upper_case_acronyms)]
+pub enum LintSource {
+    AST,
+    Lines,
+    FileSystem,
+}
 
-    fn from_str(s: &str) -> Result<Self> {
-        match s {
-            // pycodestyle errors
-            "E402" => Ok(CheckCode::E402),
-            "E501" => Ok(CheckCode::E501),
-            "E711" => Ok(CheckCode::E711),
-            "E712" => Ok(CheckCode::E712),
-            "E713" => Ok(CheckCode::E713),
-            "E714" => Ok(CheckCode::E714),
-            "E721" => Ok(CheckCode::E721),
-            "E722" => Ok(CheckCode::E722),
-            "E731" => Ok(CheckCode::E731),
-            "E741" => Ok(CheckCode::E741),
-            "E742" => Ok(CheckCode::E742),
-            "E743" => Ok(CheckCode::E743),
-            "E902" => Ok(CheckCode::E902),
-            "E999" => Ok(CheckCode::E999),
-            // pycodestyle warnings
-            "W292" => Ok(CheckCode::W292),
-            // pyflakes
-            "F401" => Ok(CheckCode::F401),
-            "F402" => Ok(CheckCode::F402),
-            "F403" => Ok(CheckCode::F403),
-            "F404" => Ok(CheckCode::F404),
-            "F405" => Ok(CheckCode::F405),
-            "F406" => Ok(CheckCode::F406),
-            "F407" => Ok(CheckCode::F407),
-            "F541" => Ok(CheckCode::F541),
-            "F601" => Ok(CheckCode::F601),
-            "F602" => Ok(CheckCode::F602),
-            "F621" => Ok(CheckCode::F621),
-            "F622" => Ok(CheckCode::F622),
-            "F631" => Ok(CheckCode::F631),
-            "F632" => Ok(CheckCode::F632),
-            "F633" => Ok(CheckCode::F633),
-            "F634" => Ok(CheckCode::F634),
-            "F701" => Ok(CheckCode::F701),
-            "F702" => Ok(CheckCode::F702),
-            "F704" => Ok(CheckCode::F704),
-            "F706" => Ok(CheckCode::F706),
-            "F707" => Ok(CheckCode::F707),
-            "F722" => Ok(CheckCode::F722),
-            "F821" => Ok(CheckCode::F821),
-            "F822" => Ok(CheckCode::F822),
-            "F823" => Ok(CheckCode::F823),
-            "F831" => Ok(CheckCode::F831),
-            "F841" => Ok(CheckCode::F841),
-            "F901" => Ok(CheckCode::F901),
-            // flake8-builtins
-            "A001" => Ok(CheckCode::A001),
-            "A002" => Ok(CheckCode::A002),
-            "A003" => Ok(CheckCode::A003),
-            // flake8-comprehensions
-            "C400" => Ok(CheckCode::C400),
-            "C401" => Ok(CheckCode::C401),
-            "C402" => Ok(CheckCode::C402),
-            "C403" => Ok(CheckCode::C403),
-            "C404" => Ok(CheckCode::C404),
-            "C405" => Ok(CheckCode::C405),
-            "C406" => Ok(CheckCode::C406),
-            "C408" => Ok(CheckCode::C408),
-            // flake8-super
-            "SPR001" => Ok(CheckCode::SPR001),
-            // flake8-print
-            "T201" => Ok(CheckCode::T201),
-            "T203" => Ok(CheckCode::T203),
-            // pyupgrade
-            "U001" => Ok(CheckCode::U001),
-            "U002" => Ok(CheckCode::U002),
-            "U003" => Ok(CheckCode::U003),
-            "U004" => Ok(CheckCode::U004),
-            "U005" => Ok(CheckCode::U005),
-            // Meta
-            "M001" => Ok(CheckCode::M001),
-            _ => Err(anyhow::anyhow!("Unknown check code: {s}")),
-        }
-    }
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum RejectedCmpop {
+    Eq,
+    NotEq,
+}
+
+#[derive(AsRefStr, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum CheckKind {
+    // pycodestyle errors
+    AmbiguousClassName(String),
+    AmbiguousFunctionName(String),
+    AmbiguousVariableName(String),
+    AssertTuple,
+    BreakOutsideLoop,
+    ContinueOutsideLoop,
+    DefaultExceptNotLast,
+    DoNotAssignLambda,
+    DoNotUseBareExcept,
+    DuplicateArgumentName,
+    ExpressionsInStarAssignment,
+    FStringMissingPlaceholders,
+    ForwardAnnotationSyntaxError(String),
+    FutureFeatureNotDefined(String),
+    IOError(String),
+    IfTuple,
+    ImportShadowedByLoopVar(String, usize),
+    ImportStarNotPermitted(String),
+    ImportStarUsage(String, Vec<String>),
+    ImportStarUsed(String),
+    InvalidPrintSyntax,
+    IsLiteral,
+    LateFutureImport,
+    LineTooLong(usize, usize),
+    ModuleImportNotAtTopOfFile,
+    MultiValueRepeatedKeyLiteral,
+    MultiValueRepeatedKeyVariable(String),
+    NoneComparison(RejectedCmpop),
+    NotInTest,
+    NotIsTest,
+    RaiseNotImplemented,
+    ReturnOutsideFunction,
+    SyntaxError(String),
+    TrueFalseComparison(bool, RejectedCmpop),
+    TwoStarredExpressions,
+    TypeComparison,
+    UndefinedExport(String),
+    UndefinedLocal(String),
+    UndefinedName(String),
+    UnusedImport(Vec<String>),
+    UnusedVariable(String),
+    YieldOutsideFunction,
+    // pycodestyle warnings
+    NoNewLineAtEndOfFile,
+    // flake8-builtin
+    BuiltinVariableShadowing(String),
+    BuiltinArgumentShadowing(String),
+    BuiltinAttributeShadowing(String),
+    // flake8-comprehensions
+    UnnecessaryGeneratorList,
+    UnnecessaryGeneratorSet,
+    UnnecessaryGeneratorDict,
+    UnnecessaryListComprehensionSet,
+    UnnecessaryListComprehensionDict,
+    UnnecessaryLiteralSet(String),
+    UnnecessaryLiteralDict(String),
+    UnnecessaryCollectionCall(String),
+    UnnecessaryLiteralWithinTupleCall(String),
+    UnnecessaryLiteralWithinListCall(String),
+    UnnecessarySubscriptReversal(String),
+    // flake8-print
+    PrintFound,
+    PPrintFound,
+    // pyupgrade
+    TypeOfPrimitive(Primitive),
+    UnnecessaryAbspath,
+    UselessMetaclassType,
+    DeprecatedUnittestAlias(String, String),
+    UselessObjectInheritance(String),
+    UsePEP585Annotation(String),
+    UsePEP604Annotation,
+    SuperCallWithParameters,
+    // Meta
+    UnusedNOQA(Option<Vec<String>>),
 }
 
 impl CheckCode {
-    pub fn as_str(&self) -> &str {
-        match self {
-            // pycodestyle errors
-            CheckCode::E402 => "E402",
-            CheckCode::E501 => "E501",
-            CheckCode::E711 => "E711",
-            CheckCode::E712 => "E712",
-            CheckCode::E713 => "E713",
-            CheckCode::E714 => "E714",
-            CheckCode::E721 => "E721",
-            CheckCode::E722 => "E722",
-            CheckCode::E731 => "E731",
-            CheckCode::E741 => "E741",
-            CheckCode::E742 => "E742",
-            CheckCode::E743 => "E743",
-            CheckCode::E902 => "E902",
-            CheckCode::E999 => "E999",
-            // pycodestyle warnings
-            CheckCode::W292 => "W292",
-            // pyflakes
-            CheckCode::F401 => "F401",
-            CheckCode::F402 => "F402",
-            CheckCode::F403 => "F403",
-            CheckCode::F404 => "F404",
-            CheckCode::F405 => "F405",
-            CheckCode::F406 => "F406",
-            CheckCode::F407 => "F407",
-            CheckCode::F541 => "F541",
-            CheckCode::F601 => "F601",
-            CheckCode::F602 => "F602",
-            CheckCode::F621 => "F621",
-            CheckCode::F622 => "F622",
-            CheckCode::F631 => "F631",
-            CheckCode::F632 => "F632",
-            CheckCode::F633 => "F633",
-            CheckCode::F634 => "F634",
-            CheckCode::F701 => "F701",
-            CheckCode::F702 => "F702",
-            CheckCode::F704 => "F704",
-            CheckCode::F706 => "F706",
-            CheckCode::F707 => "F707",
-            CheckCode::F722 => "F722",
-            CheckCode::F821 => "F821",
-            CheckCode::F822 => "F822",
-            CheckCode::F823 => "F823",
-            CheckCode::F831 => "F831",
-            CheckCode::F841 => "F841",
-            CheckCode::F901 => "F901",
-            // flake8-builtins
-            CheckCode::A001 => "A001",
-            CheckCode::A002 => "A002",
-            CheckCode::A003 => "A003",
-            // flake8-comprehensions
-            CheckCode::C400 => "C400",
-            CheckCode::C401 => "C401",
-            CheckCode::C402 => "C402",
-            CheckCode::C403 => "C403",
-            CheckCode::C404 => "C404",
-            CheckCode::C405 => "C405",
-            CheckCode::C406 => "C406",
-            CheckCode::C408 => "C408",
-            // flake8-super
-            CheckCode::SPR001 => "SPR001",
-            // flake8-print
-            CheckCode::T201 => "T201",
-            CheckCode::T203 => "T203",
-            // pyupgrade
-            CheckCode::U001 => "U001",
-            CheckCode::U002 => "U002",
-            CheckCode::U003 => "U003",
-            CheckCode::U004 => "U004",
-            CheckCode::U005 => "U005",
-            // Meta
-            CheckCode::M001 => "M001",
-        }
-    }
-
     /// The source for the check (either the AST, the filesystem, or the physical lines).
     pub fn lint_source(&self) -> &'static LintSource {
         match self {
@@ -443,8 +317,15 @@ impl CheckCode {
             CheckCode::C408 => {
                 CheckKind::UnnecessaryCollectionCall("<dict/list/tuple>".to_string())
             }
-            // flake8-super
-            CheckCode::SPR001 => CheckKind::SuperCallWithParameters,
+            CheckCode::C409 => {
+                CheckKind::UnnecessaryLiteralWithinTupleCall("<list/tuple>".to_string())
+            }
+            CheckCode::C410 => {
+                CheckKind::UnnecessaryLiteralWithinListCall("<list/tuple>".to_string())
+            }
+            CheckCode::C415 => {
+                CheckKind::UnnecessarySubscriptReversal("<reversed/set/sorted>".to_string())
+            }
             // flake8-print
             CheckCode::T201 => CheckKind::PrintFound,
             CheckCode::T203 => CheckKind::PPrintFound,
@@ -453,180 +334,24 @@ impl CheckCode {
             CheckCode::U002 => CheckKind::UnnecessaryAbspath,
             CheckCode::U003 => CheckKind::TypeOfPrimitive(Primitive::Str),
             CheckCode::U004 => CheckKind::UselessObjectInheritance("...".to_string()),
-            CheckCode::U005 => CheckKind::NoAssertEquals,
+            CheckCode::U005 => CheckKind::DeprecatedUnittestAlias(
+                "assertEquals".to_string(),
+                "assertEqual".to_string(),
+            ),
+            CheckCode::U006 => CheckKind::UsePEP585Annotation("List".to_string()),
+            CheckCode::U007 => CheckKind::UsePEP604Annotation,
+            CheckCode::U008 => CheckKind::SuperCallWithParameters,
             // Meta
             CheckCode::M001 => CheckKind::UnusedNOQA(None),
         }
     }
 }
 
-#[allow(clippy::upper_case_acronyms)]
-pub enum LintSource {
-    AST,
-    Lines,
-    FileSystem,
-}
-
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub enum RejectedCmpop {
-    Eq,
-    NotEq,
-}
-
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub enum CheckKind {
-    AmbiguousClassName(String),
-    AmbiguousFunctionName(String),
-    AmbiguousVariableName(String),
-    AssertTuple,
-    BreakOutsideLoop,
-    ContinueOutsideLoop,
-    DefaultExceptNotLast,
-    DoNotAssignLambda,
-    DoNotUseBareExcept,
-    DuplicateArgumentName,
-    ExpressionsInStarAssignment,
-    FStringMissingPlaceholders,
-    ForwardAnnotationSyntaxError(String),
-    FutureFeatureNotDefined(String),
-    IOError(String),
-    IfTuple,
-    ImportShadowedByLoopVar(String, usize),
-    ImportStarNotPermitted(String),
-    ImportStarUsage(String, Vec<String>),
-    ImportStarUsed(String),
-    InvalidPrintSyntax,
-    IsLiteral,
-    LateFutureImport,
-    LineTooLong(usize, usize),
-    ModuleImportNotAtTopOfFile,
-    MultiValueRepeatedKeyLiteral,
-    MultiValueRepeatedKeyVariable(String),
-    NoneComparison(RejectedCmpop),
-    NotInTest,
-    NotIsTest,
-    RaiseNotImplemented,
-    ReturnOutsideFunction,
-    SyntaxError(String),
-    TrueFalseComparison(bool, RejectedCmpop),
-    TwoStarredExpressions,
-    TypeComparison,
-    UndefinedExport(String),
-    UndefinedLocal(String),
-    UndefinedName(String),
-    UnusedImport(Vec<String>),
-    UnusedVariable(String),
-    YieldOutsideFunction,
-    // More style
-    NoNewLineAtEndOfFile,
-    // flake8-builtin
-    BuiltinVariableShadowing(String),
-    BuiltinArgumentShadowing(String),
-    BuiltinAttributeShadowing(String),
-    // flakes8-comprehensions
-    UnnecessaryGeneratorList,
-    UnnecessaryGeneratorSet,
-    UnnecessaryGeneratorDict,
-    UnnecessaryListComprehensionSet,
-    UnnecessaryListComprehensionDict,
-    UnnecessaryLiteralSet(String),
-    UnnecessaryLiteralDict(String),
-    UnnecessaryCollectionCall(String),
-    // flake8-super
-    SuperCallWithParameters,
-    // flake8-print
-    PrintFound,
-    PPrintFound,
-    // pyupgrade
-    TypeOfPrimitive(Primitive),
-    UnnecessaryAbspath,
-    UselessMetaclassType,
-    NoAssertEquals,
-    UselessObjectInheritance(String),
-    // Meta
-    UnusedNOQA(Option<String>),
-}
-
 impl CheckKind {
-    /// The name of the check.
-    pub fn name(&self) -> &'static str {
-        match self {
-            CheckKind::AmbiguousClassName(_) => "AmbiguousClassName",
-            CheckKind::AmbiguousFunctionName(_) => "AmbiguousFunctionName",
-            CheckKind::AmbiguousVariableName(_) => "AmbiguousVariableName",
-            CheckKind::AssertTuple => "AssertTuple",
-            CheckKind::BreakOutsideLoop => "BreakOutsideLoop",
-            CheckKind::ContinueOutsideLoop => "ContinueOutsideLoop",
-            CheckKind::DefaultExceptNotLast => "DefaultExceptNotLast",
-            CheckKind::DoNotAssignLambda => "DoNotAssignLambda",
-            CheckKind::DoNotUseBareExcept => "DoNotUseBareExcept",
-            CheckKind::DuplicateArgumentName => "DuplicateArgumentName",
-            CheckKind::ExpressionsInStarAssignment => "ExpressionsInStarAssignment",
-            CheckKind::FStringMissingPlaceholders => "FStringMissingPlaceholders",
-            CheckKind::ForwardAnnotationSyntaxError(_) => "ForwardAnnotationSyntaxError",
-            CheckKind::FutureFeatureNotDefined(_) => "FutureFeatureNotDefined",
-            CheckKind::IOError(_) => "IOError",
-            CheckKind::IfTuple => "IfTuple",
-            CheckKind::ImportShadowedByLoopVar(_, _) => "ImportShadowedByLoopVar",
-            CheckKind::ImportStarNotPermitted(_) => "ImportStarNotPermitted",
-            CheckKind::ImportStarUsage(_, _) => "ImportStarUsage",
-            CheckKind::ImportStarUsed(_) => "ImportStarUsed",
-            CheckKind::InvalidPrintSyntax => "InvalidPrintSyntax",
-            CheckKind::IsLiteral => "IsLiteral",
-            CheckKind::LateFutureImport => "LateFutureImport",
-            CheckKind::LineTooLong(_, _) => "LineTooLong",
-            CheckKind::ModuleImportNotAtTopOfFile => "ModuleImportNotAtTopOfFile",
-            CheckKind::MultiValueRepeatedKeyLiteral => "MultiValueRepeatedKeyLiteral",
-            CheckKind::MultiValueRepeatedKeyVariable(_) => "MultiValueRepeatedKeyVariable",
-            CheckKind::NoneComparison(_) => "NoneComparison",
-            CheckKind::NotInTest => "NotInTest",
-            CheckKind::NotIsTest => "NotIsTest",
-            CheckKind::RaiseNotImplemented => "RaiseNotImplemented",
-            CheckKind::ReturnOutsideFunction => "ReturnOutsideFunction",
-            CheckKind::SyntaxError(_) => "SyntaxError",
-            CheckKind::TrueFalseComparison(_, _) => "TrueFalseComparison",
-            CheckKind::TwoStarredExpressions => "TwoStarredExpressions",
-            CheckKind::TypeComparison => "TypeComparison",
-            CheckKind::UndefinedExport(_) => "UndefinedExport",
-            CheckKind::UndefinedLocal(_) => "UndefinedLocal",
-            CheckKind::UndefinedName(_) => "UndefinedName",
-            CheckKind::UnusedImport(_) => "UnusedImport",
-            CheckKind::UnusedVariable(_) => "UnusedVariable",
-            CheckKind::YieldOutsideFunction => "YieldOutsideFunction",
-            // More style
-            CheckKind::NoNewLineAtEndOfFile => "NoNewLineAtEndOfFile",
-            // flake8-builtins
-            CheckKind::BuiltinVariableShadowing(_) => "BuiltinVariableShadowing",
-            CheckKind::BuiltinArgumentShadowing(_) => "BuiltinArgumentShadowing",
-            CheckKind::BuiltinAttributeShadowing(_) => "BuiltinAttributeShadowing",
-            // flake8-comprehensions
-            CheckKind::UnnecessaryGeneratorList => "UnnecessaryGeneratorList",
-            CheckKind::UnnecessaryGeneratorSet => "UnnecessaryGeneratorSet",
-            CheckKind::UnnecessaryGeneratorDict => "UnnecessaryGeneratorDict",
-            CheckKind::UnnecessaryListComprehensionSet => "UnnecessaryListComprehensionSet",
-            CheckKind::UnnecessaryListComprehensionDict => "UnnecessaryListComprehensionDict",
-            CheckKind::UnnecessaryLiteralSet(_) => "UnnecessaryLiteralSet",
-            CheckKind::UnnecessaryLiteralDict(_) => "UnnecessaryLiteralDict",
-            CheckKind::UnnecessaryCollectionCall(_) => "UnnecessaryCollectionCall",
-            // flake8-super
-            CheckKind::SuperCallWithParameters => "SuperCallWithParameters",
-            // flake8-print
-            CheckKind::PrintFound => "PrintFound",
-            CheckKind::PPrintFound => "PPrintFound",
-            // pyupgrade
-            CheckKind::TypeOfPrimitive(_) => "TypeOfPrimitive",
-            CheckKind::UnnecessaryAbspath => "UnnecessaryAbspath",
-            CheckKind::UselessMetaclassType => "UselessMetaclassType",
-            CheckKind::NoAssertEquals => "NoAssertEquals",
-            CheckKind::UselessObjectInheritance(_) => "UselessObjectInheritance",
-            // Meta
-            CheckKind::UnusedNOQA(_) => "UnusedNOQA",
-        }
-    }
-
     /// A four-letter shorthand code for the check.
     pub fn code(&self) -> &'static CheckCode {
         match self {
+            // pycodestyle errors
             CheckKind::AmbiguousClassName(_) => &CheckCode::E742,
             CheckKind::AmbiguousFunctionName(_) => &CheckCode::E743,
             CheckKind::AmbiguousVariableName(_) => &CheckCode::E741,
@@ -669,7 +394,7 @@ impl CheckKind {
             CheckKind::UnusedImport(_) => &CheckCode::F401,
             CheckKind::UnusedVariable(_) => &CheckCode::F841,
             CheckKind::YieldOutsideFunction => &CheckCode::F704,
-            // More style
+            // pycodestyle warnings
             CheckKind::NoNewLineAtEndOfFile => &CheckCode::W292,
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(_) => &CheckCode::A001,
@@ -684,8 +409,9 @@ impl CheckKind {
             CheckKind::UnnecessaryLiteralSet(_) => &CheckCode::C405,
             CheckKind::UnnecessaryLiteralDict(_) => &CheckCode::C406,
             CheckKind::UnnecessaryCollectionCall(_) => &CheckCode::C408,
-            // flake8-super
-            CheckKind::SuperCallWithParameters => &CheckCode::SPR001,
+            CheckKind::UnnecessaryLiteralWithinTupleCall(..) => &CheckCode::C409,
+            CheckKind::UnnecessaryLiteralWithinListCall(..) => &CheckCode::C410,
+            CheckKind::UnnecessarySubscriptReversal(_) => &CheckCode::C415,
             // flake8-print
             CheckKind::PrintFound => &CheckCode::T201,
             CheckKind::PPrintFound => &CheckCode::T203,
@@ -693,8 +419,11 @@ impl CheckKind {
             CheckKind::TypeOfPrimitive(_) => &CheckCode::U003,
             CheckKind::UnnecessaryAbspath => &CheckCode::U002,
             CheckKind::UselessMetaclassType => &CheckCode::U001,
-            CheckKind::NoAssertEquals => &CheckCode::U005,
+            CheckKind::DeprecatedUnittestAlias(_, _) => &CheckCode::U005,
+            CheckKind::UsePEP585Annotation(_) => &CheckCode::U006,
+            CheckKind::UsePEP604Annotation => &CheckCode::U007,
             CheckKind::UselessObjectInheritance(_) => &CheckCode::U004,
+            CheckKind::SuperCallWithParameters => &CheckCode::U008,
             // Meta
             CheckKind::UnusedNOQA(_) => &CheckCode::M001,
         }
@@ -703,6 +432,7 @@ impl CheckKind {
     /// The body text for the check.
     pub fn body(&self) -> String {
         match self {
+            // pycodestyle errors
             CheckKind::AmbiguousClassName(name) => {
                 format!("Ambiguous class name: `{}`", name)
             }
@@ -830,7 +560,7 @@ impl CheckKind {
             CheckKind::YieldOutsideFunction => {
                 "`yield` or `yield from` statement outside of a function/method".to_string()
             }
-            // More style
+            // pycodestyle warnings
             CheckKind::NoNewLineAtEndOfFile => "No newline at end of file".to_string(),
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(name) => {
@@ -867,9 +597,30 @@ impl CheckKind {
             CheckKind::UnnecessaryCollectionCall(obj_type) => {
                 format!("Unnecessary {obj_type} call - rewrite as a literal")
             }
-            // flake8-super
-            CheckKind::SuperCallWithParameters => {
-                "Use `super()` instead of `super(__class__, self)`".to_string()
+            CheckKind::UnnecessaryLiteralWithinTupleCall(literal) => {
+                if literal == "list" {
+                    format!(
+                        "Unnecessary {literal} literal passed to tuple() - rewrite as a tuple literal"
+                    )
+                } else {
+                    format!(
+                        "Unnecessary {literal} literal passed to tuple() - remove the outer call to tuple()"
+                    )
+                }
+            }
+            CheckKind::UnnecessaryLiteralWithinListCall(literal) => {
+                if literal == "list" {
+                    format!(
+                        "Unnecessary {literal} literal passed to list() - remove the outer call to list()"
+                    )
+                } else {
+                    format!(
+                        "Unnecessary {literal} literal passed to list() - rewrite as a list literal"
+                    )
+                }
+            }
+            CheckKind::UnnecessarySubscriptReversal(func) => {
+                format!("Unnecessary subscript reversal of iterable within {func}()")
             }
             // flake8-print
             CheckKind::PrintFound => "`print` found".to_string(),
@@ -882,16 +633,39 @@ impl CheckKind {
                 "`abspath(__file__)` is unnecessary in Python 3.9 and later".to_string()
             }
             CheckKind::UselessMetaclassType => "`__metaclass__ = type` is implied".to_string(),
-            CheckKind::NoAssertEquals => {
-                "`assertEquals` is deprecated, use `assertEqual` instead".to_string()
+            CheckKind::DeprecatedUnittestAlias(alias, target) => {
+                format!("`{}` is deprecated, use `{}` instead", alias, target)
             }
             CheckKind::UselessObjectInheritance(name) => {
                 format!("Class `{name}` inherits from object")
             }
+            CheckKind::UsePEP585Annotation(name) => {
+                format!(
+                    "Use `{}` instead of `{}` for type annotations",
+                    name.to_lowercase(),
+                    name,
+                )
+            }
+            CheckKind::UsePEP604Annotation => "Use `X | Y` for type annotations".to_string(),
+            CheckKind::SuperCallWithParameters => {
+                "Use `super()` instead of `super(__class__, self)`".to_string()
+            }
             // Meta
-            CheckKind::UnusedNOQA(code) => match code {
+            CheckKind::UnusedNOQA(codes) => match codes {
                 None => "Unused `noqa` directive".to_string(),
-                Some(code) => format!("Unused `noqa` directive for: {code}"),
+                Some(codes) => {
+                    let codes = codes
+                        .iter()
+                        .map(|code| {
+                            if CheckCode::from_str(code).is_ok() {
+                                code.to_string()
+                            } else {
+                                format!("{code} (not implemented)")
+                            }
+                        })
+                        .join(", ");
+                    format!("Unused `noqa` directive for: {codes}")
+                }
             },
         }
     }
@@ -900,7 +674,7 @@ impl CheckKind {
     pub fn fixable(&self) -> bool {
         matches!(
             self,
-            CheckKind::NoAssertEquals
+            CheckKind::DeprecatedUnittestAlias(_, _)
                 | CheckKind::PPrintFound
                 | CheckKind::PrintFound
                 | CheckKind::SuperCallWithParameters
@@ -910,6 +684,8 @@ impl CheckKind {
                 | CheckKind::UnusedNOQA(_)
                 | CheckKind::UselessMetaclassType
                 | CheckKind::UselessObjectInheritance(_)
+                | CheckKind::UsePEP585Annotation(_)
+                | CheckKind::UsePEP604Annotation
         )
     }
 }
@@ -944,3 +720,25 @@ impl Check {
         self.fix = Some(fix);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use anyhow::Result;
+    use strum::IntoEnumIterator;
+
+    use crate::checks::CheckCode;
+
+    #[test]
+    fn check_code_serialization() -> Result<()> {
+        for check_code in CheckCode::iter() {
+            assert!(
+                CheckCode::from_str(check_code.as_ref()).is_ok(),
+                "{:?} could not be round-trip serialized.",
+                check_code
+            );
+        }
+        Ok(())
+    }
+}

src/code_gen.rs

@@ -547,7 +547,7 @@ impl SourceGenerator {
         Ok(())
     }
 
-    fn unparse_expr<U>(&mut self, ast: &Expr<U>, level: u8) -> fmt::Result {
+    pub fn unparse_expr<U>(&mut self, ast: &Expr<U>, level: u8) -> fmt::Result {
         macro_rules! opprec {
             ($opty:ident, $x:expr, $enu:path, $($var:ident($op:literal, $prec:ident)),*$(,)?) => {
                 match $x {

src/linter.rs

@@ -376,9 +376,57 @@ mod tests {
     }
 
     #[test]
-    fn f401() -> Result<()> {
+    fn f401_0() -> Result<()> {
         let mut checks = check_path(
-            Path::new("./resources/test/fixtures/F401.py"),
+            Path::new("./resources/test/fixtures/F401_0.py"),
+            &settings::Settings::for_rule(CheckCode::F401),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn f401_1() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/F401_1.py"),
+            &settings::Settings::for_rule(CheckCode::F401),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn f401_2() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/F401_2.py"),
+            &settings::Settings::for_rule(CheckCode::F401),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn f401_3() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/F401_3.py"),
+            &settings::Settings::for_rule(CheckCode::F401),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn f401_4() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/F401_4.py"),
             &settings::Settings::for_rule(CheckCode::F401),
             &fixer::Mode::Generate,
         )?;
@@ -714,42 +762,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn m001() -> Result<()> {
-        let mut checks = check_path(
-            Path::new("./resources/test/fixtures/M001.py"),
-            &settings::Settings::for_rules(vec![CheckCode::M001, CheckCode::E501, CheckCode::F841]),
-            &fixer::Mode::Generate,
-        )?;
-        checks.sort_by_key(|check| check.location);
-        insta::assert_yaml_snapshot!(checks);
-        Ok(())
-    }
-
-    #[test]
-    fn init() -> Result<()> {
-        let mut checks = check_path(
-            Path::new("./resources/test/fixtures/__init__.py"),
-            &settings::Settings::for_rules(vec![CheckCode::F821, CheckCode::F822]),
-            &fixer::Mode::Generate,
-        )?;
-        checks.sort_by_key(|check| check.location);
-        insta::assert_yaml_snapshot!(checks);
-        Ok(())
-    }
-
-    #[test]
-    fn future_annotations() -> Result<()> {
-        let mut checks = check_path(
-            Path::new("./resources/test/fixtures/future_annotations.py"),
-            &settings::Settings::for_rules(vec![CheckCode::F401, CheckCode::F821]),
-            &fixer::Mode::Generate,
-        )?;
-        checks.sort_by_key(|check| check.location);
-        insta::assert_yaml_snapshot!(checks);
-        Ok(())
-    }
-
     #[test]
     fn e999() -> Result<()> {
         let mut checks = check_path(
@@ -895,10 +907,46 @@ mod tests {
     }
 
     #[test]
-    fn spr001() -> Result<()> {
+    fn c409() -> Result<()> {
         let mut checks = check_path(
-            Path::new("./resources/test/fixtures/SPR001.py"),
-            &settings::Settings::for_rule(CheckCode::SPR001),
+            Path::new("./resources/test/fixtures/C409.py"),
+            &settings::Settings::for_rule(CheckCode::C409),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn c410() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/C410.py"),
+            &settings::Settings::for_rule(CheckCode::C410),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn c415() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/C415.py"),
+            &settings::Settings::for_rule(CheckCode::C415),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn u008() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/U008.py"),
+            &settings::Settings::for_rule(CheckCode::U008),
             &fixer::Mode::Generate,
         )?;
         checks.sort_by_key(|check| check.location);
@@ -989,4 +1037,64 @@ mod tests {
         insta::assert_yaml_snapshot!(checks);
         Ok(())
     }
+
+    #[test]
+    fn u006() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/U006.py"),
+            &settings::Settings::for_rule(CheckCode::U006),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn u007() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/U007.py"),
+            &settings::Settings::for_rule(CheckCode::U007),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn m001() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/M001.py"),
+            &settings::Settings::for_rules(vec![CheckCode::M001, CheckCode::E501, CheckCode::F841]),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn init() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/__init__.py"),
+            &settings::Settings::for_rules(vec![CheckCode::F821, CheckCode::F822]),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn future_annotations() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/future_annotations.py"),
+            &settings::Settings::for_rules(vec![CheckCode::F401, CheckCode::F821]),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
 }

src/message.rs

@@ -45,7 +45,7 @@ impl fmt::Display for Message {
             ":".cyan(),
             self.location.column(),
             ":".cyan(),
-            self.kind.code().as_str().red().bold(),
+            self.kind.code().as_ref().red().bold(),
             self.kind.body()
         )
     }

src/noqa.rs

@@ -125,7 +125,7 @@ fn add_noqa_inner(
                     Directive::All(start, _) => output.push_str(&line[..start]),
                     Directive::Codes(start, _, _) => output.push_str(&line[..start]),
                 };
-                let codes: Vec<&str> = codes.iter().map(|code| code.as_str()).collect();
+                let codes: Vec<&str> = codes.iter().map(|code| code.as_ref()).collect();
                 output.push_str("  # noqa: ");
                 output.push_str(&codes.join(", "));
                 output.push('\n');
@@ -150,12 +150,12 @@ pub fn add_noqa(
 
 #[cfg(test)]
 mod tests {
-    use crate::ast::types::Range;
     use anyhow::Result;
     use rustpython_parser::ast::Location;
     use rustpython_parser::lexer;
     use rustpython_parser::lexer::LexResult;
 
+    use crate::ast::types::Range;
     use crate::checks::{Check, CheckKind};
     use crate::noqa::{add_noqa_inner, extract_noqa_line_for};
 

src/plugins.rs

@@ -1,21 +1,25 @@
-mod assert_equals;
-mod assert_tuple;
-mod if_tuple;
-mod invalid_print_syntax;
-mod print_call;
-mod super_call_with_parameters;
-mod type_of_primitive;
-mod unnecessary_abspath;
-mod useless_metaclass_type;
-mod useless_object_inheritance;
-
-pub use assert_equals::assert_equals;
 pub use assert_tuple::assert_tuple;
+pub use deprecated_unittest_alias::deprecated_unittest_alias;
 pub use if_tuple::if_tuple;
 pub use invalid_print_syntax::invalid_print_syntax;
 pub use print_call::print_call;
 pub use super_call_with_parameters::super_call_with_parameters;
 pub use type_of_primitive::type_of_primitive;
 pub use unnecessary_abspath::unnecessary_abspath;
+pub use use_pep585_annotation::use_pep585_annotation;
+pub use use_pep604_annotation::use_pep604_annotation;
 pub use useless_metaclass_type::useless_metaclass_type;
 pub use useless_object_inheritance::useless_object_inheritance;
+
+mod assert_tuple;
+mod deprecated_unittest_alias;
+mod if_tuple;
+mod invalid_print_syntax;
+mod print_call;
+mod super_call_with_parameters;
+mod type_of_primitive;
+mod unnecessary_abspath;
+mod use_pep585_annotation;
+mod use_pep604_annotation;
+mod useless_metaclass_type;
+mod useless_object_inheritance;

src/plugins/assert_equals.rs

@@ -1,23 +0,0 @@
-use rustpython_ast::{Expr, Location};
-
-use crate::ast::checks;
-use crate::autofix::fixer;
-use crate::check_ast::Checker;
-use crate::checks::Fix;
-
-pub fn assert_equals(checker: &mut Checker, expr: &Expr) {
-    if let Some(mut check) = checks::check_assert_equals(expr) {
-        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
-            check.amend(Fix {
-                content: "assertEqual".to_string(),
-                location: Location::new(expr.location.row(), expr.location.column() + 1),
-                end_location: Location::new(
-                    expr.location.row(),
-                    expr.location.column() + 1 + "assertEquals".len(),
-                ),
-                applied: false,
-            });
-        }
-        checker.add_check(check);
-    }
-}

src/plugins/deprecated_unittest_alias.rs

@@ -0,0 +1,56 @@
+use std::collections::BTreeMap;
+
+use once_cell::sync::Lazy;
+use rustpython_ast::{Expr, ExprKind, Location};
+
+use crate::ast::types::Range;
+use crate::autofix::fixer;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind, Fix};
+
+static DEPRECATED_ALIASES: Lazy<BTreeMap<&'static str, &'static str>> = Lazy::new(|| {
+    BTreeMap::from([
+        ("failUnlessEqual", "assertEqual"),
+        ("assertEquals", "assertEqual"),
+        ("failIfEqual", "assertNotEqual"),
+        ("assertNotEquals", "assertNotEqual"),
+        ("failUnless", "assertTrue"),
+        ("assert_", "assertTrue"),
+        ("failIf", "assertFalse"),
+        ("failUnlessRaises", "assertRaises"),
+        ("failUnlessAlmostEqual", "assertAlmostEqual"),
+        ("assertAlmostEquals", "assertAlmostEqual"),
+        ("failIfAlmostEqual", "assertNotAlmostEqual"),
+        ("assertNotAlmostEquals", "assertNotAlmostEqual"),
+        ("assertRegexpMatches", "assertRegex"),
+        ("assertNotRegexpMatches", "assertNotRegex"),
+        ("assertRaisesRegexp", "assertRaisesRegex"),
+    ])
+});
+
+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()) {
+            if let ExprKind::Name { id, .. } = &value.node {
+                if id == "self" {
+                    let mut check = Check::new(
+                        CheckKind::DeprecatedUnittestAlias(attr.to_string(), target.to_string()),
+                        Range::from_located(expr),
+                    );
+                    if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                        check.amend(Fix {
+                            content: format!("self.{}", target),
+                            location: Location::new(expr.location.row(), expr.location.column()),
+                            end_location: Location::new(
+                                expr.end_location.row(),
+                                expr.end_location.column(),
+                            ),
+                            applied: false,
+                        });
+                    }
+                    checker.add_check(check);
+                }
+            }
+        }
+    }
+}

src/plugins/use_pep585_annotation.rs

@@ -0,0 +1,26 @@
+use rustpython_ast::Expr;
+
+use crate::ast::types::Range;
+use crate::autofix::fixer;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind, Fix};
+use crate::python::typing;
+
+pub fn use_pep585_annotation(checker: &mut Checker, expr: &Expr, id: &str) {
+    // TODO(charlie): Verify that the builtin is imported from the `typing` module.
+    if typing::is_pep585_builtin(id) {
+        let mut check = Check::new(
+            CheckKind::UsePEP585Annotation(id.to_string()),
+            Range::from_located(expr),
+        );
+        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+            check.amend(Fix {
+                content: id.to_lowercase(),
+                location: expr.location,
+                end_location: expr.end_location,
+                applied: false,
+            })
+        }
+        checker.add_check(check);
+    }
+}

src/plugins/use_pep604_annotation.rs

@@ -0,0 +1,100 @@
+use rustpython_ast::{Constant, Expr, ExprKind, Operator};
+
+use crate::ast::helpers::match_name_or_attr;
+use crate::ast::types::Range;
+use crate::autofix::fixer;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind, Fix};
+use crate::code_gen::SourceGenerator;
+
+fn optional(expr: &Expr) -> Expr {
+    Expr::new(
+        Default::default(),
+        Default::default(),
+        ExprKind::BinOp {
+            left: Box::new(expr.clone()),
+            op: Operator::BitOr,
+            right: Box::new(Expr::new(
+                Default::default(),
+                Default::default(),
+                ExprKind::Constant {
+                    value: Constant::None,
+                    kind: None,
+                },
+            )),
+        },
+    )
+}
+
+fn union(elts: &[Expr]) -> Expr {
+    if elts.len() == 1 {
+        elts[0].clone()
+    } else {
+        Expr::new(
+            Default::default(),
+            Default::default(),
+            ExprKind::BinOp {
+                left: Box::new(union(&elts[..elts.len() - 1])),
+                op: Operator::BitOr,
+                right: Box::new(elts[elts.len() - 1].clone()),
+            },
+        )
+    }
+}
+
+pub fn use_pep604_annotation(checker: &mut Checker, expr: &Expr, value: &Expr, slice: &Expr) {
+    if match_name_or_attr(value, "Optional") {
+        let mut check = Check::new(CheckKind::UsePEP604Annotation, Range::from_located(expr));
+        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+            let mut generator = SourceGenerator::new();
+            if let Ok(()) = generator.unparse_expr(&optional(slice), 0) {
+                if let Ok(content) = generator.generate() {
+                    check.amend(Fix {
+                        content,
+                        location: expr.location,
+                        end_location: expr.end_location,
+                        applied: false,
+                    })
+                }
+            }
+        }
+        checker.add_check(check);
+    } else if match_name_or_attr(value, "Union") {
+        let mut check = Check::new(CheckKind::UsePEP604Annotation, Range::from_located(expr));
+        if matches!(checker.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+            match &slice.node {
+                ExprKind::Slice { .. } => {
+                    // Invalid type annotation.
+                }
+                ExprKind::Tuple { elts, .. } => {
+                    let mut generator = SourceGenerator::new();
+                    if let Ok(()) = generator.unparse_expr(&union(elts), 0) {
+                        if let Ok(content) = generator.generate() {
+                            check.amend(Fix {
+                                content,
+                                location: expr.location,
+                                end_location: expr.end_location,
+                                applied: false,
+                            })
+                        }
+                    }
+                }
+                _ => {
+                    // Single argument.
+                    let mut generator = SourceGenerator::new();
+                    if let Ok(()) = generator.unparse_expr(slice, 0) {
+                        if let Ok(content) = generator.generate() {
+                            check.amend(Fix {
+                                content,
+                                location: expr.location,
+                                end_location: expr.end_location,
+                                applied: false,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        checker.add_check(check);
+    }
+}

src/pyproject.rs

@@ -154,12 +154,13 @@ mod tests {
 
     use anyhow::Result;
 
-    use super::StrCheckCodePair;
     use crate::checks::CheckCode;
     use crate::pyproject::{
         find_project_root, find_pyproject_toml, parse_pyproject_toml, Config, PyProject, Tools,
     };
 
+    use super::StrCheckCodePair;
+
     #[test]
     fn deserialize() -> Result<()> {
         let pyproject: PyProject = toml::from_str(r#""#)?;

src/python/typing.rs

@@ -92,3 +92,10 @@ pub fn is_annotated_subscript(name: &str) -> bool {
 pub fn is_pep593_annotated_subscript(name: &str) -> bool {
     name == "Annotated"
 }
+
+static PEP_585_BUILTINS: Lazy<BTreeSet<&'static str>> =
+    Lazy::new(|| BTreeSet::from(["Dict", "FrozenSet", "List", "Set", "Tuple", "Type"]));
+
+pub fn is_pep585_builtin(name: &str) -> bool {
+    PEP_585_BUILTINS.contains(name)
+}

src/snapshots/ruff__linter__tests__c409.snap

@@ -0,0 +1,32 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UnnecessaryLiteralWithinTupleCall: list
+  location:
+    row: 1
+    column: 6
+  end_location:
+    row: 1
+    column: 19
+  fix: ~
+- kind:
+    UnnecessaryLiteralWithinTupleCall: tuple
+  location:
+    row: 2
+    column: 6
+  end_location:
+    row: 2
+    column: 19
+  fix: ~
+- kind:
+    UnnecessaryLiteralWithinTupleCall: list
+  location:
+    row: 3
+    column: 6
+  end_location:
+    row: 3
+    column: 15
+  fix: ~
+

src/snapshots/ruff__linter__tests__c410.snap

@@ -0,0 +1,41 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UnnecessaryLiteralWithinListCall: list
+  location:
+    row: 1
+    column: 6
+  end_location:
+    row: 1
+    column: 18
+  fix: ~
+- kind:
+    UnnecessaryLiteralWithinListCall: tuple
+  location:
+    row: 2
+    column: 6
+  end_location:
+    row: 2
+    column: 18
+  fix: ~
+- kind:
+    UnnecessaryLiteralWithinListCall: list
+  location:
+    row: 3
+    column: 6
+  end_location:
+    row: 3
+    column: 14
+  fix: ~
+- kind:
+    UnnecessaryLiteralWithinListCall: tuple
+  location:
+    row: 4
+    column: 6
+  end_location:
+    row: 4
+    column: 14
+  fix: ~
+

src/snapshots/ruff__linter__tests__c415.snap

@@ -0,0 +1,41 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UnnecessarySubscriptReversal: set
+  location:
+    row: 2
+    column: 5
+  end_location:
+    row: 2
+    column: 19
+  fix: ~
+- kind:
+    UnnecessarySubscriptReversal: reversed
+  location:
+    row: 3
+    column: 5
+  end_location:
+    row: 3
+    column: 24
+  fix: ~
+- kind:
+    UnnecessarySubscriptReversal: sorted
+  location:
+    row: 4
+    column: 5
+  end_location:
+    row: 4
+    column: 22
+  fix: ~
+- kind:
+    UnnecessarySubscriptReversal: sorted
+  location:
+    row: 5
+    column: 5
+  end_location:
+    row: 5
+    column: 36
+  fix: ~
+

src/snapshots/ruff__linter__tests__f401_0.snap

@@ -0,0 +1,131 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UnusedImport:
+      - functools
+  location:
+    row: 2
+    column: 1
+  end_location:
+    row: 2
+    column: 21
+  fix:
+    content: import os
+    location:
+      row: 2
+      column: 1
+    end_location:
+      row: 2
+      column: 21
+    applied: false
+- kind:
+    UnusedImport:
+      - collections.OrderedDict
+  location:
+    row: 4
+    column: 1
+  end_location:
+    row: 8
+    column: 2
+  fix:
+    content: "from collections import (\n    Counter,\n    namedtuple,\n)"
+    location:
+      row: 4
+      column: 1
+    end_location:
+      row: 8
+      column: 2
+    applied: false
+- kind:
+    UnusedImport:
+      - logging.handlers
+  location:
+    row: 12
+    column: 1
+  end_location:
+    row: 12
+    column: 24
+  fix:
+    content: import logging.handlers
+    location:
+      row: 12
+      column: 1
+    end_location:
+      row: 12
+      column: 24
+    applied: false
+- kind:
+    UnusedImport:
+      - shelve
+  location:
+    row: 33
+    column: 5
+  end_location:
+    row: 33
+    column: 18
+  fix:
+    content: ""
+    location:
+      row: 33
+      column: 1
+    end_location:
+      row: 34
+      column: 1
+    applied: false
+- kind:
+    UnusedImport:
+      - importlib
+  location:
+    row: 34
+    column: 5
+  end_location:
+    row: 34
+    column: 21
+  fix:
+    content: ""
+    location:
+      row: 34
+      column: 1
+    end_location:
+      row: 35
+      column: 1
+    applied: false
+- kind:
+    UnusedImport:
+      - pathlib
+  location:
+    row: 38
+    column: 5
+  end_location:
+    row: 38
+    column: 19
+  fix:
+    content: ""
+    location:
+      row: 38
+      column: 1
+    end_location:
+      row: 39
+      column: 1
+    applied: false
+- kind:
+    UnusedImport:
+      - pickle
+  location:
+    row: 53
+    column: 9
+  end_location:
+    row: 53
+    column: 22
+  fix:
+    content: pass
+    location:
+      row: 53
+      column: 9
+    end_location:
+      row: 53
+      column: 22
+    applied: false
+

src/snapshots/ruff__linter__tests__f401_1.snap

@@ -0,0 +1,6 @@
+---
+source: src/linter.rs
+expression: checks
+---
+[]
+

src/snapshots/ruff__linter__tests__f401_2.snap

@@ -0,0 +1,6 @@
+---
+source: src/linter.rs
+expression: checks
+---
+[]
+

src/snapshots/ruff__linter__tests__f401_3.snap

@@ -0,0 +1,6 @@
+---
+source: src/linter.rs
+expression: checks
+---
+[]
+

src/snapshots/ruff__linter__tests__f401_4.snap

@@ -0,0 +1,6 @@
+---
+source: src/linter.rs
+expression: checks
+---
+[]
+

src/snapshots/ruff__linter__tests__f722.snap

@@ -9,6 +9,6 @@ expression: checks
     column: 13
   end_location:
     row: 9
-    column: 17
+    column: 16
   fix: ~
 

src/snapshots/ruff__linter__tests__f821.snap

@@ -45,7 +45,7 @@ expression: checks
     column: 5
   end_location:
     row: 58
-    column: 9
+    column: 8
   fix: ~
 - kind:
     UndefinedName: TOMATO
@@ -81,7 +81,7 @@ expression: checks
     column: 10
   end_location:
     row: 114
-    column: 24
+    column: 23
   fix: ~
 - kind:
     UndefinedName: foo
@@ -90,7 +90,7 @@ expression: checks
     column: 15
   end_location:
     row: 122
-    column: 19
+    column: 18
   fix: ~
 - kind:
     UndefinedName: bar
@@ -99,6 +99,6 @@ expression: checks
     column: 22
   end_location:
     row: 122
-    column: 26
+    column: 25
   fix: ~
 

src/snapshots/ruff__linter__tests__m001.snap

@@ -20,7 +20,8 @@ expression: checks
       column: 18
     applied: false
 - kind:
-    UnusedNOQA: E501
+    UnusedNOQA:
+      - E501
   location:
     row: 13
     column: 10
@@ -37,7 +38,9 @@ expression: checks
       column: 24
     applied: false
 - kind:
-    UnusedNOQA: E501
+    UnusedNOQA:
+      - F841
+      - E501
   location:
     row: 16
     column: 10
@@ -45,7 +48,7 @@ expression: checks
     row: 16
     column: 30
   fix:
-    content: "  # noqa: F841"
+    content: ""
     location:
       row: 16
       column: 10
@@ -54,54 +57,74 @@ expression: checks
       column: 30
     applied: false
 - kind:
-    UnusedNOQA: F841
+    UnusedNOQA:
+      - W191
   location:
-    row: 41
+    row: 19
+    column: 10
+  end_location:
+    row: 19
+    column: 30
+  fix:
+    content: "  # noqa: F841"
+    location:
+      row: 19
+      column: 10
+    end_location:
+      row: 19
+      column: 30
+    applied: false
+- kind:
+    UnusedNOQA:
+      - F841
+  location:
+    row: 44
     column: 4
   end_location:
-    row: 41
+    row: 44
     column: 24
   fix:
     content: "  # noqa: E501"
     location:
-      row: 41
+      row: 44
       column: 4
     end_location:
-      row: 41
+      row: 44
       column: 24
     applied: false
 - kind:
-    UnusedNOQA: E501
+    UnusedNOQA:
+      - E501
   location:
-    row: 49
+    row: 52
     column: 4
   end_location:
-    row: 49
+    row: 52
     column: 18
   fix:
     content: ""
     location:
-      row: 49
+      row: 52
       column: 4
     end_location:
-      row: 49
+      row: 52
       column: 18
     applied: false
 - kind:
     UnusedNOQA: ~
   location:
-    row: 57
+    row: 60
     column: 4
   end_location:
-    row: 57
+    row: 60
     column: 12
   fix:
     content: ""
     location:
-      row: 57
+      row: 60
       column: 4
     end_location:
-      row: 57
+      row: 60
       column: 12
     applied: false
 

src/snapshots/ruff__linter__tests__u005.snap

@@ -2,36 +2,80 @@
 source: src/linter.rs
 expression: checks
 ---
-- kind: NoAssertEquals
+- kind:
+    DeprecatedUnittestAlias:
+      - assertEquals
+      - assertEqual
   location:
-    row: 1
-    column: 1
+    row: 6
+    column: 9
   end_location:
-    row: 1
-    column: 18
+    row: 6
+    column: 26
   fix:
-    content: assertEqual
+    content: self.assertEqual
     location:
-      row: 1
-      column: 2
+      row: 6
+      column: 9
     end_location:
-      row: 1
-      column: 14
+      row: 6
+      column: 26
     applied: false
-- kind: NoAssertEquals
+- kind:
+    DeprecatedUnittestAlias:
+      - assertEquals
+      - assertEqual
   location:
-    row: 2
-    column: 1
+    row: 7
+    column: 9
   end_location:
-    row: 2
-    column: 18
+    row: 7
+    column: 26
   fix:
-    content: assertEqual
+    content: self.assertEqual
     location:
-      row: 2
-      column: 2
+      row: 7
+      column: 9
     end_location:
-      row: 2
-      column: 14
+      row: 7
+      column: 26
+    applied: false
+- kind:
+    DeprecatedUnittestAlias:
+      - failUnlessAlmostEqual
+      - assertAlmostEqual
+  location:
+    row: 9
+    column: 9
+  end_location:
+    row: 9
+    column: 35
+  fix:
+    content: self.assertAlmostEqual
+    location:
+      row: 9
+      column: 9
+    end_location:
+      row: 9
+      column: 35
+    applied: false
+- kind:
+    DeprecatedUnittestAlias:
+      - assertNotRegexpMatches
+      - assertNotRegex
+  location:
+    row: 10
+    column: 9
+  end_location:
+    row: 10
+    column: 36
+  fix:
+    content: self.assertNotRegex
+    location:
+      row: 10
+      column: 9
+    end_location:
+      row: 10
+      column: 36
     applied: false
 

src/snapshots/ruff__linter__tests__u006.snap

@@ -0,0 +1,39 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UsePEP585Annotation: List
+  location:
+    row: 4
+    column: 10
+  end_location:
+    row: 4
+    column: 14
+  fix:
+    content: list
+    location:
+      row: 4
+      column: 10
+    end_location:
+      row: 4
+      column: 14
+    applied: false
+- kind:
+    UsePEP585Annotation: List
+  location:
+    row: 11
+    column: 10
+  end_location:
+    row: 11
+    column: 21
+  fix:
+    content: list
+    location:
+      row: 11
+      column: 10
+    end_location:
+      row: 11
+      column: 21
+    applied: false
+

src/snapshots/ruff__linter__tests__u007.snap

@@ -0,0 +1,133 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: UsePEP604Annotation
+  location:
+    row: 4
+    column: 10
+  end_location:
+    row: 4
+    column: 23
+  fix:
+    content: str | None
+    location:
+      row: 4
+      column: 10
+    end_location:
+      row: 4
+      column: 23
+    applied: false
+- kind: UsePEP604Annotation
+  location:
+    row: 11
+    column: 10
+  end_location:
+    row: 11
+    column: 30
+  fix:
+    content: str | None
+    location:
+      row: 11
+      column: 10
+    end_location:
+      row: 11
+      column: 30
+    applied: false
+- kind: UsePEP604Annotation
+  location:
+    row: 18
+    column: 10
+  end_location:
+    row: 18
+    column: 46
+  fix:
+    content: "str | int | Union[float, bytes]"
+    location:
+      row: 18
+      column: 10
+    end_location:
+      row: 18
+      column: 46
+    applied: false
+- kind: UsePEP604Annotation
+  location:
+    row: 18
+    column: 26
+  end_location:
+    row: 18
+    column: 45
+  fix:
+    content: float | bytes
+    location:
+      row: 18
+      column: 26
+    end_location:
+      row: 18
+      column: 45
+    applied: false
+- kind: UsePEP604Annotation
+  location:
+    row: 25
+    column: 10
+  end_location:
+    row: 25
+    column: 32
+  fix:
+    content: str | int
+    location:
+      row: 25
+      column: 10
+    end_location:
+      row: 25
+      column: 32
+    applied: false
+- kind: UsePEP604Annotation
+  location:
+    row: 32
+    column: 11
+  end_location:
+    row: 32
+    column: 47
+  fix:
+    content: "str | int | Union[float, bytes]"
+    location:
+      row: 32
+      column: 11
+    end_location:
+      row: 32
+      column: 47
+    applied: false
+- kind: UsePEP604Annotation
+  location:
+    row: 32
+    column: 11
+  end_location:
+    row: 32
+    column: 47
+  fix:
+    content: float | bytes
+    location:
+      row: 32
+      column: 11
+    end_location:
+      row: 32
+      column: 47
+    applied: false
+- kind: UsePEP604Annotation
+  location:
+    row: 39
+    column: 11
+  end_location:
+    row: 39
+    column: 33
+  fix:
+    content: str | int
+    location:
+      row: 39
+      column: 11
+    end_location:
+      row: 39
+      column: 33
+    applied: false
+

src/snapshots/ruff__linter__tests__u008.snap

@@ -0,0 +1,85 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: SuperCallWithParameters
+  location:
+    row: 17
+    column: 18
+  end_location:
+    row: 17
+    column: 36
+  fix:
+    content: super()
+    location:
+      row: 17
+      column: 18
+    end_location:
+      row: 17
+      column: 36
+    applied: false
+- kind: SuperCallWithParameters
+  location:
+    row: 18
+    column: 9
+  end_location:
+    row: 18
+    column: 27
+  fix:
+    content: super()
+    location:
+      row: 18
+      column: 9
+    end_location:
+      row: 18
+      column: 27
+    applied: false
+- kind: SuperCallWithParameters
+  location:
+    row: 19
+    column: 9
+  end_location:
+    row: 22
+    column: 10
+  fix:
+    content: super()
+    location:
+      row: 19
+      column: 9
+    end_location:
+      row: 22
+      column: 10
+    applied: false
+- kind: SuperCallWithParameters
+  location:
+    row: 36
+    column: 9
+  end_location:
+    row: 36
+    column: 29
+  fix:
+    content: super()
+    location:
+      row: 36
+      column: 9
+    end_location:
+      row: 36
+      column: 29
+    applied: false
+- kind: SuperCallWithParameters
+  location:
+    row: 50
+    column: 13
+  end_location:
+    row: 50
+    column: 33
+  fix:
+    content: super()
+    location:
+      row: 50
+      column: 13
+    end_location:
+      row: 50
+      column: 33
+    applied: false
+