Bump version to 0.0.54

Cargo.lock

@@ -1871,7 +1871,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.52"
+version = "0.0.54"
 dependencies = [
  "anyhow",
  "bincode",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.52"
+version = "0.0.54"
 edition = "2021"
 
 [lib]

README.md

@@ -201,72 +201,86 @@ stylistic lint rules that are obviated by autoformatting.
 
 ### Parity with Flake8
 
-ruff's goal is to achieve feature-parity with Flake8 when used (1) without plugins, (2) alongside
+ruff's goal is to achieve feature parity with Flake8 when used (1) without plugins, (2) alongside
 Black, and (3) on Python 3 code.
 
 **Under those conditions, ruff implements 44 out of 60 rules.** (ruff is missing: 14 rules related
 to string `.format` calls, 1 rule related to docstring parsing, and 1 rule related to redefined
 variables.)
 
+ruff also implements some of the most popular Flake8 plugins natively, including:
+
+- [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
+- [`flake8-super`](https://pypi.org/project/flake8-super/)
+- [`flake8-print`](https://pypi.org/project/flake8-print/)
+- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (partial)
+
 Beyond rule-set parity, ruff suffers from the following limitations vis-à-vis Flake8:
 
-1. Flake8 has a plugin architecture and supports writing custom lint rules.
-2. ruff does not yet support a few Python 3.9 and 3.10 language features, including structural
+1. ruff does not yet support a few Python 3.9 and 3.10 language features, including structural
    pattern matching and parenthesized context managers.
+2. Flake8 has a plugin architecture and supports writing custom lint rules.
 
 ## Rules
 
-| Code | Name | Message |
-| ---- | ----- | ------- |
-| E402 | ModuleImportNotAtTopOfFile | Module level import not at top of file |
-| E501 | LineTooLong | Line too long (89 > 88 characters) |
-| E711 | NoneComparison | Comparison to `None` should be `cond is None` |
-| E712 | TrueFalseComparison | Comparison to `True` should be `cond is True` |
-| E713 | NotInTest | Test for membership should be `not in` |
-| E714 | NotIsTest | Test for object identity should be `is not` |
-| E721 | TypeComparison | do not compare types, use `isinstance()` |
-| E722 | DoNotUseBareExcept | Do not use bare `except` |
-| E731 | DoNotAssignLambda | Do not assign a lambda expression, use a def |
-| E741 | AmbiguousVariableName | ambiguous variable name '...' |
-| E742 | AmbiguousClassName | ambiguous class name '...' |
-| E743 | AmbiguousFunctionName | ambiguous function name '...' |
-| E902 | IOError | ... |
-| E999 | SyntaxError | SyntaxError: ... |
-| F401 | UnusedImport | `...` imported but unused |
-| F402 | ImportShadowedByLoopVar | import '...' from line 1 shadowed by loop variable |
-| F403 | ImportStarUsed | `from ... import *` used; unable to detect undefined names |
-| F404 | LateFutureImport | from __future__ imports must occur at the beginning of the file |
-| F405 | ImportStarUsage | '...' may be undefined, or defined from star imports: ... |
-| F406 | ImportStarNotPermitted | `from ... import *` only allowed at module level |
-| F407 | FutureFeatureNotDefined | future feature '...' is not defined |
-| F541 | FStringMissingPlaceholders | f-string without any placeholders |
-| F601 | MultiValueRepeatedKeyLiteral | Dictionary key literal repeated |
-| F602 | MultiValueRepeatedKeyVariable | Dictionary key `...` repeated |
-| F621 | TooManyExpressionsInStarredAssignment | too many expressions in star-unpacking assignment |
-| F622 | TwoStarredExpressions | two starred expressions in assignment |
-| F631 | AssertTuple | Assert test is a non-empty tuple, which is always `True` |
-| F632 | IsLiteral | use ==/!= to compare constant literals |
-| F633 | InvalidPrintSyntax | use of >> is invalid with print function |
-| F634 | IfTuple | If test is a tuple, which is always `True` |
-| F701 | BreakOutsideLoop | `break` outside loop |
-| F702 | ContinueOutsideLoop | `continue` not properly in loop |
-| F704 | YieldOutsideFunction | a `yield` or `yield from` statement outside of a function/method |
-| F706 | ReturnOutsideFunction | a `return` statement outside of a function/method |
-| F707 | DefaultExceptNotLast | an `except:` block as not the last exception handler |
-| F722 | ForwardAnnotationSyntaxError | syntax error in forward annotation '...' |
-| F821 | UndefinedName | Undefined name `...` |
-| F822 | UndefinedExport | Undefined name `...` in `__all__` |
-| F823 | UndefinedLocal | Local variable `...` referenced before assignment |
-| F831 | DuplicateArgumentName | Duplicate argument name in function definition |
-| F841 | UnusedVariable | Local variable `...` is assigned to but never used |
-| F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` |
-| A001 | BuiltinVariableShadowing | Variable `...` is shadowing a python builtin |
-| A002 | BuiltinArgumentShadowing | Argument `...` is shadowing a python builtin |
-| A003 | BuiltinAttributeShadowing | class attribute `...` is shadowing a python builtin |
-| SPR001 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` |
-| R001 | UselessObjectInheritance | Class `...` inherits from object |
-| R002 | NoAssertEquals | `assertEquals` is deprecated, use `assertEqual` instead |
-| M001 | UnusedNOQA | Unused `noqa` directive |
+The ✅ emoji indicates a rule is enabled by default.
+
+The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` command-line option.
+
+| Code | Name | Message |     |     |
+| ---- | ---- | ------- | --- | --- |
+| E402 | ModuleImportNotAtTopOfFile | Module level import not at top of file | ✅ |  |
+| E501 | LineTooLong | Line too long (89 > 88 characters) | ✅ |  |
+| E711 | NoneComparison | Comparison to `None` should be `cond is None` | ✅ |  |
+| E712 | TrueFalseComparison | Comparison to `True` should be `cond is True` | ✅ |  |
+| E713 | NotInTest | Test for membership should be `not in` | ✅ |  |
+| E714 | NotIsTest | Test for object identity should be `is not` | ✅ |  |
+| E721 | TypeComparison | Do not compare types, use `isinstance()` | ✅ |  |
+| E722 | DoNotUseBareExcept | Do not use bare `except` | ✅ |  |
+| E731 | DoNotAssignLambda | Do not assign a lambda expression, use a def | ✅ |  |
+| E741 | AmbiguousVariableName | Ambiguous variable name: `...` | ✅ |  |
+| E742 | AmbiguousClassName | Ambiguous class name: `...` | ✅ |  |
+| E743 | AmbiguousFunctionName | Ambiguous function name: `...` | ✅ |  |
+| E902 | IOError | IOError: `...` | ✅ |  |
+| E999 | SyntaxError | SyntaxError: `...` | ✅ |  |
+| F401 | UnusedImport | `...` imported but unused | ✅ | 🛠 |
+| F402 | ImportShadowedByLoopVar | Import `...` from line 1 shadowed by loop variable | ✅ |  |
+| F403 | ImportStarUsed | `from ... import *` used; unable to detect undefined names | ✅ |  |
+| F404 | LateFutureImport | `from __future__` imports must occur at the beginning of the file | ✅ |  |
+| F405 | ImportStarUsage | `...` may be undefined, or defined from star imports: `...` | ✅ |  |
+| F406 | ImportStarNotPermitted | `from ... import *` only allowed at module level | ✅ |  |
+| F407 | FutureFeatureNotDefined | Future feature `...` is not defined | ✅ |  |
+| F541 | FStringMissingPlaceholders | f-string without any placeholders | ✅ |  |
+| F601 | MultiValueRepeatedKeyLiteral | Dictionary key literal repeated | ✅ |  |
+| F602 | MultiValueRepeatedKeyVariable | Dictionary key `...` repeated | ✅ |  |
+| F621 | ExpressionsInStarAssignment | Too many expressions in star-unpacking assignment | ✅ |  |
+| F622 | TwoStarredExpressions | Two starred expressions in assignment | ✅ |  |
+| F631 | AssertTuple | Assert test is a non-empty tuple, which is always `True` | ✅ |  |
+| F632 | IsLiteral | Use `==` and `!=` to compare constant literals | ✅ |  |
+| F633 | InvalidPrintSyntax | Use of `>>` is invalid with `print` function | ✅ |  |
+| F634 | IfTuple | If test is a tuple, which is always `True` | ✅ |  |
+| F701 | BreakOutsideLoop | `break` outside loop | ✅ |  |
+| F702 | ContinueOutsideLoop | `continue` not properly in loop | ✅ |  |
+| F704 | YieldOutsideFunction | `yield` or `yield from` statement outside of a function/method | ✅ |  |
+| F706 | ReturnOutsideFunction | `return` statement outside of a function/method | ✅ |  |
+| F707 | DefaultExceptNotLast | An `except:` block as not the last exception handler | ✅ |  |
+| F722 | ForwardAnnotationSyntaxError | Syntax error in forward annotation: `...` | ✅ |  |
+| F821 | UndefinedName | Undefined name `...` | ✅ |  |
+| F822 | UndefinedExport | Undefined name `...` in `__all__` | ✅ |  |
+| F823 | UndefinedLocal | Local variable `...` referenced before assignment | ✅ |  |
+| F831 | DuplicateArgumentName | Duplicate argument name in function definition | ✅ |  |
+| F841 | UnusedVariable | Local variable `...` is assigned to but never used | ✅ |  |
+| F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` | ✅ |  |
+| A001 | BuiltinVariableShadowing | Variable `...` is shadowing a python builtin |  |  |
+| A002 | BuiltinArgumentShadowing | Argument `...` is shadowing a python builtin |  |  |
+| A003 | BuiltinAttributeShadowing | Class attribute `...` is shadowing a python builtin |  |  |
+| SPR001 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` |  | 🛠 |
+| T201 | PrintFound | `print` found |  | 🛠 |
+| T203 | PPrintFound | `pprint` found |  | 🛠 |
+| U001 | UselessMetaclassType | `__metaclass__ = type` is implied |  | 🛠 |
+| R001 | UselessObjectInheritance | Class `...` inherits from object |  | 🛠 |
+| R002 | NoAssertEquals | `assertEquals` is deprecated, use `assertEqual` instead |  | 🛠 |
+| M001 | UnusedNOQA | Unused `noqa` directive |  | 🛠 |
 
 ## Integrations
 
@@ -469,4 +483,4 @@ MIT
 ## Contributing
 
 Contributions are welcome and hugely appreciated. To get started, check out the
-[contributing guidelines](https://github.com/charliermarsh/ruff/blob/main/CONTRIBUTORS.md).
+[contributing guidelines](https://github.com/charliermarsh/ruff/blob/main/CONTRIBUTING.md).

examples/generate_rules_table.rs

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

resources/test/fixtures/SPR001.py

@@ -20,3 +20,46 @@ class Child(Parent):
             Child,
             self,
         ).method()  # wrong
+
+
+class BaseClass:
+    def f(self):
+        print("f")
+
+
+def defined_outside(self):
+    super(MyClass, self).f()  # CANNOT use super()
+
+
+class MyClass(BaseClass):
+    def normal(self):
+        super(MyClass, self).f()  # can use super()
+        super().f()
+
+    def different_argument(self, other):
+        super(MyClass, other).f()  # CANNOT use super()
+
+    def comprehension_scope(self):
+        [super(MyClass, self).f() for x in [1]]  # CANNOT use super()
+
+    def inner_functions(self):
+        def outer_argument():
+            super(MyClass, self).f()  # CANNOT use super()
+
+        def inner_argument(self):
+            super(MyClass, self).f()  # can use super()
+            super().f()
+
+        outer_argument()
+        inner_argument(self)
+
+    def inner_class(self):
+        class InnerClass:
+            super(MyClass, self).f()  # CANNOT use super()
+
+            def method(inner_self):
+                super(MyClass, self).f()  # CANNOT use super()
+
+        InnerClass().method()
+
+    defined_outside = defined_outside

resources/test/fixtures/T201.py

@@ -0,0 +1 @@
+print("Hello, world!")  # T201

resources/test/fixtures/T203.py

@@ -0,0 +1,10 @@
+from pprint import pprint
+
+pprint("Hello, world!")  # T203
+
+
+import pprint
+
+pprint.pprint("Hello, world!")  # T203
+
+pprint.pformat("Hello, world!")

resources/test/fixtures/U001.py

@@ -0,0 +1,13 @@
+class A:
+    __metaclass__ = type
+
+
+class B:
+    __metaclass__ = type
+
+    def __init__(self) -> None:
+        pass
+
+
+class C(metaclass=type):
+    pass

src/ast/checks.rs

@@ -3,8 +3,8 @@ use std::collections::BTreeSet;
 use itertools::izip;
 use regex::Regex;
 use rustpython_parser::ast::{
-    Arg, Arguments, Cmpop, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprKind, Keyword,
-    Location, Stmt, StmtKind, Unaryop,
+    Arg, ArgData, Arguments, Cmpop, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprKind,
+    Keyword, Location, Stmt, StmtKind, Unaryop,
 };
 
 use crate::ast::operations::SourceCodeLocator;
@@ -116,6 +116,26 @@ pub fn check_do_not_assign_lambda(value: &Expr, location: Range) -> Option<Check
     }
 }
 
+/// Check UselessMetaclassType compliance.
+pub fn check_useless_metaclass_type(
+    targets: &Vec<Expr>,
+    value: &Expr,
+    location: Range,
+) -> Option<Check> {
+    if targets.len() == 1 {
+        if let ExprKind::Name { id, .. } = targets.first().map(|expr| &expr.node).unwrap() {
+            if id == "__metaclass__" {
+                if let ExprKind::Name { id, .. } = &value.node {
+                    if id == "type" {
+                        return Some(Check::new(CheckKind::UselessMetaclassType, location));
+                    }
+                }
+            }
+        }
+    }
+    None
+}
+
 fn is_ambiguous_name(name: &str) -> bool {
     name == "l" || name == "I" || name == "O"
 }
@@ -576,10 +596,7 @@ pub fn check_starred_expressions(
     if check_too_many_expressions {
         if let Some(starred_index) = starred_index {
             if starred_index >= 1 << 8 || elts.len() - starred_index > 1 << 24 {
-                return Some(Check::new(
-                    CheckKind::TooManyExpressionsInStarredAssignment,
-                    location,
-                ));
+                return Some(Check::new(CheckKind::ExpressionsInStarAssignment, location));
             }
         }
     }
@@ -696,28 +713,106 @@ pub fn check_builtin_shadowing(
     }
 }
 
+/// Returns `true` if a call is an argumented `super` invocation.
+pub fn is_super_call_with_arguments(func: &Expr, args: &Vec<Expr>) -> bool {
+    // Check: is this a `super` call?
+    if let ExprKind::Name { id, .. } = &func.node {
+        id == "super" && !args.is_empty()
+    } else {
+        false
+    }
+}
+
 // flake8-super
 /// Check that `super()` has no args
 pub fn check_super_args(
+    scope: &Scope,
+    parents: &[&Stmt],
     expr: &Expr,
     func: &Expr,
     args: &Vec<Expr>,
-    locator: &mut SourceCodeLocator,
-    autofix: &fixer::Mode,
 ) -> Option<Check> {
-    if let ExprKind::Name { id, .. } = &func.node {
-        if id == "super" && !args.is_empty() {
-            let mut check = Check::new(
-                CheckKind::SuperCallWithParameters,
-                Range::from_located(expr),
-            );
-            if matches!(autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
-                if let Some(fix) = fixes::remove_super_arguments(locator, expr) {
-                    check.amend(fix);
+    if !is_super_call_with_arguments(func, args) {
+        return None;
+    }
+
+    // Check: are we in a Function scope?
+    if !matches!(scope.kind, ScopeKind::Function { .. }) {
+        return None;
+    }
+
+    let mut parents = parents.iter().rev();
+
+    // For a `super` invocation to be unnecessary, the first argument needs to match the enclosing
+    // class, and the second argument needs to match the first argument to the enclosing function.
+    if let [first_arg, second_arg] = args.as_slice() {
+        // Find the enclosing function definition (if any).
+        if let Some(StmtKind::FunctionDef {
+            args: parent_args, ..
+        }) = parents
+            .find(|stmt| matches!(stmt.node, StmtKind::FunctionDef { .. }))
+            .map(|stmt| &stmt.node)
+        {
+            // Extract the name of the first argument to the enclosing function.
+            if let Some(ArgData {
+                arg: parent_arg, ..
+            }) = parent_args.args.first().map(|expr| &expr.node)
+            {
+                // Find the enclosing class definition (if any).
+                if let Some(StmtKind::ClassDef {
+                    name: parent_name, ..
+                }) = parents
+                    .find(|stmt| matches!(stmt.node, StmtKind::ClassDef { .. }))
+                    .map(|stmt| &stmt.node)
+                {
+                    if let (
+                        ExprKind::Name {
+                            id: first_arg_id, ..
+                        },
+                        ExprKind::Name {
+                            id: second_arg_id, ..
+                        },
+                    ) = (&first_arg.node, &second_arg.node)
+                    {
+                        if first_arg_id == parent_name && second_arg_id == parent_arg {
+                            return Some(Check::new(
+                                CheckKind::SuperCallWithParameters,
+                                Range::from_located(expr),
+                            ));
+                        }
+                    }
                 }
             }
-            return Some(check);
         }
     }
+
+    None
+}
+
+// flake8-print
+/// Check whether a function call is a `print` or `pprint` invocation
+pub fn check_print_call(expr: &Expr, func: &Expr) -> Option<Check> {
+    if let ExprKind::Name { id, .. } = &func.node {
+        if id == "print" {
+            return Some(Check::new(CheckKind::PrintFound, Range::from_located(expr)));
+        } else if id == "pprint" {
+            return Some(Check::new(
+                CheckKind::PPrintFound,
+                Range::from_located(expr),
+            ));
+        }
+    }
+
+    if let ExprKind::Attribute { value, attr, .. } = &func.node {
+        if let ExprKind::Name { id, .. } = &value.node {
+            if id == "pprint" && attr == "pprint" {
+                return Some(Check::new(
+                    CheckKind::PPrintFound,
+                    Range::from_located(expr),
+                ));
+            }
+        }
+    }
+
     None
 }

src/autofix/fixes.rs

@@ -224,7 +224,7 @@ fn is_lone_child(child: &Stmt, parent: &Stmt, deleted: &[&Stmt]) -> Result<bool>
     }
 }
 
-fn remove_stmt(stmt: &Stmt, parent: Option<&Stmt>, deleted: &[&Stmt]) -> Result<Fix> {
+pub fn remove_stmt(stmt: &Stmt, parent: Option<&Stmt>, deleted: &[&Stmt]) -> Result<Fix> {
     if parent
         .map(|parent| is_lone_child(stmt, parent, deleted))
         .map_or(Ok(None), |v| v.map(Some))?

src/check_ast.rs

@@ -621,7 +621,7 @@ where
                     }
                 }
             }
-            StmtKind::Assign { value, .. } => {
+            StmtKind::Assign { targets, value, .. } => {
                 if self.settings.select.contains(&CheckCode::E731) {
                     if let Some(check) = checks::check_do_not_assign_lambda(
                         value,
@@ -630,6 +630,37 @@ where
                         self.checks.push(check);
                     }
                 }
+                if self.settings.select.contains(&CheckCode::U001) {
+                    if let Some(mut check) = checks::check_useless_metaclass_type(
+                        targets,
+                        value,
+                        self.locate_check(Range::from_located(stmt)),
+                    ) {
+                        if matches!(self.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                            let context = self.binding_context();
+                            let deleted: Vec<&Stmt> = self
+                                .deletions
+                                .iter()
+                                .map(|index| self.parents[*index])
+                                .collect();
+
+                            match fixes::remove_stmt(
+                                self.parents[context.defined_by],
+                                context.defined_in.map(|index| self.parents[index]),
+                                &deleted,
+                            ) {
+                                Ok(fix) => {
+                                    if fix.content.is_empty() || fix.content == "pass" {
+                                        self.deletions.insert(context.defined_by);
+                                    }
+                                    check.amend(fix)
+                                }
+                                Err(e) => error!("Failed to fix unused imports: {}", e),
+                            }
+                        }
+                        self.checks.push(check);
+                    }
+                }
             }
             StmtKind::AnnAssign { value, .. } => {
                 if self.settings.select.contains(&CheckCode::E731) {
@@ -754,9 +785,64 @@ where
 
                 // flake8-super
                 if self.settings.select.contains(&CheckCode::SPR001) {
-                    if let Some(check) =
-                        checks::check_super_args(expr, func, args, &mut self.locator, self.autofix)
-                    {
+                    // Only bother going through the super check at all if we're in a `super` call.
+                    // (We check this in `check_super_args` too, so this is just an optimization.)
+                    if checks::is_super_call_with_arguments(func, args) {
+                        let scope = &mut self.scopes
+                            [*(self.scope_stack.last().expect("No current scope found."))];
+                        let parents: Vec<&Stmt> = self
+                            .parent_stack
+                            .iter()
+                            .map(|index| self.parents[*index])
+                            .collect();
+                        if let Some(mut check) =
+                            checks::check_super_args(scope, &parents, expr, func, args)
+                        {
+                            if matches!(self.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                                if let Some(fix) =
+                                    fixes::remove_super_arguments(&mut self.locator, expr)
+                                {
+                                    check.amend(fix);
+                                }
+                            }
+                            self.checks.push(check)
+                        }
+                    }
+                }
+
+                // flake8-print
+                if self.settings.select.contains(&CheckCode::T201)
+                    || self.settings.select.contains(&CheckCode::T203)
+                {
+                    if let Some(mut check) = checks::check_print_call(expr, func) {
+                        if matches!(self.autofix, fixer::Mode::Generate | fixer::Mode::Apply) {
+                            let context = self.binding_context();
+                            if matches!(
+                                self.parents[context.defined_by].node,
+                                StmtKind::Expr { .. }
+                            ) {
+                                let deleted: Vec<&Stmt> = self
+                                    .deletions
+                                    .iter()
+                                    .map(|index| self.parents[*index])
+                                    .collect();
+
+                                match fixes::remove_stmt(
+                                    self.parents[context.defined_by],
+                                    context.defined_in.map(|index| self.parents[index]),
+                                    &deleted,
+                                ) {
+                                    Ok(fix) => {
+                                        if fix.content.is_empty() || fix.content == "pass" {
+                                            self.deletions.insert(context.defined_by);
+                                        }
+                                        check.amend(fix)
+                                    }
+                                    Err(e) => error!("Failed to fix unused imports: {}", e),
+                                }
+                            }
+                        }
+
                         self.checks.push(check)
                     }
                 }
@@ -1342,14 +1428,14 @@ impl<'a> Checker<'a> {
                         let scope = &self.scopes[*scope_index];
                         for (name, binding) in scope.values.iter() {
                             if matches!(binding.kind, BindingKind::StarImportation) {
-                                from_list.push(name.as_str());
+                                from_list.push(name.to_string());
                             }
                         }
                     }
                     from_list.sort();
 
                     self.checks.push(Check::new(
-                        CheckKind::ImportStarUsage(id.clone(), from_list.join(", ")),
+                        CheckKind::ImportStarUsage(id.clone(), from_list),
                         self.locate_check(Range::from_located(expr)),
                     ));
                 }
@@ -1607,7 +1693,7 @@ impl<'a> Checker<'a> {
                         let mut from_list = vec![];
                         for (name, binding) in scope.values.iter() {
                             if matches!(binding.kind, BindingKind::StarImportation) {
-                                from_list.push(name.as_str());
+                                from_list.push(name.to_string());
                             }
                         }
                         from_list.sort();
@@ -1615,7 +1701,7 @@ impl<'a> Checker<'a> {
                         for name in names {
                             if !scope.values.contains_key(name) {
                                 self.checks.push(Check::new(
-                                    CheckKind::ImportStarUsage(name.clone(), from_list.join(", ")),
+                                    CheckKind::ImportStarUsage(name.clone(), from_list.clone()),
                                     self.locate_check(all_binding.range),
                                 ));
                             }

src/checks.rs

@@ -2,10 +2,11 @@ use std::str::FromStr;
 
 use crate::ast::types::Range;
 use anyhow::Result;
+use itertools::Itertools;
 use rustpython_parser::ast::Location;
 use serde::{Deserialize, Serialize};
 
-pub const DEFAULT_CHECK_CODES: [CheckCode; 46] = [
+pub const DEFAULT_CHECK_CODES: [CheckCode; 42] = [
     // pycodestyle
     CheckCode::E402,
     CheckCode::E501,
@@ -50,15 +51,9 @@ pub const DEFAULT_CHECK_CODES: [CheckCode; 46] = [
     CheckCode::F831,
     CheckCode::F841,
     CheckCode::F901,
-    // flake8-builtins
-    CheckCode::A001,
-    CheckCode::A002,
-    CheckCode::A003,
-    // flake8-super
-    CheckCode::SPR001,
 ];
 
-pub const ALL_CHECK_CODES: [CheckCode; 49] = [
+pub const ALL_CHECK_CODES: [CheckCode; 52] = [
     // pycodestyle
     CheckCode::E402,
     CheckCode::E501,
@@ -109,11 +104,16 @@ pub const ALL_CHECK_CODES: [CheckCode; 49] = [
     CheckCode::A003,
     // flake8-super
     CheckCode::SPR001,
-    // Meta
-    CheckCode::M001,
+    // flake8-print
+    CheckCode::T201,
+    CheckCode::T203,
+    // pyupgrade
+    CheckCode::U001,
     // Refactor
     CheckCode::R001,
     CheckCode::R002,
+    // Meta
+    CheckCode::M001,
 ];
 
 #[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize, Hash, PartialOrd, Ord)]
@@ -168,6 +168,11 @@ pub enum CheckCode {
     A003,
     // flake8-super
     SPR001,
+    // flake8-print
+    T201,
+    T203,
+    // pyupgrade
+    U001,
     // Refactor
     R001,
     R002,
@@ -230,6 +235,8 @@ impl FromStr for CheckCode {
             "A003" => Ok(CheckCode::A003),
             // flake8-super
             "SPR001" => Ok(CheckCode::SPR001),
+            // pyupgrade
+            "U001" => Ok(CheckCode::U001),
             // Refactor
             "R001" => Ok(CheckCode::R001),
             "R002" => Ok(CheckCode::R002),
@@ -293,6 +300,11 @@ impl CheckCode {
             CheckCode::A003 => "A003",
             // flake8-super
             CheckCode::SPR001 => "SPR001",
+            // flake8-print
+            CheckCode::T201 => "T201",
+            CheckCode::T203 => "T203",
+            // pyupgrade
+            CheckCode::U001 => "U001",
             // Refactor
             CheckCode::R001 => "R001",
             CheckCode::R002 => "R002",
@@ -326,20 +338,22 @@ impl CheckCode {
             CheckCode::E741 => CheckKind::AmbiguousVariableName("...".to_string()),
             CheckCode::E742 => CheckKind::AmbiguousClassName("...".to_string()),
             CheckCode::E743 => CheckKind::AmbiguousFunctionName("...".to_string()),
-            CheckCode::E902 => CheckKind::IOError("...".to_string()),
-            CheckCode::E999 => CheckKind::SyntaxError("...".to_string()),
+            CheckCode::E902 => CheckKind::IOError("IOError: `...`".to_string()),
+            CheckCode::E999 => CheckKind::SyntaxError("`...`".to_string()),
             // pyflakes
             CheckCode::F401 => CheckKind::UnusedImport("...".to_string()),
             CheckCode::F402 => CheckKind::ImportShadowedByLoopVar("...".to_string(), 1),
             CheckCode::F403 => CheckKind::ImportStarUsed("...".to_string()),
             CheckCode::F404 => CheckKind::LateFutureImport,
-            CheckCode::F405 => CheckKind::ImportStarUsage("...".to_string(), "...".to_string()),
+            CheckCode::F405 => {
+                CheckKind::ImportStarUsage("...".to_string(), vec!["...".to_string()])
+            }
             CheckCode::F406 => CheckKind::ImportStarNotPermitted("...".to_string()),
             CheckCode::F407 => CheckKind::FutureFeatureNotDefined("...".to_string()),
             CheckCode::F541 => CheckKind::FStringMissingPlaceholders,
             CheckCode::F601 => CheckKind::MultiValueRepeatedKeyLiteral,
             CheckCode::F602 => CheckKind::MultiValueRepeatedKeyVariable("...".to_string()),
-            CheckCode::F621 => CheckKind::TooManyExpressionsInStarredAssignment,
+            CheckCode::F621 => CheckKind::ExpressionsInStarAssignment,
             CheckCode::F622 => CheckKind::TwoStarredExpressions,
             CheckCode::F631 => CheckKind::AssertTuple,
             CheckCode::F632 => CheckKind::IsLiteral,
@@ -363,6 +377,11 @@ impl CheckCode {
             CheckCode::A003 => CheckKind::BuiltinAttributeShadowing("...".to_string()),
             // flake8-super
             CheckCode::SPR001 => CheckKind::SuperCallWithParameters,
+            // flake8-print
+            CheckCode::T201 => CheckKind::PrintFound,
+            CheckCode::T203 => CheckKind::PPrintFound,
+            // pyupgrade
+            CheckCode::U001 => CheckKind::UselessMetaclassType,
             // Refactor
             CheckCode::R001 => CheckKind::UselessObjectInheritance("...".to_string()),
             CheckCode::R002 => CheckKind::NoAssertEquals,
@@ -387,7 +406,6 @@ pub enum RejectedCmpop {
 
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum CheckKind {
-    UnusedNOQA(Option<String>),
     AmbiguousClassName(String),
     AmbiguousFunctionName(String),
     AmbiguousVariableName(String),
@@ -398,14 +416,15 @@ pub enum CheckKind {
     DoNotAssignLambda,
     DoNotUseBareExcept,
     DuplicateArgumentName,
-    ForwardAnnotationSyntaxError(String),
+    ExpressionsInStarAssignment,
     FStringMissingPlaceholders,
+    ForwardAnnotationSyntaxError(String),
     FutureFeatureNotDefined(String),
     IOError(String),
     IfTuple,
     ImportShadowedByLoopVar(String, usize),
     ImportStarNotPermitted(String),
-    ImportStarUsage(String, String),
+    ImportStarUsage(String, Vec<String>),
     ImportStarUsed(String),
     InvalidPrintSyntax,
     IsLiteral,
@@ -421,7 +440,6 @@ pub enum CheckKind {
     RaiseNotImplemented,
     ReturnOutsideFunction,
     SyntaxError(String),
-    TooManyExpressionsInStarredAssignment,
     TrueFalseComparison(bool, RejectedCmpop),
     TwoStarredExpressions,
     TypeComparison,
@@ -429,7 +447,9 @@ pub enum CheckKind {
     UndefinedLocal(String),
     UndefinedName(String),
     UnusedImport(String),
+    UnusedNOQA(Option<String>),
     UnusedVariable(String),
+    UselessMetaclassType,
     UselessObjectInheritance(String),
     YieldOutsideFunction,
     // flake8-builtin
@@ -438,6 +458,9 @@ pub enum CheckKind {
     BuiltinAttributeShadowing(String),
     // flake8-super
     SuperCallWithParameters,
+    // flake8-print
+    PrintFound,
+    PPrintFound,
 }
 
 impl CheckKind {
@@ -454,6 +477,7 @@ impl CheckKind {
             CheckKind::DoNotAssignLambda => "DoNotAssignLambda",
             CheckKind::DoNotUseBareExcept => "DoNotUseBareExcept",
             CheckKind::DuplicateArgumentName => "DuplicateArgumentName",
+            CheckKind::ExpressionsInStarAssignment => "ExpressionsInStarAssignment",
             CheckKind::FStringMissingPlaceholders => "FStringMissingPlaceholders",
             CheckKind::ForwardAnnotationSyntaxError(_) => "ForwardAnnotationSyntaxError",
             CheckKind::FutureFeatureNotDefined(_) => "FutureFeatureNotDefined",
@@ -470,16 +494,12 @@ impl CheckKind {
             CheckKind::ModuleImportNotAtTopOfFile => "ModuleImportNotAtTopOfFile",
             CheckKind::MultiValueRepeatedKeyLiteral => "MultiValueRepeatedKeyLiteral",
             CheckKind::MultiValueRepeatedKeyVariable(_) => "MultiValueRepeatedKeyVariable",
-            CheckKind::NoAssertEquals => "NoAssertEquals",
             CheckKind::NoneComparison(_) => "NoneComparison",
             CheckKind::NotInTest => "NotInTest",
             CheckKind::NotIsTest => "NotIsTest",
             CheckKind::RaiseNotImplemented => "RaiseNotImplemented",
             CheckKind::ReturnOutsideFunction => "ReturnOutsideFunction",
             CheckKind::SyntaxError(_) => "SyntaxError",
-            CheckKind::TooManyExpressionsInStarredAssignment => {
-                "TooManyExpressionsInStarredAssignment"
-            }
             CheckKind::TrueFalseComparison(_, _) => "TrueFalseComparison",
             CheckKind::TwoStarredExpressions => "TwoStarredExpressions",
             CheckKind::TypeComparison => "TypeComparison",
@@ -488,15 +508,23 @@ impl CheckKind {
             CheckKind::UndefinedName(_) => "UndefinedName",
             CheckKind::UnusedImport(_) => "UnusedImport",
             CheckKind::UnusedVariable(_) => "UnusedVariable",
-            CheckKind::UselessObjectInheritance(_) => "UselessObjectInheritance",
             CheckKind::YieldOutsideFunction => "YieldOutsideFunction",
-            CheckKind::UnusedNOQA(_) => "UnusedNOQA",
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(_) => "BuiltinVariableShadowing",
             CheckKind::BuiltinArgumentShadowing(_) => "BuiltinArgumentShadowing",
             CheckKind::BuiltinAttributeShadowing(_) => "BuiltinAttributeShadowing",
             // flake8-super
             CheckKind::SuperCallWithParameters => "SuperCallWithParameters",
+            // flake8-print
+            CheckKind::PrintFound => "PrintFound",
+            CheckKind::PPrintFound => "PPrintFound",
+            // pyupgrade
+            CheckKind::UselessMetaclassType => "UselessMetaclassType",
+            // Refactor
+            CheckKind::NoAssertEquals => "NoAssertEquals",
+            CheckKind::UselessObjectInheritance(_) => "UselessObjectInheritance",
+            // Meta
+            CheckKind::UnusedNOQA(_) => "UnusedNOQA",
         }
     }
 
@@ -529,14 +557,13 @@ impl CheckKind {
             CheckKind::ModuleImportNotAtTopOfFile => &CheckCode::E402,
             CheckKind::MultiValueRepeatedKeyLiteral => &CheckCode::F601,
             CheckKind::MultiValueRepeatedKeyVariable(_) => &CheckCode::F602,
-            CheckKind::NoAssertEquals => &CheckCode::R002,
             CheckKind::NoneComparison(_) => &CheckCode::E711,
             CheckKind::NotInTest => &CheckCode::E713,
             CheckKind::NotIsTest => &CheckCode::E714,
             CheckKind::RaiseNotImplemented => &CheckCode::F901,
             CheckKind::ReturnOutsideFunction => &CheckCode::F706,
             CheckKind::SyntaxError(_) => &CheckCode::E999,
-            CheckKind::TooManyExpressionsInStarredAssignment => &CheckCode::F621,
+            CheckKind::ExpressionsInStarAssignment => &CheckCode::F621,
             CheckKind::TrueFalseComparison(_, _) => &CheckCode::E712,
             CheckKind::TwoStarredExpressions => &CheckCode::F622,
             CheckKind::TypeComparison => &CheckCode::E721,
@@ -544,9 +571,7 @@ impl CheckKind {
             CheckKind::UndefinedLocal(_) => &CheckCode::F823,
             CheckKind::UndefinedName(_) => &CheckCode::F821,
             CheckKind::UnusedImport(_) => &CheckCode::F401,
-            CheckKind::UnusedNOQA(_) => &CheckCode::M001,
             CheckKind::UnusedVariable(_) => &CheckCode::F841,
-            CheckKind::UselessObjectInheritance(_) => &CheckCode::R001,
             CheckKind::YieldOutsideFunction => &CheckCode::F704,
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(_) => &CheckCode::A001,
@@ -554,6 +579,16 @@ impl CheckKind {
             CheckKind::BuiltinAttributeShadowing(_) => &CheckCode::A003,
             // flake8-super
             CheckKind::SuperCallWithParameters => &CheckCode::SPR001,
+            // flake8-print
+            CheckKind::PrintFound => &CheckCode::T201,
+            CheckKind::PPrintFound => &CheckCode::T203,
+            // pyupgrade
+            CheckKind::UselessMetaclassType => &CheckCode::U001,
+            // Refactor
+            CheckKind::NoAssertEquals => &CheckCode::R002,
+            CheckKind::UselessObjectInheritance(_) => &CheckCode::R001,
+            // Meta
+            CheckKind::UnusedNOQA(_) => &CheckCode::M001,
         }
     }
 
@@ -561,13 +596,13 @@ impl CheckKind {
     pub fn body(&self) -> String {
         match self {
             CheckKind::AmbiguousClassName(name) => {
-                format!("ambiguous class name '{}'", name)
+                format!("Ambiguous class name: `{}`", name)
             }
             CheckKind::AmbiguousFunctionName(name) => {
-                format!("ambiguous function name '{}'", name)
+                format!("Ambiguous function name: `{}`", name)
             }
             CheckKind::AmbiguousVariableName(name) => {
-                format!("ambiguous variable name '{}'", name)
+                format!("Ambiguous variable name: `{}`", name)
             }
             CheckKind::AssertTuple => {
                 "Assert test is a non-empty tuple, which is always `True`".to_string()
@@ -575,7 +610,7 @@ impl CheckKind {
             CheckKind::BreakOutsideLoop => "`break` outside loop".to_string(),
             CheckKind::ContinueOutsideLoop => "`continue` not properly in loop".to_string(),
             CheckKind::DefaultExceptNotLast => {
-                "an `except:` block as not the last exception handler".to_string()
+                "An `except:` block as not the last exception handler".to_string()
             }
             CheckKind::DoNotAssignLambda => {
                 "Do not assign a lambda expression, use a def".to_string()
@@ -585,19 +620,21 @@ impl CheckKind {
                 "Duplicate argument name in function definition".to_string()
             }
             CheckKind::ForwardAnnotationSyntaxError(body) => {
-                format!("syntax error in forward annotation '{body}'")
+                format!("Syntax error in forward annotation: `{body}`")
             }
             CheckKind::FStringMissingPlaceholders => {
                 "f-string without any placeholders".to_string()
             }
             CheckKind::FutureFeatureNotDefined(name) => {
-                format!("future feature '{name}' is not defined")
+                format!("Future feature `{name}` is not defined")
             }
             CheckKind::IOError(message) => message.clone(),
             CheckKind::IfTuple => "If test is a tuple, which is always `True`".to_string(),
-            CheckKind::InvalidPrintSyntax => "use of >> is invalid with print function".to_string(),
+            CheckKind::InvalidPrintSyntax => {
+                "Use of `>>` is invalid with `print` function".to_string()
+            }
             CheckKind::ImportShadowedByLoopVar(name, line) => {
-                format!("import '{name}' from line {line} shadowed by loop variable")
+                format!("Import `{name}` from line {line} shadowed by loop variable")
             }
             CheckKind::ImportStarNotPermitted(name) => {
                 format!("`from {name} import *` only allowed at module level")
@@ -606,11 +643,15 @@ impl CheckKind {
                 format!("`from {name} import *` used; unable to detect undefined names")
             }
             CheckKind::ImportStarUsage(name, sources) => {
-                format!("'{name}' may be undefined, or defined from star imports: {sources}")
+                let sources = sources
+                    .iter()
+                    .map(|source| format!("`{}`", source))
+                    .join(", ");
+                format!("`{name}` may be undefined, or defined from star imports: {sources}")
             }
-            CheckKind::IsLiteral => "use ==/!= to compare constant literals".to_string(),
+            CheckKind::IsLiteral => "Use `==` and `!=` to compare constant literals".to_string(),
             CheckKind::LateFutureImport => {
-                "from __future__ imports must occur at the beginning of the file".to_string()
+                "`from __future__` imports must occur at the beginning of the file".to_string()
             }
             CheckKind::LineTooLong(length, limit) => {
                 format!("Line too long ({length} > {limit} characters)")
@@ -624,9 +665,6 @@ impl CheckKind {
             CheckKind::MultiValueRepeatedKeyVariable(name) => {
                 format!("Dictionary key `{name}` repeated")
             }
-            CheckKind::NoAssertEquals => {
-                "`assertEquals` is deprecated, use `assertEqual` instead".to_string()
-            }
             CheckKind::NoneComparison(op) => match op {
                 RejectedCmpop::Eq => "Comparison to `None` should be `cond is None`".to_string(),
                 RejectedCmpop::NotEq => {
@@ -639,11 +677,11 @@ impl CheckKind {
                 "`raise NotImplemented` should be `raise NotImplementedError`".to_string()
             }
             CheckKind::ReturnOutsideFunction => {
-                "a `return` statement outside of a function/method".to_string()
+                "`return` statement outside of a function/method".to_string()
             }
             CheckKind::SyntaxError(message) => format!("SyntaxError: {message}"),
-            CheckKind::TooManyExpressionsInStarredAssignment => {
-                "too many expressions in star-unpacking assignment".to_string()
+            CheckKind::ExpressionsInStarAssignment => {
+                "Too many expressions in star-unpacking assignment".to_string()
             }
             CheckKind::TrueFalseComparison(value, op) => match *value {
                 true => match op {
@@ -663,8 +701,8 @@ impl CheckKind {
                     }
                 },
             },
-            CheckKind::TwoStarredExpressions => "two starred expressions in assignment".to_string(),
-            CheckKind::TypeComparison => "do not compare types, use `isinstance()`".to_string(),
+            CheckKind::TwoStarredExpressions => "Two starred expressions in assignment".to_string(),
+            CheckKind::TypeComparison => "Do not compare types, use `isinstance()`".to_string(),
             CheckKind::UndefinedExport(name) => {
                 format!("Undefined name `{name}` in `__all__`")
             }
@@ -678,16 +716,10 @@ impl CheckKind {
             CheckKind::UnusedVariable(name) => {
                 format!("Local variable `{name}` is assigned to but never used")
             }
-            CheckKind::UselessObjectInheritance(name) => {
-                format!("Class `{name}` inherits from object")
-            }
             CheckKind::YieldOutsideFunction => {
-                "a `yield` or `yield from` statement outside of a function/method".to_string()
+                "`yield` or `yield from` statement outside of a function/method".to_string()
             }
-            CheckKind::UnusedNOQA(code) => match code {
-                None => "Unused `noqa` directive".to_string(),
-                Some(code) => format!("Unused `noqa` directive for: {code}"),
-            },
+
             // flake8-builtins
             CheckKind::BuiltinVariableShadowing(name) => {
                 format!("Variable `{name}` is shadowing a python builtin")
@@ -696,12 +728,29 @@ impl CheckKind {
                 format!("Argument `{name}` is shadowing a python builtin")
             }
             CheckKind::BuiltinAttributeShadowing(name) => {
-                format!("class attribute `{name}` is shadowing a python builtin")
+                format!("Class attribute `{name}` is shadowing a python builtin")
             }
             // flake8-super
             CheckKind::SuperCallWithParameters => {
                 "Use `super()` instead of `super(__class__, self)`".to_string()
             }
+            // flake8-print
+            CheckKind::PrintFound => "`print` found".to_string(),
+            CheckKind::PPrintFound => "`pprint` found".to_string(),
+            // pyupgrade
+            CheckKind::UselessMetaclassType => "`__metaclass__ = type` is implied".to_string(),
+            // Refactor
+            CheckKind::NoAssertEquals => {
+                "`assertEquals` is deprecated, use `assertEqual` instead".to_string()
+            }
+            CheckKind::UselessObjectInheritance(name) => {
+                format!("Class `{name}` inherits from object")
+            }
+            // Meta
+            CheckKind::UnusedNOQA(code) => match code {
+                None => "Unused `noqa` directive".to_string(),
+                Some(code) => format!("Unused `noqa` directive for: {code}"),
+            },
         }
     }
 
@@ -710,10 +759,13 @@ impl CheckKind {
         matches!(
             self,
             CheckKind::NoAssertEquals
-                | CheckKind::UselessObjectInheritance(_)
-                | CheckKind::UnusedNOQA(_)
+                | CheckKind::PPrintFound
+                | CheckKind::PrintFound
                 | CheckKind::SuperCallWithParameters
                 | CheckKind::UnusedImport(_)
+                | CheckKind::UnusedNOQA(_)
+                | CheckKind::UselessMetaclassType
+                | CheckKind::UselessObjectInheritance(_)
         )
     }
 }

src/linter.rs

@@ -779,4 +779,40 @@ mod tests {
         insta::assert_yaml_snapshot!(checks);
         Ok(())
     }
+
+    #[test]
+    fn t201() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/T201.py"),
+            &settings::Settings::for_rule(CheckCode::T201),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn t203() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/T203.py"),
+            &settings::Settings::for_rule(CheckCode::T203),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
+    #[test]
+    fn u001() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/U001.py"),
+            &settings::Settings::for_rule(CheckCode::U001),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
 }

src/noqa.rs

@@ -47,10 +47,9 @@ pub fn extract_noqa_directive(line: &str) -> Directive {
 pub fn extract_noqa_line_for(lxr: &[LexResult]) -> Vec<usize> {
     let mut noqa_line_for: Vec<usize> = vec![];
 
-    let mut last_is_string = false;
-    let mut last_seen = usize::MIN;
     let mut min_line = usize::MAX;
     let mut max_line = usize::MIN;
+    let mut in_string = false;
 
     for (start, tok, end) in lxr.iter().flatten() {
         if matches!(tok, Tok::EndOfFile) {
@@ -62,29 +61,20 @@ pub fn extract_noqa_line_for(lxr: &[LexResult]) -> Vec<usize> {
             max_line = max(max_line, start.row());
 
             // For now, we only care about preserving noqa directives across multi-line strings.
-            if last_is_string {
-                noqa_line_for.extend(vec![max_line; (max_line + 1) - min_line]);
-            } else {
-                for i in (min_line - 1)..(max_line) {
+            if in_string {
+                for i in (noqa_line_for.len())..(min_line - 1) {
                     noqa_line_for.push(i + 1);
                 }
+                noqa_line_for.extend(vec![max_line; (max_line + 1) - min_line]);
             }
 
             min_line = usize::MAX;
             max_line = usize::MIN;
         } else {
-            // Handle empty lines.
-            if start.row() > last_seen {
-                for i in last_seen..(start.row() - 1) {
-                    noqa_line_for.push(i + 1);
-                }
-            }
-
             min_line = min(min_line, start.row());
             max_line = max(max_line, end.row());
         }
-        last_seen = start.row();
-        last_is_string = matches!(tok, Tok::String { .. });
+        in_string = matches!(tok, Tok::String { .. });
     }
 
     noqa_line_for
@@ -173,6 +163,8 @@ mod tests {
 
     #[test]
     fn extraction() -> Result<()> {
+        let empty: Vec<usize> = Default::default();
+
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
             "x = 1
 y = 2
@@ -180,7 +172,7 @@ z = x + 1",
         )
         .collect();
         println!("{:?}", extract_noqa_line_for(&lxr));
-        assert_eq!(extract_noqa_line_for(&lxr), vec![1, 2, 3]);
+        assert_eq!(extract_noqa_line_for(&lxr), empty);
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
             "
@@ -190,7 +182,7 @@ z = x + 1",
         )
         .collect();
         println!("{:?}", extract_noqa_line_for(&lxr));
-        assert_eq!(extract_noqa_line_for(&lxr), vec![1, 2, 3, 4]);
+        assert_eq!(extract_noqa_line_for(&lxr), empty);
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
             "x = 1
@@ -200,7 +192,7 @@ z = x + 1
         )
         .collect();
         println!("{:?}", extract_noqa_line_for(&lxr));
-        assert_eq!(extract_noqa_line_for(&lxr), vec![1, 2, 3]);
+        assert_eq!(extract_noqa_line_for(&lxr), empty);
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
             "x = 1
@@ -211,7 +203,7 @@ z = x + 1
         )
         .collect();
         println!("{:?}", extract_noqa_line_for(&lxr));
-        assert_eq!(extract_noqa_line_for(&lxr), vec![1, 2, 3, 4]);
+        assert_eq!(extract_noqa_line_for(&lxr), empty);
 
         let lxr: Vec<LexResult> = lexer::make_tokenizer(
             "x = '''abc
@@ -222,7 +214,28 @@ y = 2
 z = x + 1",
         )
         .collect();
-        assert_eq!(extract_noqa_line_for(&lxr), vec![4, 4, 4, 4, 5, 6]);
+        assert_eq!(extract_noqa_line_for(&lxr), vec![4, 4, 4, 4]);
+
+        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+            "x = 1
+y = '''abc
+def
+ghi
+'''
+z = 2",
+        )
+        .collect();
+        assert_eq!(extract_noqa_line_for(&lxr), vec![1, 5, 5, 5, 5]);
+
+        let lxr: Vec<LexResult> = lexer::make_tokenizer(
+            "x = 1
+y = '''abc
+def
+ghi
+'''",
+        )
+        .collect();
+        assert_eq!(extract_noqa_line_for(&lxr), vec![1, 5, 5, 5, 5]);
 
         Ok(())
     }

src/snapshots/ruff__linter__tests__f405.snap

@@ -5,7 +5,7 @@ expression: checks
 - kind:
     ImportStarUsage:
       - name
-      - mymodule
+      - - mymodule
   location:
     row: 5
     column: 11
@@ -16,7 +16,7 @@ expression: checks
 - kind:
     ImportStarUsage:
       - a
-      - mymodule
+      - - mymodule
   location:
     row: 11
     column: 1

src/snapshots/ruff__linter__tests__spr001.snap

@@ -50,4 +50,36 @@ expression: checks
       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
 

src/snapshots/ruff__linter__tests__t201.snap

@@ -0,0 +1,21 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: PrintFound
+  location:
+    row: 1
+    column: 1
+  end_location:
+    row: 1
+    column: 23
+  fix:
+    content: ""
+    location:
+      row: 1
+      column: 1
+    end_location:
+      row: 2
+      column: 1
+    applied: false
+

src/snapshots/ruff__linter__tests__t203.snap

@@ -0,0 +1,37 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: PPrintFound
+  location:
+    row: 3
+    column: 1
+  end_location:
+    row: 3
+    column: 24
+  fix:
+    content: ""
+    location:
+      row: 3
+      column: 1
+    end_location:
+      row: 4
+      column: 1
+    applied: false
+- kind: PPrintFound
+  location:
+    row: 8
+    column: 1
+  end_location:
+    row: 8
+    column: 31
+  fix:
+    content: ""
+    location:
+      row: 8
+      column: 1
+    end_location:
+      row: 9
+      column: 1
+    applied: false
+

src/snapshots/ruff__linter__tests__u001.snap

@@ -0,0 +1,37 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind: UselessMetaclassType
+  location:
+    row: 2
+    column: 5
+  end_location:
+    row: 2
+    column: 25
+  fix:
+    content: pass
+    location:
+      row: 2
+      column: 5
+    end_location:
+      row: 2
+      column: 25
+    applied: false
+- kind: UselessMetaclassType
+  location:
+    row: 6
+    column: 5
+  end_location:
+    row: 6
+    column: 25
+  fix:
+    content: ""
+    location:
+      row: 6
+      column: 1
+    end_location:
+      row: 7
+      column: 1
+    applied: false
+