Bump version to 0.0.141

.pre-commit-config.yaml

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

Cargo.lock

@@ -670,7 +670,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.139-dev.0"
+version = "0.0.141-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.22",
@@ -1775,7 +1775,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.139"
+version = "0.0.141"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1825,7 +1825,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.139"
+version = "0.0.141"
 dependencies = [
  "anyhow",
  "clap 4.0.22",

Cargo.toml

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

LICENSE

@@ -242,6 +242,31 @@ are:
     SOFTWARE.
   """
 
+- flake8-debugger, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2016 Joseph Kahn
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+  """
+
 - flake8-tidy-imports, licensed as follows:
   """
     MIT License

README.md

@@ -59,6 +59,7 @@ Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-mu
    1. [flake8-boolean-trap (FBT)](#flake8-boolean-trap)
    1. [flake8-bugbear (B)](#flake8-bugbear)
    1. [flake8-builtins (A)](#flake8-builtins)
+   1. [flake8-debugger (T)](#flake8-debugger)
    1. [flake8-tidy-imports (I25)](#flake8-tidy-imports)
    1. [flake8-print (T)](#flake8-print)
    1. [flake8-quotes (Q)](#flake8-quotes)
@@ -107,7 +108,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.139
+    rev: v0.0.141
     hooks:
       - id: ruff
 ```
@@ -538,6 +539,14 @@ For more, see [flake8-comprehensions](https://pypi.org/project/flake8-comprehens
 | C416 | UnnecessaryComprehension | Unnecessary `(list\|set)` comprehension (rewrite using `(list\|set)()`) | 🛠 |
 | C417 | UnnecessaryMap | Unnecessary `map` usage (rewrite using a `(list\|set\|dict)` comprehension) |  |
 
+### flake8-debugger
+
+For more, see [flake8-debugger](https://pypi.org/project/flake8-debugger/4.1.2/) on PyPI.
+
+| Code | Name | Message | Fix |
+| ---- | ---- | ------- | --- |
+| T100 | Debugger | Import for `...` found |  |
+
 ### flake8-boolean-trap
 
 For more, see [flake8-boolean-trap](https://pypi.org/project/flake8-boolean-trap/0.1.0/) on PyPI.
@@ -825,6 +834,7 @@ including:
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
 - [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
 - [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
+- [`flake8-debugger`](https://pypi.org/project/flake8-debugger/)
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-tidy-imports`](https://pypi.org/project/flake8-tidy-imports/) (1/3)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
@@ -856,6 +866,7 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
 - [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
 - [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
+- [`flake8-debugger`](https://pypi.org/project/flake8-debugger/)
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-tidy-imports`](https://pypi.org/project/flake8-tidy-imports/) (1/3)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)

flake8_to_ruff/Cargo.lock

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

flake8_to_ruff/Cargo.toml

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

flake8_to_ruff/src/plugin.rs

@@ -10,6 +10,7 @@ pub enum Plugin {
     Flake8Bugbear,
     Flake8Builtins,
     Flake8Comprehensions,
+    Flake8Debugger,
     Flake8Docstrings,
     Flake8TidyImports,
     Flake8Print,
@@ -30,6 +31,7 @@ impl FromStr for Plugin {
             "flake8-bugbear" => Ok(Plugin::Flake8Bugbear),
             "flake8-builtins" => Ok(Plugin::Flake8Builtins),
             "flake8-comprehensions" => Ok(Plugin::Flake8Comprehensions),
+            "flake8-debugger" => Ok(Plugin::Flake8Debugger),
             "flake8-docstrings" => Ok(Plugin::Flake8Docstrings),
             "flake8-tidy-imports" => Ok(Plugin::Flake8TidyImports),
             "flake8-print" => Ok(Plugin::Flake8Print),
@@ -51,9 +53,10 @@ impl Plugin {
             Plugin::Flake8Bugbear => CheckCodePrefix::B,
             Plugin::Flake8Builtins => CheckCodePrefix::A,
             Plugin::Flake8Comprehensions => CheckCodePrefix::C4,
+            Plugin::Flake8Debugger => CheckCodePrefix::T1,
             Plugin::Flake8Docstrings => CheckCodePrefix::D,
             Plugin::Flake8TidyImports => CheckCodePrefix::I25,
-            Plugin::Flake8Print => CheckCodePrefix::T,
+            Plugin::Flake8Print => CheckCodePrefix::T2,
             Plugin::Flake8Quotes => CheckCodePrefix::Q,
             Plugin::Flake8Annotations => CheckCodePrefix::ANN,
             Plugin::Flake8BlindExcept => CheckCodePrefix::BLE,
@@ -69,6 +72,7 @@ impl Plugin {
             Plugin::Flake8Bugbear => vec![CheckCodePrefix::B],
             Plugin::Flake8Builtins => vec![CheckCodePrefix::A],
             Plugin::Flake8Comprehensions => vec![CheckCodePrefix::C4],
+            Plugin::Flake8Debugger => vec![CheckCodePrefix::T1],
             Plugin::Flake8Docstrings => {
                 // Use the user-provided docstring.
                 for key in ["docstring-convention", "docstring_convention"] {
@@ -86,7 +90,7 @@ impl Plugin {
                 DocstringConvention::PEP8.select()
             }
             Plugin::Flake8TidyImports => vec![CheckCodePrefix::I25],
-            Plugin::Flake8Print => vec![CheckCodePrefix::T],
+            Plugin::Flake8Print => vec![CheckCodePrefix::T2],
             Plugin::Flake8Quotes => vec![CheckCodePrefix::Q],
             Plugin::Flake8Annotations => vec![CheckCodePrefix::ANN],
             Plugin::Flake8BlindExcept => vec![CheckCodePrefix::BLE],
@@ -364,6 +368,7 @@ pub fn infer_plugins_from_codes(codes: &BTreeSet<CheckCodePrefix>) -> Vec<Plugin
         Plugin::Flake8Bugbear,
         Plugin::Flake8Builtins,
         Plugin::Flake8Comprehensions,
+        Plugin::Flake8Debugger,
         Plugin::Flake8Docstrings,
         Plugin::Flake8TidyImports,
         Plugin::Flake8Print,

resources/test/fixtures/B023.py

@@ -76,3 +76,7 @@ for var in range(2):
 
     def explicit_capture(captured=var):
         return captured
+
+
+for i in range(3):
+    lambda: f"{i}"

resources/test/fixtures/F821_3.py

@@ -12,3 +12,13 @@ x: dict["key", "value"]
 
 # OK
 x: dict[str, str]
+
+# OK
+def unimportant(name):
+    pass
+
+
+def dang(dict, set, list):
+    unimportant(name=dict["name"])
+    unimportant(name=set["name"])
+    unimportant(name=list["name"])

resources/test/fixtures/T100.py

@@ -0,0 +1,14 @@
+breakpoint()
+
+
+import pdb
+from builtins import breakpoint
+from pdb import set_trace as st
+from celery.contrib.rdb import set_trace
+from celery.contrib import rdb
+import celery.contrib.rdb
+
+
+breakpoint()
+st()
+set_trace()

resources/test/fixtures/U009_0.py

@@ -1,3 +1,3 @@
 # coding=utf8
 
-print('Hello world')
+print("Hello world")

resources/test/fixtures/U009_4.py

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

resources/test/fixtures/U015.py

@@ -68,3 +68,13 @@ open(file="foo", mode='Ub', buffering=- 1, encoding=None, errors=None, newline=N
 open(file="foo", buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None, mode='Ub')
 open(file="foo", buffering=- 1, encoding=None, errors=None, mode='Ub', newline=None, closefd=True, opener=None)
 open(mode='Ub', file="foo", buffering=- 1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
+
+open = 1
+open("foo", "U")
+open("foo", "Ur")
+open("foo", "Ub")
+open("foo", "rUb")
+open("foo", "r")
+open("foo", "rt")
+open("f", "r", encoding="UTF-8")
+open("f", "wt")

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.139"
+version = "0.0.141"
 edition = "2021"
 
 [dependencies]

ruff_dev/src/generate_check_code_prefix.rs

@@ -130,6 +130,21 @@ pub fn main(cli: &Cli) -> Result<()> {
     output.push('\n');
     output.push('\n');
     output.push_str(&scope.to_string());
+    output.push('\n');
+    output.push('\n');
+
+    // Add the list of output categories (not generated).
+    output.push_str("pub const CATEGORIES: &[CheckCodePrefix] = &[");
+    output.push('\n');
+    for prefix in prefix_to_codes.keys() {
+        if prefix.chars().all(char::is_alphabetic) {
+            output.push_str(&format!("CheckCodePrefix::{prefix},"));
+            output.push('\n');
+        }
+    }
+    output.push_str("];");
+    output.push('\n');
+    output.push('\n');
 
     // Write the output to `src/checks_gen.rs` (or stdout).
     if cli.dry_run {

src/check_ast.rs

@@ -36,8 +36,9 @@ use crate::source_code_locator::SourceCodeLocator;
 use crate::visibility::{module_visibility, transition_scope, Modifier, Visibility, VisibleScope};
 use crate::{
     docstrings, flake8_2020, flake8_annotations, flake8_bandit, flake8_blind_except,
-    flake8_boolean_trap, flake8_bugbear, flake8_builtins, flake8_comprehensions, flake8_print,
-    flake8_tidy_imports, mccabe, pep8_naming, pycodestyle, pydocstyle, pyflakes, pyupgrade, rules,
+    flake8_boolean_trap, flake8_bugbear, flake8_builtins, flake8_comprehensions, flake8_debugger,
+    flake8_print, flake8_tidy_imports, mccabe, pep8_naming, pycodestyle, pydocstyle, pyflakes,
+    pyupgrade, rules,
 };
 
 const GLOBAL_SCOPE_INDEX: usize = 0;
@@ -177,6 +178,15 @@ impl<'a> Checker<'a> {
             || (typing::in_extensions(target)
                 && match_call_path(call_path, "typing_extensions", target, &self.from_imports))
     }
+
+    /// Return `true` if `member` is bound as a builtin.
+    pub fn is_builtin(&self, member: &str) -> bool {
+        self.current_scopes()
+            .find_map(|scope| scope.values.get(member))
+            .map_or(false, |binding| {
+                matches!(binding.kind, BindingKind::Builtin)
+            })
+    }
 }
 
 impl<'a, 'b> Visitor<'b> for Checker<'a>
@@ -626,6 +636,15 @@ where
                         );
                     }
 
+                    // flake8-debugger
+                    if self.settings.enabled.contains(&CheckCode::T100) {
+                        if let Some(check) =
+                            flake8_debugger::checks::debugger_import(stmt, None, &alias.node.name)
+                        {
+                            self.add_check(check);
+                        }
+                    }
+
                     if let Some(asname) = &alias.node.asname {
                         for alias in names {
                             if let Some(asname) = &alias.node.asname {
@@ -855,6 +874,17 @@ where
                         }
                     }
 
+                    // flake8-debugger
+                    if self.settings.enabled.contains(&CheckCode::T100) {
+                        if let Some(check) = flake8_debugger::checks::debugger_import(
+                            stmt,
+                            module.as_ref().map(String::as_str),
+                            &alias.node.name,
+                        ) {
+                            self.add_check(check);
+                        }
+                    }
+
                     if let Some(asname) = &alias.node.asname {
                         if self.settings.enabled.contains(&CheckCode::N811) {
                             if let Some(check) =
@@ -1625,6 +1655,18 @@ where
                     }
                 }
 
+                // flake8-debugger
+                if self.settings.enabled.contains(&CheckCode::T100) {
+                    if let Some(check) = flake8_debugger::checks::debugger_call(
+                        expr,
+                        func,
+                        &self.from_imports,
+                        &self.import_aliases,
+                    ) {
+                        self.add_check(check);
+                    }
+                }
+
                 // Ruff
                 if self.settings.enabled.contains(&CheckCode::RUF101) {
                     rules::plugins::convert_exit_to_sys_exit(self, func);
@@ -1964,6 +2006,7 @@ where
                         value,
                         &self.from_imports,
                         &self.import_aliases,
+                        |member| self.is_builtin(member),
                     ) {
                         Some(subscript) => {
                             match subscript {

src/check_lines.rs

@@ -38,6 +38,7 @@ pub fn check_lines(
     noqa_line_for: &IntMap<usize, usize>,
     settings: &Settings,
     autofix: bool,
+    ignore_noqa: bool,
 ) {
     let enforce_unnecessary_coding_comment = settings.enabled.contains(&CheckCode::U009);
     let enforce_line_too_long = settings.enabled.contains(&CheckCode::E501);
@@ -53,6 +54,30 @@ pub fn check_lines(
         assert!(check.location.row() >= 1);
     }
 
+    macro_rules! add_if {
+        ($check:expr, $noqa:expr) => {{
+            match $noqa {
+                (Directive::All(..), matches) => {
+                    matches.push($check.kind.code().as_ref());
+                    if ignore_noqa {
+                        line_checks.push($check);
+                    }
+                }
+                (Directive::Codes(.., codes), matches) => {
+                    if codes.contains(&$check.kind.code().as_ref()) {
+                        matches.push($check.kind.code().as_ref());
+                        if ignore_noqa {
+                            line_checks.push($check);
+                        }
+                    } else {
+                        line_checks.push($check);
+                    }
+                }
+                (Directive::None, ..) => line_checks.push($check),
+            }
+        }};
+    }
+
     let lines: Vec<&str> = contents.lines().collect();
     for (lineno, line) in lines.iter().enumerate() {
         // Grab the noqa (logical) line number for the current (physical) line.
@@ -65,21 +90,24 @@ pub fn check_lines(
             if lineno < 2 {
                 // PEP3120 makes utf-8 the default encoding.
                 if CODING_COMMENT_REGEX.is_match(line) {
-                    let line_length = line.len();
                     let mut check = Check::new(
                         CheckKind::PEP3120UnnecessaryCodingComment,
                         Range {
                             location: Location::new(lineno + 1, 0),
-                            end_location: Location::new(lineno + 1, line_length + 1),
+                            end_location: Location::new(lineno + 2, 0),
                         },
                     );
                     if autofix && settings.fixable.contains(check.kind.code()) {
                         check.amend(Fix::deletion(
                             Location::new(lineno + 1, 0),
-                            Location::new(lineno + 1, line_length + 1),
+                            Location::new(lineno + 2, 0),
                         ));
                     }
-                    line_checks.push(check);
+
+                    let noqa = noqa_directives.entry(noqa_lineno).or_insert_with(|| {
+                        (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![])
+                    });
+                    add_if!(check, noqa);
                 }
             }
         }
@@ -109,7 +137,7 @@ pub fn check_lines(
                         ignored.push(index);
                     }
                 }
-                (Directive::None, _) => {}
+                (Directive::None, ..) => {}
             }
         }
 
@@ -117,10 +145,6 @@ pub fn check_lines(
         if enforce_line_too_long {
             let line_length = line.chars().count();
             if should_enforce_line_length(line, line_length, settings.line_length) {
-                let noqa = noqa_directives
-                    .entry(noqa_lineno)
-                    .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
-
                 let check = Check::new(
                     CheckKind::LineTooLong(line_length, settings.line_length),
                     Range {
@@ -129,35 +153,19 @@ pub fn check_lines(
                     },
                 );
 
-                match noqa {
-                    (Directive::All(..), matches) => {
-                        matches.push(check.kind.code().as_ref());
-                    }
-                    (Directive::Codes(.., codes), matches) => {
-                        if codes.contains(&check.kind.code().as_ref()) {
-                            matches.push(check.kind.code().as_ref());
-                        } else {
-                            line_checks.push(check);
-                        }
-                    }
-                    (Directive::None, _) => line_checks.push(check),
-                }
+                let noqa = noqa_directives
+                    .entry(noqa_lineno)
+                    .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
+                add_if!(check, noqa);
             }
         }
     }
 
-    // Enforce newlines at end of files.
+    // Enforce newlines at end of files (W292).
     if settings.enabled.contains(&CheckCode::W292) && !contents.ends_with('\n') {
         // Note: if `lines.last()` is `None`, then `contents` is empty (and so we don't
         // want to raise W292 anyway).
         if let Some(line) = lines.last() {
-            let lineno = lines.len() - 1;
-            let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
-
-            let noqa = noqa_directives
-                .entry(noqa_lineno)
-                .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
-
             let check = Check::new(
                 CheckKind::NoNewLineAtEndOfFile,
                 Range {
@@ -166,23 +174,16 @@ pub fn check_lines(
                 },
             );
 
-            match noqa {
-                (Directive::All(..), matches) => {
-                    matches.push(check.kind.code().as_ref());
-                }
-                (Directive::Codes(.., codes), matches) => {
-                    if codes.contains(&check.kind.code().as_ref()) {
-                        matches.push(check.kind.code().as_ref());
-                    } else {
-                        line_checks.push(check);
-                    }
-                }
-                (Directive::None, _) => line_checks.push(check),
-            }
+            let lineno = lines.len() - 1;
+            let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
+            let noqa = noqa_directives
+                .entry(noqa_lineno)
+                .or_insert_with(|| (noqa::extract_noqa_directive(lines[noqa_lineno]), vec![]));
+            add_if!(check, noqa);
         }
     }
 
-    // Enforce that the noqa directive was actually used.
+    // Enforce that the noqa directive was actually used (M001).
     if enforce_noqa {
         for (row, (directive, matches)) in noqa_directives {
             match directive {
@@ -245,9 +246,11 @@ pub fn check_lines(
         }
     }
 
-    ignored.sort_unstable();
-    for index in ignored.iter().rev() {
-        checks.swap_remove(*index);
+    if !ignore_noqa {
+        ignored.sort_unstable();
+        for index in ignored.iter().rev() {
+            checks.swap_remove(*index);
+        }
     }
     checks.extend(line_checks);
 }
@@ -275,6 +278,7 @@ mod tests {
                     ..Settings::for_rule(CheckCode::E501)
                 },
                 true,
+                false,
             );
             checks
         };

src/checks.rs

@@ -7,6 +7,7 @@ use strum_macros::{AsRefStr, EnumIter, EnumString};
 
 use crate::ast::types::Range;
 use crate::autofix::Fix;
+use crate::flake8_debugger::types::DebuggerUsingType;
 use crate::flake8_quotes::settings::Quote;
 use crate::flake8_tidy_imports::settings::Strictness;
 use crate::pyupgrade::types::Primitive;
@@ -129,6 +130,8 @@ pub enum CheckCode {
     C415,
     C416,
     C417,
+    // flake8-debugger
+    T100,
     // mccabe
     C901,
     // flake8-tidy-imports
@@ -272,6 +275,7 @@ pub enum CheckCategory {
     PEP8Naming,
     Flake8Bandit,
     Flake8Comprehensions,
+    Flake8Debugger,
     Flake8BooleanTrap,
     Flake8Bugbear,
     Flake8Builtins,
@@ -297,6 +301,7 @@ impl CheckCategory {
             CheckCategory::Flake8Builtins => "flake8-builtins",
             CheckCategory::Flake8Bugbear => "flake8-bugbear",
             CheckCategory::Flake8Comprehensions => "flake8-comprehensions",
+            CheckCategory::Flake8Debugger => "flake8-debugger",
             CheckCategory::Flake8TidyImports => "flake8-tidy-imports",
             CheckCategory::Flake8Print => "flake8-print",
             CheckCategory::Flake8Quotes => "flake8-quotes",
@@ -326,6 +331,9 @@ impl CheckCategory {
             CheckCategory::Flake8Comprehensions => {
                 Some("https://pypi.org/project/flake8-comprehensions/3.10.1/")
             }
+            CheckCategory::Flake8Debugger => {
+                Some("https://pypi.org/project/flake8-debugger/4.1.2/")
+            }
             CheckCategory::Flake8TidyImports => {
                 Some("https://pypi.org/project/flake8-tidy-imports/4.8.0/")
             }
@@ -472,6 +480,8 @@ pub enum CheckKind {
     UnnecessarySubscriptReversal(String),
     UnnecessaryComprehension(String),
     UnnecessaryMap(String),
+    // flake8-debugger
+    Debugger(DebuggerUsingType),
     // flake8-tidy-imports
     BannedRelativeImport(Strictness),
     // flake8-print
@@ -754,6 +764,8 @@ impl CheckCode {
             }
             CheckCode::C416 => CheckKind::UnnecessaryComprehension("(list|set)".to_string()),
             CheckCode::C417 => CheckKind::UnnecessaryMap("(list|set|dict)".to_string()),
+            // flake8-debugger
+            CheckCode::T100 => CheckKind::Debugger(DebuggerUsingType::Import("...".to_string())),
             // flake8-tidy-imports
             CheckCode::I252 => CheckKind::BannedRelativeImport(Strictness::All),
             // flake8-print
@@ -1007,6 +1019,7 @@ impl CheckCode {
             CheckCode::C415 => CheckCategory::Flake8Comprehensions,
             CheckCode::C416 => CheckCategory::Flake8Comprehensions,
             CheckCode::C417 => CheckCategory::Flake8Comprehensions,
+            CheckCode::T100 => CheckCategory::Flake8Debugger,
             CheckCode::I252 => CheckCategory::Flake8TidyImports,
             CheckCode::T201 => CheckCategory::Flake8Print,
             CheckCode::T203 => CheckCategory::Flake8Print,
@@ -1234,6 +1247,8 @@ impl CheckKind {
             CheckKind::UnnecessarySubscriptReversal(_) => &CheckCode::C415,
             CheckKind::UnnecessaryComprehension(..) => &CheckCode::C416,
             CheckKind::UnnecessaryMap(_) => &CheckCode::C417,
+            // flake8-debugger
+            CheckKind::Debugger(_) => &CheckCode::T100,
             // flake8-tidy-imports
             CheckKind::BannedRelativeImport(_) => &CheckCode::I252,
             // flake8-print
@@ -1718,6 +1733,11 @@ impl CheckKind {
                     format!("Unnecessary `map` usage (rewrite using a `{obj_type}` comprehension)")
                 }
             }
+            // flake8-debugger
+            CheckKind::Debugger(using_type) => match using_type {
+                DebuggerUsingType::Call(name) => format!("Trace found: `{name}` used"),
+                DebuggerUsingType::Import(name) => format!("Import for `{name}` found"),
+            },
             // flake8-tidy-imports
             CheckKind::BannedRelativeImport(strictness) => match strictness {
                 Strictness::Parents => {

src/checks_gen.rs

@@ -290,6 +290,9 @@ pub enum CheckCodePrefix {
     S106,
     S107,
     T,
+    T1,
+    T10,
+    T100,
     T2,
     T20,
     T201,
@@ -1149,7 +1152,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::S105 => vec![CheckCode::S105],
             CheckCodePrefix::S106 => vec![CheckCode::S106],
             CheckCodePrefix::S107 => vec![CheckCode::S107],
-            CheckCodePrefix::T => vec![CheckCode::T201, CheckCode::T203],
+            CheckCodePrefix::T => vec![CheckCode::T100, CheckCode::T201, CheckCode::T203],
+            CheckCodePrefix::T1 => vec![CheckCode::T100],
+            CheckCodePrefix::T10 => vec![CheckCode::T100],
+            CheckCodePrefix::T100 => vec![CheckCode::T100],
             CheckCodePrefix::T2 => vec![CheckCode::T201, CheckCode::T203],
             CheckCodePrefix::T20 => vec![CheckCode::T201, CheckCode::T203],
             CheckCodePrefix::T201 => vec![CheckCode::T201],
@@ -1554,6 +1560,9 @@ impl CheckCodePrefix {
             CheckCodePrefix::S106 => PrefixSpecificity::Explicit,
             CheckCodePrefix::S107 => PrefixSpecificity::Explicit,
             CheckCodePrefix::T => PrefixSpecificity::Category,
+            CheckCodePrefix::T1 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::T10 => PrefixSpecificity::Tens,
+            CheckCodePrefix::T100 => PrefixSpecificity::Explicit,
             CheckCodePrefix::T2 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::T20 => PrefixSpecificity::Tens,
             CheckCodePrefix::T201 => PrefixSpecificity::Explicit,
@@ -1603,3 +1612,25 @@ impl CheckCodePrefix {
         }
     }
 }
+
+pub const CATEGORIES: &[CheckCodePrefix] = &[
+    CheckCodePrefix::A,
+    CheckCodePrefix::ANN,
+    CheckCodePrefix::B,
+    CheckCodePrefix::BLE,
+    CheckCodePrefix::C,
+    CheckCodePrefix::D,
+    CheckCodePrefix::E,
+    CheckCodePrefix::F,
+    CheckCodePrefix::FBT,
+    CheckCodePrefix::I,
+    CheckCodePrefix::M,
+    CheckCodePrefix::N,
+    CheckCodePrefix::Q,
+    CheckCodePrefix::RUF,
+    CheckCodePrefix::S,
+    CheckCodePrefix::T,
+    CheckCodePrefix::U,
+    CheckCodePrefix::W,
+    CheckCodePrefix::YTT,
+];

src/flake8_bugbear/plugins/function_uses_loop_variable.rs

@@ -10,7 +10,10 @@ use crate::checks::{Check, CheckKind};
 
 #[derive(Default)]
 struct LoadedNamesVisitor<'a> {
-    names: Vec<(&'a str, &'a Expr)>,
+    // Tuple of: name, defining expression, and defining range.
+    names: Vec<(&'a str, &'a Expr, Range)>,
+    // If we're in an f-string, the range of the defining expression.
+    in_f_string: Option<Range>,
 }
 
 /// `Visitor` to collect all used identifiers in a statement.
@@ -20,8 +23,19 @@ where
 {
     fn visit_expr(&mut self, expr: &'b Expr) {
         match &expr.node {
+            ExprKind::JoinedStr { .. } => {
+                let prev_in_f_string = self.in_f_string;
+                self.in_f_string = Some(Range::from_located(expr));
+                visitor::walk_expr(self, expr);
+                self.in_f_string = prev_in_f_string;
+            }
             ExprKind::Name { id, ctx } if matches!(ctx, ExprContext::Load) => {
-                self.names.push((id, expr));
+                self.names.push((
+                    id,
+                    expr,
+                    self.in_f_string
+                        .unwrap_or_else(|| Range::from_located(expr)),
+                ));
             }
             _ => visitor::walk_expr(self, expr),
         }
@@ -30,7 +44,7 @@ where
 
 #[derive(Default)]
 struct SuspiciousVariablesVisitor<'a> {
-    names: Vec<(&'a str, &'a Expr)>,
+    names: Vec<(&'a str, &'a Expr, Range)>,
 }
 
 /// `Visitor` to collect all suspicious variables (those referenced in
@@ -57,7 +71,7 @@ where
                     visitor
                         .names
                         .into_iter()
-                        .filter(|(id, _)| !arg_names.contains(id)),
+                        .filter(|(id, ..)| !arg_names.contains(id)),
                 );
             }
             _ => visitor::walk_stmt(self, stmt),
@@ -79,7 +93,7 @@ where
                     visitor
                         .names
                         .into_iter()
-                        .filter(|(id, _)| !arg_names.contains(id)),
+                        .filter(|(id, ..)| !arg_names.contains(id)),
                 );
             }
             _ => visitor::walk_expr(self, expr),
@@ -203,13 +217,13 @@ where
 
         // If a variable was used in a function or lambda body, and assigned in the
         // loop, flag it.
-        for (name, expr) in suspicious_variables {
+        for (name, expr, range) in suspicious_variables {
             if reassigned_in_loop.contains(name) {
                 if !checker.seen_b023.contains(&expr) {
                     checker.seen_b023.push(expr);
                     checker.add_check(Check::new(
                         CheckKind::FunctionUsesLoopVariable(name.to_string()),
-                        Range::from_located(expr),
+                        range,
                     ));
                 }
             }

src/flake8_debugger/checks.rs

@@ -0,0 +1,64 @@
+use rustc_hash::{FxHashMap, FxHashSet};
+use rustpython_ast::{Expr, Stmt};
+
+use crate::ast::helpers::{collect_call_paths, dealias_call_path, match_call_path};
+use crate::ast::types::Range;
+use crate::checks::{Check, CheckKind};
+use crate::flake8_debugger::types::DebuggerUsingType;
+
+const DEBUGGERS: &[(&str, &str)] = &[
+    ("pdb", "set_trace"),
+    ("pudb", "set_trace"),
+    ("ipdb", "set_trace"),
+    ("ipdb", "sset_trace"),
+    ("IPython.terminal.embed", "InteractiveShellEmbed"),
+    ("IPython.frontend.terminal.embed", "InteractiveShellEmbed"),
+    ("celery.contrib.rdb", "set_trace"),
+    ("builtins", "breakpoint"),
+    ("", "breakpoint"),
+];
+
+/// Checks for the presence of a debugger call.
+pub fn debugger_call(
+    expr: &Expr,
+    func: &Expr,
+    from_imports: &FxHashMap<&str, FxHashSet<&str>>,
+    import_aliases: &FxHashMap<&str, &str>,
+) -> Option<Check> {
+    let call_path = dealias_call_path(collect_call_paths(func), import_aliases);
+    if DEBUGGERS
+        .iter()
+        .any(|(module, member)| match_call_path(&call_path, module, member, from_imports))
+    {
+        Some(Check::new(
+            CheckKind::Debugger(DebuggerUsingType::Call(call_path.join("."))),
+            Range::from_located(expr),
+        ))
+    } else {
+        None
+    }
+}
+
+/// Checks for the presence of a debugger import.
+pub fn debugger_import(stmt: &Stmt, module: Option<&str>, name: &str) -> Option<Check> {
+    if let Some(module) = module {
+        if let Some((module_name, member)) = DEBUGGERS
+            .iter()
+            .find(|(module_name, member)| module_name == &module && member == &name)
+        {
+            return Some(Check::new(
+                CheckKind::Debugger(DebuggerUsingType::Import(format!("{module_name}.{member}"))),
+                Range::from_located(stmt),
+            ));
+        }
+    } else if DEBUGGERS
+        .iter()
+        .any(|(module_name, ..)| module_name == &name)
+    {
+        return Some(Check::new(
+            CheckKind::Debugger(DebuggerUsingType::Import(name.to_string())),
+            Range::from_located(stmt),
+        ));
+    }
+    None
+}

src/flake8_debugger/mod.rs

@@ -0,0 +1,2 @@
+pub mod checks;
+pub mod types;

src/flake8_debugger/types.rs

@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum DebuggerUsingType {
+    Call(String),
+    Import(String),
+}

src/lib.rs

@@ -47,6 +47,7 @@ pub mod flake8_boolean_trap;
 pub mod flake8_bugbear;
 mod flake8_builtins;
 mod flake8_comprehensions;
+mod flake8_debugger;
 mod flake8_print;
 pub mod flake8_quotes;
 pub mod flake8_tidy_imports;
@@ -115,6 +116,7 @@ pub fn check(path: &Path, contents: &str, autofix: bool) -> Result<Vec<Check>> {
         &directives,
         &settings,
         autofix,
+        false,
     )?;
 
     Ok(checks)

src/linter.rs

@@ -7,6 +7,7 @@ use std::path::Path;
 use anyhow::Result;
 #[cfg(not(target_family = "wasm"))]
 use log::debug;
+use nohash_hasher::IntMap;
 use rustpython_parser::lexer::LexResult;
 
 use crate::ast::types::Range;
@@ -46,6 +47,7 @@ impl AddAssign for Diagnostics {
 
 /// Generate a list of `Check` violations from the source code contents at the
 /// given `Path`.
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn check_path(
     path: &Path,
     contents: &str,
@@ -54,6 +56,7 @@ pub(crate) fn check_path(
     directives: &Directives,
     settings: &Settings,
     autofix: bool,
+    ignore_noqa: bool,
 ) -> Result<Vec<Check>> {
     // Aggregate all checks.
     let mut checks: Vec<Check> = vec![];
@@ -113,6 +116,7 @@ pub(crate) fn check_path(
         &directives.noqa_line_for,
         settings,
         autofix,
+        ignore_noqa,
     );
 
     // Create path ignores.
@@ -179,6 +183,7 @@ pub fn lint_path(
             &directives,
             settings,
             autofix.into(),
+            false,
         )?;
 
         // Apply autofix.
@@ -242,15 +247,19 @@ pub fn add_noqa_to_path(path: &Path, settings: &Settings) -> Result<usize> {
         directives::Flags::from_settings(settings),
     );
 
-    // Generate checks.
+    // Generate checks, ignoring any existing `noqa` directives.
     let checks = check_path(
         path,
         &contents,
         tokens,
         &locator,
-        &directives,
+        &Directives {
+            noqa_line_for: IntMap::default(),
+            isort_exclusions: directives.isort_exclusions,
+        },
         settings,
         false,
+        true,
     )?;
 
     add_noqa(&checks, &contents, &directives.noqa_line_for, path)
@@ -313,6 +322,7 @@ pub fn lint_stdin(
             &directives,
             settings,
             autofix.into(),
+            false,
         )?;
 
         // Apply autofix.
@@ -373,6 +383,7 @@ pub fn test_path(path: &Path, settings: &Settings, autofix: bool) -> Result<Vec<
         &directives,
         settings,
         autofix,
+        false,
     )
 }
 
@@ -558,6 +569,7 @@ mod tests {
     #[test_case(CheckCode::S105, Path::new("S105.py"); "S105")]
     #[test_case(CheckCode::S106, Path::new("S106.py"); "S106")]
     #[test_case(CheckCode::S107, Path::new("S107.py"); "S107")]
+    #[test_case(CheckCode::T100, Path::new("T100.py"); "T100")]
     #[test_case(CheckCode::T201, Path::new("T201.py"); "T201")]
     #[test_case(CheckCode::T203, Path::new("T203.py"); "T203")]
     #[test_case(CheckCode::U001, Path::new("U001.py"); "U001")]
@@ -571,6 +583,7 @@ mod tests {
     #[test_case(CheckCode::U009, Path::new("U009_1.py"); "U009_1")]
     #[test_case(CheckCode::U009, Path::new("U009_2.py"); "U009_2")]
     #[test_case(CheckCode::U009, Path::new("U009_3.py"); "U009_3")]
+    #[test_case(CheckCode::U009, Path::new("U009_4.py"); "U009_4")]
     #[test_case(CheckCode::U010, Path::new("U010.py"); "U010")]
     #[test_case(CheckCode::U011, Path::new("U011_0.py"); "U011_0")]
     #[test_case(CheckCode::U011, Path::new("U011_1.py"); "U011_1")]

src/noqa.rs

@@ -99,18 +99,42 @@ fn add_noqa_inner(
             Some(codes) => {
                 match extract_noqa_directive(line) {
                     Directive::None => {
-                        output.push_str(line);
+                        // Add existing content.
+                        output.push_str(line.trim_end());
+
+                        // Add `noqa` directive.
                         output.push_str("  # noqa: ");
+
+                        // Add codes.
+                        let codes: Vec<&str> = codes.iter().map(AsRef::as_ref).collect();
+                        let suffix = codes.join(", ");
+                        output.push_str(&suffix);
+                        output.push('\n');
+                        count += 1;
                     }
                     Directive::All(_, start, _) | Directive::Codes(_, start, ..) => {
-                        output.push_str(&line[..start]);
-                        output.push_str("# noqa: ");
+                        let mut new_line = String::new();
+
+                        // Add existing content.
+                        new_line.push_str(line[..start].trim_end());
+
+                        // Add `noqa` directive.
+                        new_line.push_str("  # noqa: ");
+
+                        // Add codes.
+                        let codes: Vec<&str> = codes.iter().map(AsRef::as_ref).collect();
+                        let suffix = codes.join(", ");
+                        new_line.push_str(&suffix);
+
+                        output.push_str(&new_line);
+                        output.push('\n');
+
+                        // Only count if the new line is an actual edit.
+                        if &new_line != line {
+                            count += 1;
+                        }
                     }
                 };
-                let codes: Vec<&str> = codes.iter().map(AsRef::as_ref).collect();
-                output.push_str(&codes.join(", "));
-                output.push('\n');
-                count += 1;
             }
         }
     }

src/python/typing.rs

@@ -209,15 +209,21 @@ pub enum SubscriptKind {
     PEP593AnnotatedSubscript,
 }
 
-pub fn match_annotated_subscript(
+pub fn match_annotated_subscript<F>(
     expr: &Expr,
     from_imports: &FxHashMap<&str, FxHashSet<&str>>,
     import_aliases: &FxHashMap<&str, &str>,
-) -> Option<SubscriptKind> {
+    is_builtin: F,
+) -> Option<SubscriptKind>
+where
+    F: Fn(&str) -> bool,
+{
     let call_path = dealias_call_path(collect_call_paths(expr), import_aliases);
     if !call_path.is_empty() {
         for (module, member) in SUBSCRIPTS {
-            if match_call_path(&call_path, module, member, from_imports) {
+            if match_call_path(&call_path, module, member, from_imports)
+                && (!module.is_empty() || is_builtin(member))
+            {
                 return Some(SubscriptKind::AnnotatedSubscript);
             }
         }

src/pyupgrade/plugins/redundant_open_modes.rs

@@ -64,7 +64,6 @@ fn match_open(expr: &Expr) -> (Option<&Expr>, Vec<Keyword>) {
         keywords,
     } = &expr.node
     {
-        // TODO(andberger): Verify that "open" is still bound to the built-in function.
         if match_name_or_attr(func, OPEN_FUNC_NAME) {
             // Return the "open mode" parameter and keywords.
             return (args.get(1), keywords.clone());
@@ -149,6 +148,10 @@ fn create_remove_param_fix(
 
 /// U015
 pub fn redundant_open_modes(checker: &mut Checker, expr: &Expr) {
+    // If `open` has been rebound, skip this check entirely.
+    if !checker.is_builtin(OPEN_FUNC_NAME) {
+        return;
+    }
     let (mode_param, keywords): (Option<&Expr>, Vec<Keyword>) = match_open(expr);
     if mode_param.is_none() && !keywords.is_empty() {
         if let Some(value) = keywords.iter().find_map(|keyword| {

src/rules/plugins/convert_exit_to_sys_exit.rs

@@ -21,12 +21,7 @@ fn is_module_star_imported(checker: &Checker, module: &str) -> bool {
 
 /// Return `true` if `exit` is (still) bound as a built-in in the current scope.
 fn has_builtin_exit_in_scope(checker: &Checker) -> bool {
-    !is_module_star_imported(checker, "sys")
-        && checker
-            .current_scopes()
-            .find_map(|scope| scope.values.get("exit"))
-            .map(|binding| matches!(binding.kind, BindingKind::Builtin))
-            .unwrap_or_default()
+    !is_module_star_imported(checker, "sys") && checker.is_builtin("exit")
 }
 
 /// Return the appropriate `sys.exit` reference based on the current set of

src/settings/configuration.rs

@@ -9,7 +9,7 @@ use once_cell::sync::Lazy;
 use path_absolutize::path_dedot;
 use regex::Regex;
 
-use crate::checks_gen::CheckCodePrefix;
+use crate::checks_gen::{CheckCodePrefix, CATEGORIES};
 use crate::settings::pyproject::load_options;
 use crate::settings::types::{FilePattern, PerFileIgnore, PythonVersion};
 use crate::{
@@ -117,28 +117,7 @@ impl Configuration {
                 .unwrap_or_else(|| vec![CheckCodePrefix::E, CheckCodePrefix::F]),
             extend_select: options.extend_select.unwrap_or_default(),
             fix: options.fix.unwrap_or_default(),
-            fixable: options.fixable.unwrap_or_else(|| {
-                // TODO(charlie): Autogenerate this list.
-                vec![
-                    CheckCodePrefix::A,
-                    CheckCodePrefix::B,
-                    CheckCodePrefix::BLE,
-                    CheckCodePrefix::C,
-                    CheckCodePrefix::D,
-                    CheckCodePrefix::E,
-                    CheckCodePrefix::F,
-                    CheckCodePrefix::I,
-                    CheckCodePrefix::M,
-                    CheckCodePrefix::N,
-                    CheckCodePrefix::Q,
-                    CheckCodePrefix::RUF,
-                    CheckCodePrefix::S,
-                    CheckCodePrefix::T,
-                    CheckCodePrefix::U,
-                    CheckCodePrefix::W,
-                    CheckCodePrefix::YTT,
-                ]
-            }),
+            fixable: options.fixable.unwrap_or_else(|| CATEGORIES.to_vec()),
             unfixable: options.unfixable.unwrap_or_default(),
             ignore: options.ignore.unwrap_or_default(),
             line_length: options.line_length.unwrap_or(88),

src/snapshots/ruff__linter__tests__B023_B023.py.snap

@@ -146,4 +146,13 @@ expression: checks
     row: 68
     column: 10
   fix: ~
+- kind:
+    FunctionUsesLoopVariable: i
+  location:
+    row: 82
+    column: 12
+  end_location:
+    row: 82
+    column: 18
+  fix: ~
 

src/snapshots/ruff__linter__tests__T100_T100.py.snap

@@ -0,0 +1,95 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    Debugger:
+      Call: breakpoint
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 1
+    column: 12
+  fix: ~
+- kind:
+    Debugger:
+      Import: pdb
+  location:
+    row: 4
+    column: 0
+  end_location:
+    row: 4
+    column: 10
+  fix: ~
+- kind:
+    Debugger:
+      Import: builtins.breakpoint
+  location:
+    row: 5
+    column: 0
+  end_location:
+    row: 5
+    column: 31
+  fix: ~
+- kind:
+    Debugger:
+      Import: pdb.set_trace
+  location:
+    row: 6
+    column: 0
+  end_location:
+    row: 6
+    column: 31
+  fix: ~
+- kind:
+    Debugger:
+      Import: celery.contrib.rdb.set_trace
+  location:
+    row: 7
+    column: 0
+  end_location:
+    row: 7
+    column: 40
+  fix: ~
+- kind:
+    Debugger:
+      Import: celery.contrib.rdb
+  location:
+    row: 9
+    column: 0
+  end_location:
+    row: 9
+    column: 25
+  fix: ~
+- kind:
+    Debugger:
+      Call: breakpoint
+  location:
+    row: 12
+    column: 0
+  end_location:
+    row: 12
+    column: 12
+  fix: ~
+- kind:
+    Debugger:
+      Call: set_trace
+  location:
+    row: 13
+    column: 0
+  end_location:
+    row: 13
+    column: 4
+  fix: ~
+- kind:
+    Debugger:
+      Call: set_trace
+  location:
+    row: 14
+    column: 0
+  end_location:
+    row: 14
+    column: 11
+  fix: ~
+

src/snapshots/ruff__linter__tests__U009_U009_0.py.snap

@@ -7,8 +7,8 @@ expression: checks
     row: 1
     column: 0
   end_location:
-    row: 1
-    column: 14
+    row: 2
+    column: 0
   fix:
     patch:
       content: ""
@@ -16,6 +16,6 @@ expression: checks
         row: 1
         column: 0
       end_location:
-        row: 1
-        column: 14
+        row: 2
+        column: 0
 

src/snapshots/ruff__linter__tests__U009_U009_1.py.snap

@@ -7,8 +7,8 @@ expression: checks
     row: 2
     column: 0
   end_location:
-    row: 2
-    column: 24
+    row: 3
+    column: 0
   fix:
     patch:
       content: ""
@@ -16,6 +16,6 @@ expression: checks
         row: 2
         column: 0
       end_location:
-        row: 2
-        column: 24
+        row: 3
+        column: 0
 

src/snapshots/ruff__linter__tests__U009_U009_4.py.snap

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