Bump version to 0.0.123

Fix off-by-one in noqa

.github/workflows/ci.yaml

@@ -6,6 +6,11 @@ on:
   pull_request:
     branches: [main]
 
+env:
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  RUSTUP_MAX_RETRIES: 10
+
 jobs:
   cargo_build:
     name: "cargo build"

.github/workflows/flake8-to-ruff.yaml

@@ -10,6 +10,9 @@ env:
   PACKAGE_NAME: flake8-to-ruff
   CRATE_NAME: flake8_to_ruff
   PYTHON_VERSION: "3.7" # to build abi3 wheels
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  RUSTUP_MAX_RETRIES: 10
 
 jobs:
   macos-x86_64:

.github/workflows/ruff.yaml

@@ -12,6 +12,9 @@ concurrency:
 env:
   PACKAGE_NAME: ruff
   PYTHON_VERSION: "3.7" # to build abi3 wheels
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  RUSTUP_MAX_RETRIES: 10
 
 jobs:
   macos-x86_64:

.pre-commit-config.yaml

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

Cargo.lock

@@ -930,7 +930,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.121-dev.0"
+version = "0.0.123-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.22",
@@ -2238,7 +2238,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.121"
+version = "0.0.123"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2287,7 +2287,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.121"
+version = "0.0.123"
 dependencies = [
  "anyhow",
  "clap 4.0.22",

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.121"
+version = "0.0.123"
 edition = "2021"
 
 [lib]

LICENSE

@@ -19,3 +19,378 @@ 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.
+
+The externally maintained libraries from which parts of the Software is derived
+are:
+
+- Pyflakes, licensed as follows:
+  """
+    Copyright 2005-2011 Divmod, Inc.
+    Copyright 2013-2014 Florent Xicluna
+
+    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.
+  """
+
+- autoflake, licensed as follows:
+  """
+    Copyright (C) 2012-2018 Steven Myint
+
+    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, licensed as follows:
+  """
+    == Flake8 License (MIT) ==
+
+    Copyright (C) 2011-2013 Tarek Ziade <tarek@ziade.org>
+    Copyright (C) 2012-2016 Ian Cordasco <graffatcolmingov@gmail.com>
+
+    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-2020, licensed as follows:
+  """
+    Copyright (c) 2019 Anthony Sottile
+
+    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-annotations, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2019 - Present S. Co1
+
+    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-bandit, licensed as follows:
+  """
+    Copyright (c) 2017 Tyler Wince
+
+    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-bugbear, licensed as follows:
+  """
+    The MIT License (MIT)
+
+    Copyright (c) 2016 Łukasz Langa
+
+    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-comprehensions, licensed as follows:
+  """
+    MIT License
+
+    Copyright (c) 2017 Adam Johnson
+
+    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-print, 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-quotes, licensed as follows:
+  """
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.
+  """
+
+- isort, licensed as follows:
+  """
+    The MIT License (MIT)
+
+    Copyright (c) 2013 Timothy Edmund Crosley
+
+    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.
+  """
+
+- pep8-naming, licensed as follows:
+  """
+    Copyright © 2013 Florent Xicluna <florent.xicluna@gmail.com>
+
+    Licensed under the terms of the Expat License
+
+    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.
+  """
+
+- pycodestyle, licensed as follows:
+  """
+    Copyright © 2006-2009 Johann C. Rocholl <johann@rocholl.net>
+    Copyright © 2009-2014 Florent Xicluna <florent.xicluna@gmail.com>
+    Copyright © 2014-2020 Ian Lee <IanLee1521@gmail.com>
+
+    Licensed under the terms of the Expat License
+
+    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.
+  """
+
+- pydocstyle, licensed as follows:
+  """
+    Copyright (c) 2012 GreenSteam, <http://greensteam.dk/>
+
+    Copyright (c) 2014-2020 Amir Rachum, <http://amir.rachum.com/>
+
+    Copyright (c) 2020 Sambhav Kothari, <https://github.com/samj1912>
+
+    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.
+  """
+
+- pyupgrade, licensed as follows:
+  """
+    Copyright (c) 2017 Anthony Sottile
+
+    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_to_ruff/Cargo.lock

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

flake8_to_ruff/Cargo.toml

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

resources/test/fixtures/E501.py

@@ -5,7 +5,7 @@
 Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 """
 
-_ = """Lorem ipsum dolor sit amet.
+_ = """Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 
     https://github.com/PyCQA/pycodestyle/pull/258/files#diff-841c622497a8033d10152bfdfb15b20b92437ecdea21a260944ea86b77b51533
 

resources/test/fixtures/E731.py

@@ -8,14 +8,14 @@ while False:
 
 
 f = object()
-#: E731
 f.method = lambda: "Method"
 
 f = {}
-#: E731
 f["a"] = lambda x: x ** 2
 
 f = []
 f.append(lambda x: x ** 2)
 
+f = g = lambda x: x ** 2
+
 lambda: "no-op"

resources/test/fixtures/isort/add_newline_before_comments.py

@@ -0,0 +1,7 @@
+import os
+# This is a comment in the same section, so we need to add one newline.
+import sys
+import numpy as np
+# This is a comment, but it starts a new section, so we don't need to add a newline
+# before it.
+import leading_prefix

resources/test/fixtures/isort/comments.py

@@ -0,0 +1,25 @@
+# Comment 1
+# Comment 2
+import D
+
+# Comment 3a
+import C
+
+# Comment 3b
+import C
+
+import B  # Comment 4
+
+# Comment 5
+
+# Comment 6
+from A import (
+    a,  # Comment 7
+    b,
+    c,  # Comment 8
+)
+from A import (
+    a,  # Comment 9
+    b,  # Comment 10
+    c,  # Comment 11
+)

resources/test/fixtures/isort/fit_line_length_comment.py

@@ -0,0 +1,4 @@
+import a
+# Don't take this comment into account when determining whether the next import can fit on one line.
+from b import c
+from d import e  # Do take this comment into account when determining whether the next import can fit on one line.

resources/test/fixtures/isort/preserve_comment_order.py

@@ -0,0 +1,11 @@
+import io
+# Old MacDonald had a farm,
+# EIEIO
+# And on his farm he had a cow,
+# EIEIO
+# With a moo-moo here and a moo-moo there
+# Here a moo, there a moo, everywhere moo-moo
+# Old MacDonald had a farm,
+# EIEIO
+from errno import EIO
+import abc

resources/test/fixtures/isort/type_comments.py

@@ -0,0 +1,2 @@
+import A  # type: ignore
+from B import C  # type: ignore

ruff_dev/Cargo.toml

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

src/ast/helpers.rs

@@ -225,6 +225,20 @@ pub fn is_super_call_with_arguments(func: &Expr, args: &[Expr]) -> bool {
     }
 }
 
+/// Format the module name for a relative import.
+pub fn format_import_from(level: Option<&usize>, module: Option<&String>) -> String {
+    let mut module_name = String::with_capacity(16);
+    if let Some(level) = level {
+        for _ in 0..*level {
+            module_name.push('.');
+        }
+    }
+    if let Some(module) = module {
+        module_name.push_str(module);
+    }
+    module_name
+}
+
 /// Convert a location within a file (relative to `base`) to an absolute
 /// position.
 pub fn to_absolute(relative: &Location, base: &Location) -> Location {

src/ast/types.rs

@@ -54,7 +54,7 @@ pub struct Scope<'a> {
     pub id: usize,
     pub kind: ScopeKind<'a>,
     pub import_starred: bool,
-    pub values: FnvHashMap<String, Binding>,
+    pub values: FnvHashMap<&'a str, Binding>,
 }
 
 impl<'a> Scope<'a> {
@@ -86,7 +86,7 @@ pub enum BindingKind {
     Definition,
     Export(Vec<String>),
     FutureImportation,
-    StarImportation,
+    StarImportation(Option<usize>, Option<String>),
     Importation(String, String, BindingContext),
     FromImportation(String, String, BindingContext),
     SubmoduleImportation(String, String, BindingContext),

src/check_ast.rs

@@ -222,7 +222,7 @@ where
                     for name in names {
                         for scope in self.scopes.iter_mut().skip(GLOBAL_SCOPE_INDEX + 1) {
                             scope.values.insert(
-                                name.to_string(),
+                                name,
                                 Binding {
                                     kind: BindingKind::Assignment,
                                     used: Some((global_scope_id, Range::from_located(stmt))),
@@ -397,7 +397,7 @@ where
                     self.visit_expr(expr);
                 }
                 self.add_binding(
-                    name.to_string(),
+                    name,
                     Binding {
                         kind: BindingKind::Definition,
                         used: None,
@@ -502,7 +502,7 @@ where
                         let name = alias.node.name.split('.').next().unwrap();
                         let full_name = &alias.node.name;
                         self.add_binding(
-                            name.to_string(),
+                            name,
                             Binding {
                                 kind: BindingKind::SubmoduleImportation(
                                     name.to_string(),
@@ -524,7 +524,7 @@ where
                         let name = alias.node.asname.as_ref().unwrap_or(&alias.node.name);
                         let full_name = &alias.node.name;
                         self.add_binding(
-                            name.to_string(),
+                            name,
                             Binding {
                                 kind: BindingKind::Importation(
                                     name.to_string(),
@@ -657,7 +657,7 @@ where
                     if let Some("__future__") = module.as_deref() {
                         let name = alias.node.asname.as_ref().unwrap_or(&alias.node.name);
                         self.add_binding(
-                            name.to_string(),
+                            name,
                             Binding {
                                 kind: BindingKind::FutureImportation,
                                 // Always mark `__future__` imports as used.
@@ -694,16 +694,10 @@ where
                             ));
                         }
                     } else if alias.node.name == "*" {
-                        let module_name = format!(
-                            "{}{}",
-                            ".".repeat(level.unwrap_or_default()),
-                            module.clone().unwrap_or_else(|| "module".to_string()),
-                        );
-
                         self.add_binding(
-                            module_name.to_string(),
+                            "*",
                             Binding {
-                                kind: BindingKind::StarImportation,
+                                kind: BindingKind::StarImportation(*level, module.clone()),
                                 used: None,
                                 range: Range::from_located(stmt),
                             },
@@ -714,7 +708,10 @@ where
                                 [*(self.scope_stack.last().expect("No current scope found."))];
                             if !matches!(scope.kind, ScopeKind::Module) {
                                 self.add_check(Check::new(
-                                    CheckKind::ImportStarNotPermitted(module_name.to_string()),
+                                    CheckKind::ImportStarNotPermitted(helpers::format_import_from(
+                                        level.as_ref(),
+                                        module.as_ref(),
+                                    )),
                                     Range::from_located(stmt),
                                 ));
                             }
@@ -722,7 +719,10 @@ where
 
                         if self.settings.enabled.contains(&CheckCode::F403) {
                             self.add_check(Check::new(
-                                CheckKind::ImportStarUsed(module_name.to_string()),
+                                CheckKind::ImportStarUsed(helpers::format_import_from(
+                                    level.as_ref(),
+                                    module.as_ref(),
+                                )),
                                 Range::from_located(stmt),
                             ));
                         }
@@ -746,7 +746,7 @@ where
                             Some(parent) => format!("{}.{}", parent, alias.node.name),
                         };
                         self.add_binding(
-                            name.to_string(),
+                            name,
                             Binding {
                                 kind: BindingKind::FromImportation(
                                     name.to_string(),
@@ -862,7 +862,12 @@ where
                     pyflakes::plugins::assert_tuple(self, stmt, test);
                 }
                 if self.settings.enabled.contains(&CheckCode::B011) {
-                    flake8_bugbear::plugins::assert_false(self, stmt, test, msg);
+                    flake8_bugbear::plugins::assert_false(
+                        self,
+                        stmt,
+                        test,
+                        msg.as_ref().map(|expr| expr.deref()),
+                    );
                 }
                 if self.settings.enabled.contains(&CheckCode::S101) {
                     self.add_check(flake8_bandit::plugins::assert_used(stmt));
@@ -900,10 +905,12 @@ where
             }
             StmtKind::Assign { targets, value, .. } => {
                 if self.settings.enabled.contains(&CheckCode::E731) {
-                    if let Some(check) =
-                        pycodestyle::checks::do_not_assign_lambda(value, Range::from_located(stmt))
-                    {
-                        self.add_check(check);
+                    if let [target] = &targets[..] {
+                        if let Some(check) =
+                            pycodestyle::checks::do_not_assign_lambda(target, value, stmt)
+                        {
+                            self.add_check(check);
+                        }
                     }
                 }
                 if self.settings.enabled.contains(&CheckCode::U001) {
@@ -920,13 +927,12 @@ where
                     }
                 }
             }
-            StmtKind::AnnAssign { value, .. } => {
+            StmtKind::AnnAssign { target, value, .. } => {
                 if self.settings.enabled.contains(&CheckCode::E731) {
                     if let Some(value) = value {
-                        if let Some(check) = pycodestyle::checks::do_not_assign_lambda(
-                            value,
-                            Range::from_located(stmt),
-                        ) {
+                        if let Some(check) =
+                            pycodestyle::checks::do_not_assign_lambda(target, value, stmt)
+                        {
                             self.add_check(check);
                         }
                     }
@@ -1017,7 +1023,7 @@ where
         if let StmtKind::ClassDef { name, .. } = &stmt.node {
             self.pop_scope();
             self.add_binding(
-                name.to_string(),
+                name,
                 Binding {
                     kind: BindingKind::ClassDefinition,
                     used: None,
@@ -1130,7 +1136,7 @@ where
 
                         self.check_builtin_shadowing(id, Range::from_located(expr), true);
 
-                        self.handle_node_store(expr, self.current_parent());
+                        self.handle_node_store(id, expr, self.current_parent());
                     }
                     ExprContext::Del => self.handle_node_delete(expr),
                 }
@@ -1860,8 +1866,9 @@ where
                             false,
                         );
 
-                        if self.current_scope().values.contains_key(name) {
+                        if self.current_scope().values.contains_key(&name.as_str()) {
                             self.handle_node_store(
+                                name,
                                 &Expr::new(
                                     excepthandler.location,
                                     excepthandler.end_location.unwrap(),
@@ -1874,8 +1881,9 @@ where
                             );
                         }
 
-                        let definition = self.current_scope().values.get(name).cloned();
+                        let definition = self.current_scope().values.get(&name.as_str()).cloned();
                         self.handle_node_store(
+                            name,
                             &Expr::new(
                                 excepthandler.location,
                                 excepthandler.end_location.unwrap(),
@@ -1892,7 +1900,7 @@ where
                         if let Some(binding) = {
                             let scope = &mut self.scopes
                                 [*(self.scope_stack.last().expect("No current scope found."))];
-                            &scope.values.remove(name)
+                            &scope.values.remove(&name.as_str())
                         } {
                             if binding.used.is_none() {
                                 if self.settings.enabled.contains(&CheckCode::F841) {
@@ -1907,7 +1915,7 @@ where
                         if let Some(binding) = definition {
                             let scope = &mut self.scopes
                                 [*(self.scope_stack.last().expect("No current scope found."))];
-                            scope.values.insert(name.to_string(), binding);
+                            scope.values.insert(name, binding);
                         }
                     }
                     None => walk_excepthandler(self, excepthandler),
@@ -1951,7 +1959,7 @@ where
         // Bind, but intentionally avoid walking the annotation, as we handle it
         // upstream.
         self.add_binding(
-            arg.node.arg.to_string(),
+            &arg.node.arg,
             Binding {
                 kind: BindingKind::Argument,
                 used: None,
@@ -2016,7 +2024,7 @@ fn try_mark_used(scope: &mut Scope, scope_id: usize, id: &str, expr: &Expr) -> b
     };
 
     // Mark the sub-importation as used.
-    if let Some(binding) = scope.values.get_mut(&alias) {
+    if let Some(binding) = scope.values.get_mut(alias.as_str()) {
         binding.used = Some((scope_id, Range::from_located(expr)));
     }
     true
@@ -2052,7 +2060,7 @@ impl<'a> Checker<'a> {
 
         for builtin in BUILTINS {
             scope.values.insert(
-                (*builtin).to_string(),
+                builtin,
                 Binding {
                     kind: BindingKind::Builtin,
                     range: Default::default(),
@@ -2062,7 +2070,7 @@ impl<'a> Checker<'a> {
         }
         for builtin in MAGIC_GLOBALS {
             scope.values.insert(
-                (*builtin).to_string(),
+                builtin,
                 Binding {
                     kind: BindingKind::Builtin,
                     range: Default::default(),
@@ -2090,23 +2098,26 @@ impl<'a> Checker<'a> {
         }
     }
 
-    fn add_binding(&mut self, name: String, binding: Binding) {
+    fn add_binding<'b>(&mut self, name: &'b str, binding: Binding)
+    where
+        'b: 'a,
+    {
         if self.settings.enabled.contains(&CheckCode::F402) {
             let scope = &self.scopes[*(self.scope_stack.last().expect("No current scope found."))];
             if let Some(existing) = scope.values.get(&name) {
                 if matches!(binding.kind, BindingKind::LoopVar)
                     && matches!(
                         existing.kind,
-                        BindingKind::Importation(_, _, _)
-                            | BindingKind::FromImportation(_, _, _)
-                            | BindingKind::SubmoduleImportation(_, _, _)
-                            | BindingKind::StarImportation
+                        BindingKind::Importation(..)
+                            | BindingKind::FromImportation(..)
+                            | BindingKind::SubmoduleImportation(..)
+                            | BindingKind::StarImportation(..)
                             | BindingKind::FutureImportation
                     )
                 {
                     self.add_check(Check::new(
                         CheckKind::ImportShadowedByLoopVar(
-                            name.clone(),
+                            name.to_string(),
                             existing.range.location.row(),
                         ),
                         binding.range,
@@ -2164,16 +2175,19 @@ impl<'a> Checker<'a> {
                     let mut from_list = vec![];
                     for scope_index in self.scope_stack.iter().rev() {
                         let scope = &self.scopes[*scope_index];
-                        for (name, binding) in scope.values.iter() {
-                            if matches!(binding.kind, BindingKind::StarImportation) {
-                                from_list.push(name.to_string());
+                        for binding in scope.values.values() {
+                            if let BindingKind::StarImportation(level, module) = &binding.kind {
+                                from_list.push(helpers::format_import_from(
+                                    level.as_ref(),
+                                    module.as_ref(),
+                                ));
                             }
                         }
                     }
                     from_list.sort();
 
                     self.add_check(Check::new(
-                        CheckKind::ImportStarUsage(id.clone(), from_list),
+                        CheckKind::ImportStarUsage(id.to_string(), from_list),
                         Range::from_located(expr),
                     ));
                 }
@@ -2204,113 +2218,112 @@ impl<'a> Checker<'a> {
         }
     }
 
-    fn handle_node_store(&mut self, expr: &Expr, parent: &Stmt) {
-        if let ExprKind::Name { id, .. } = &expr.node {
-            if self.settings.enabled.contains(&CheckCode::F823) {
-                let scopes: Vec<&Scope> = self
-                    .scope_stack
-                    .iter()
-                    .map(|index| &self.scopes[*index])
-                    .collect();
-                if let Some(check) = pyflakes::checks::undefined_local(&scopes, id) {
-                    self.add_check(check);
-                }
+    fn handle_node_store<'b>(&mut self, id: &'b str, expr: &Expr, parent: &Stmt)
+    where
+        'b: 'a,
+    {
+        if self.settings.enabled.contains(&CheckCode::F823) {
+            let scopes: Vec<&Scope> = self
+                .scope_stack
+                .iter()
+                .map(|index| &self.scopes[*index])
+                .collect();
+            if let Some(check) = pyflakes::checks::undefined_local(&scopes, id) {
+                self.add_check(check);
             }
+        }
 
-            if self.settings.enabled.contains(&CheckCode::N806) {
-                if matches!(self.current_scope().kind, ScopeKind::Function(..)) {
-                    pep8_naming::plugins::non_lowercase_variable_in_function(self, expr, parent, id)
-                }
+        if self.settings.enabled.contains(&CheckCode::N806) {
+            if matches!(self.current_scope().kind, ScopeKind::Function(..)) {
+                pep8_naming::plugins::non_lowercase_variable_in_function(self, expr, parent, id)
             }
+        }
 
-            if self.settings.enabled.contains(&CheckCode::N815) {
-                if matches!(self.current_scope().kind, ScopeKind::Class(..)) {
-                    pep8_naming::plugins::mixed_case_variable_in_class_scope(self, expr, parent, id)
-                }
+        if self.settings.enabled.contains(&CheckCode::N815) {
+            if matches!(self.current_scope().kind, ScopeKind::Class(..)) {
+                pep8_naming::plugins::mixed_case_variable_in_class_scope(self, expr, parent, id)
             }
+        }
 
-            if self.settings.enabled.contains(&CheckCode::N816) {
-                if matches!(self.current_scope().kind, ScopeKind::Module) {
-                    pep8_naming::plugins::mixed_case_variable_in_global_scope(
-                        self, expr, parent, id,
-                    )
-                }
-            }
-
-            if matches!(parent.node, StmtKind::AnnAssign { value: None, .. }) {
-                self.add_binding(
-                    id.to_string(),
-                    Binding {
-                        kind: BindingKind::Annotation,
-                        used: None,
-                        range: Range::from_located(expr),
-                    },
-                );
-                return;
-            }
-
-            // TODO(charlie): Include comprehensions here.
-            if matches!(
-                parent.node,
-                StmtKind::For { .. } | StmtKind::AsyncFor { .. }
-            ) {
-                self.add_binding(
-                    id.to_string(),
-                    Binding {
-                        kind: BindingKind::LoopVar,
-                        used: None,
-                        range: Range::from_located(expr),
-                    },
-                );
-                return;
-            }
-
-            if operations::is_unpacking_assignment(parent) {
-                self.add_binding(
-                    id.to_string(),
-                    Binding {
-                        kind: BindingKind::Binding,
-                        used: None,
-                        range: Range::from_located(expr),
-                    },
-                );
-                return;
-            }
-
-            let current =
-                &self.scopes[*(self.scope_stack.last().expect("No current scope found."))];
-            if id == "__all__"
-                && matches!(current.kind, ScopeKind::Module)
-                && matches!(
-                    parent.node,
-                    StmtKind::Assign { .. }
-                        | StmtKind::AugAssign { .. }
-                        | StmtKind::AnnAssign { .. }
-                )
-            {
-                self.add_binding(
-                    id.to_string(),
-                    Binding {
-                        kind: BindingKind::Export(extract_all_names(parent, current)),
-                        used: None,
-                        range: Range::from_located(expr),
-                    },
-                );
-                return;
+        if self.settings.enabled.contains(&CheckCode::N816) {
+            if matches!(self.current_scope().kind, ScopeKind::Module) {
+                pep8_naming::plugins::mixed_case_variable_in_global_scope(self, expr, parent, id)
             }
+        }
 
+        if matches!(parent.node, StmtKind::AnnAssign { value: None, .. }) {
             self.add_binding(
-                id.to_string(),
+                id,
                 Binding {
-                    kind: BindingKind::Assignment,
+                    kind: BindingKind::Annotation,
                     used: None,
                     range: Range::from_located(expr),
                 },
             );
+            return;
         }
+
+        // TODO(charlie): Include comprehensions here.
+        if matches!(
+            parent.node,
+            StmtKind::For { .. } | StmtKind::AsyncFor { .. }
+        ) {
+            self.add_binding(
+                id,
+                Binding {
+                    kind: BindingKind::LoopVar,
+                    used: None,
+                    range: Range::from_located(expr),
+                },
+            );
+            return;
+        }
+
+        if operations::is_unpacking_assignment(parent) {
+            self.add_binding(
+                id,
+                Binding {
+                    kind: BindingKind::Binding,
+                    used: None,
+                    range: Range::from_located(expr),
+                },
+            );
+            return;
+        }
+
+        let current = &self.scopes[*(self.scope_stack.last().expect("No current scope found."))];
+        if id == "__all__"
+            && matches!(current.kind, ScopeKind::Module)
+            && matches!(
+                parent.node,
+                StmtKind::Assign { .. } | StmtKind::AugAssign { .. } | StmtKind::AnnAssign { .. }
+            )
+        {
+            self.add_binding(
+                id,
+                Binding {
+                    kind: BindingKind::Export(extract_all_names(parent, current)),
+                    used: None,
+                    range: Range::from_located(expr),
+                },
+            );
+            return;
+        }
+
+        self.add_binding(
+            id,
+            Binding {
+                kind: BindingKind::Assignment,
+                used: None,
+                range: Range::from_located(expr),
+            },
+        );
     }
 
-    fn handle_node_delete(&mut self, expr: &Expr) {
+    fn handle_node_delete<'b>(&mut self, expr: &'b Expr)
+    where
+        'b: 'a,
+    {
         if let ExprKind::Name { id, .. } = &expr.node {
             if operations::on_conditional_branch(
                 &mut self
@@ -2324,10 +2337,11 @@ impl<'a> Checker<'a> {
 
             let scope =
                 &mut self.scopes[*(self.scope_stack.last().expect("No current scope found."))];
-            if scope.values.remove(id).is_none() && self.settings.enabled.contains(&CheckCode::F821)
+            if scope.values.remove(&id.as_str()).is_none()
+                && self.settings.enabled.contains(&CheckCode::F821)
             {
                 self.add_check(Check::new(
-                    CheckKind::UndefinedName(id.clone()),
+                    CheckKind::UndefinedName(id.to_string()),
                     Range::from_located(expr),
                 ))
             }
@@ -2459,16 +2473,19 @@ impl<'a> Checker<'a> {
 
         let mut checks: Vec<Check> = vec![];
         for scope in self.dead_scopes.iter().map(|index| &self.scopes[*index]) {
-            let all_binding = scope.values.get("__all__");
-            let all_names = all_binding.and_then(|binding| match &binding.kind {
-                BindingKind::Export(names) => Some(names),
-                _ => None,
-            });
+            let all_binding: Option<&Binding> = scope.values.get("__all__");
+            let all_names: Option<Vec<&str>> =
+                all_binding.and_then(|binding| match &binding.kind {
+                    BindingKind::Export(names) => {
+                        Some(names.iter().map(|name| name.as_str()).collect())
+                    }
+                    _ => None,
+                });
 
             if self.settings.enabled.contains(&CheckCode::F822) {
                 if !scope.import_starred && !self.path.ends_with("__init__.py") {
                     if let Some(all_binding) = all_binding {
-                        if let Some(names) = all_names {
+                        if let Some(names) = &all_names {
                             for name in names {
                                 if !scope.values.contains_key(name) {
                                     checks.push(Check::new(
@@ -2485,11 +2502,14 @@ impl<'a> Checker<'a> {
             if self.settings.enabled.contains(&CheckCode::F405) {
                 if scope.import_starred {
                     if let Some(all_binding) = all_binding {
-                        if let Some(names) = all_names {
+                        if let Some(names) = &all_names {
                             let mut from_list = vec![];
-                            for (name, binding) in scope.values.iter() {
-                                if matches!(binding.kind, BindingKind::StarImportation) {
-                                    from_list.push(name.to_string());
+                            for binding in scope.values.values() {
+                                if let BindingKind::StarImportation(level, module) = &binding.kind {
+                                    from_list.push(helpers::format_import_from(
+                                        level.as_ref(),
+                                        module.as_ref(),
+                                    ));
                                 }
                             }
                             from_list.sort();
@@ -2497,7 +2517,10 @@ impl<'a> Checker<'a> {
                             for name in names {
                                 if !scope.values.contains_key(name) {
                                     checks.push(Check::new(
-                                        CheckKind::ImportStarUsage(name.clone(), from_list.clone()),
+                                        CheckKind::ImportStarUsage(
+                                            name.to_string(),
+                                            from_list.clone(),
+                                        ),
                                         all_binding.range,
                                     ));
                                 }
@@ -2514,8 +2537,18 @@ impl<'a> Checker<'a> {
                     BTreeMap::new();
 
                 for (name, binding) in scope.values.iter() {
+                    if !matches!(
+                        binding.kind,
+                        BindingKind::Importation(..)
+                            | BindingKind::SubmoduleImportation(..)
+                            | BindingKind::FromImportation(..)
+                    ) {
+                        continue;
+                    }
+
                     let used = binding.used.is_some()
                         || all_names
+                            .as_ref()
                             .map(|names| names.contains(name))
                             .unwrap_or_default();
 
@@ -2542,7 +2575,7 @@ impl<'a> Checker<'a> {
                                     .or_default()
                                     .push(full_name);
                             }
-                            _ => {}
+                            _ => unreachable!("Already filtered on BindingKind."),
                         }
                     }
                 }

src/check_lines.rs

@@ -58,10 +58,7 @@ pub fn check_lines(
         // Grab the noqa (logical) line number for the current (physical) line.
         // If there are newlines at the end of the file, they won't be represented in
         // `noqa_line_for`, so fallback to the current line.
-        let noqa_lineno = noqa_line_for
-            .get(&lineno)
-            .map(|lineno| lineno - 1)
-            .unwrap_or(lineno);
+        let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
 
         // Enforce unnecessary coding comments (U009).
         if enforce_unnecessary_coding_comment {
@@ -155,10 +152,7 @@ pub fn check_lines(
         // want to raise W292 anyway).
         if let Some(line) = lines.last() {
             let lineno = lines.len() - 1;
-            let noqa_lineno = noqa_line_for
-                .get(&lineno)
-                .map(|lineno| lineno - 1)
-                .unwrap_or(lineno);
+            let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
 
             let noqa = noqa_directives
                 .entry(noqa_lineno)

src/cli.rs

@@ -152,7 +152,7 @@ pub fn warn_on(
     cli_ignore: &[CheckCodePrefix],
     cli_extend_ignore: &[CheckCodePrefix],
     pyproject_configuration: &Configuration,
-    pyproject_path: &Option<PathBuf>,
+    pyproject_path: Option<&PathBuf>,
 ) {
     for code in codes {
         if !cli_ignore.is_empty() {
@@ -192,7 +192,7 @@ pub fn warn_on(
 /// Convert a list of `PatternPrefixPair` structs to `PerFileIgnore`.
 pub fn collect_per_file_ignores(
     pairs: Vec<PatternPrefixPair>,
-    project_root: &Option<PathBuf>,
+    project_root: Option<&PathBuf>,
 ) -> Vec<PerFileIgnore> {
     let mut per_file_ignores: FnvHashMap<String, Vec<CheckCodePrefix>> = FnvHashMap::default();
     for pair in pairs {

src/flake8_annotations/plugins.rs

@@ -1,3 +1,5 @@
+use std::ops::Deref;
+
 use rustpython_ast::{Arguments, Constant, Expr, ExprKind, Stmt, StmtKind};
 
 use crate::ast::types::Range;
@@ -11,7 +13,7 @@ use crate::{visibility, Check};
 
 #[derive(Default)]
 struct ReturnStatementVisitor<'a> {
-    returns: Vec<&'a Option<Box<Expr>>>,
+    returns: Vec<Option<&'a Expr>>,
 }
 
 impl<'a, 'b> Visitor<'b> for ReturnStatementVisitor<'a>
@@ -23,7 +25,9 @@ where
             StmtKind::FunctionDef { .. } | StmtKind::AsyncFunctionDef { .. } => {
                 // No recurse.
             }
-            StmtKind::Return { value } => self.returns.push(value),
+            StmtKind::Return { value } => {
+                self.returns.push(value.as_ref().map(|expr| expr.deref()))
+            }
             _ => visitor::walk_stmt(self, stmt),
         }
     }

src/flake8_bugbear/plugins/assert_false.rs

@@ -6,7 +6,7 @@ use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 use crate::code_gen::SourceGenerator;
 
-fn assertion_error(msg: &Option<Box<Expr>>) -> Stmt {
+fn assertion_error(msg: Option<&Expr>) -> Stmt {
     Stmt::new(
         Default::default(),
         Default::default(),
@@ -24,7 +24,7 @@ fn assertion_error(msg: &Option<Box<Expr>>) -> Stmt {
                         },
                     )),
                     args: if let Some(msg) = msg {
-                        vec![*msg.clone()]
+                        vec![msg.clone()]
                     } else {
                         vec![]
                     },
@@ -36,7 +36,7 @@ fn assertion_error(msg: &Option<Box<Expr>>) -> Stmt {
     )
 }
 
-pub fn assert_false(checker: &mut Checker, stmt: &Stmt, test: &Expr, msg: &Option<Box<Expr>>) {
+pub fn assert_false(checker: &mut Checker, stmt: &Stmt, test: &Expr, msg: Option<&Expr>) {
     if let ExprKind::Constant {
         value: Constant::Bool(false),
         ..

src/fs.rs

@@ -202,7 +202,7 @@ mod tests {
         let path = Path::new("foo").absolutize_from(project_root).unwrap();
         let exclude = vec![FilePattern::from_user(
             "foo",
-            &Some(project_root.to_path_buf()),
+            Some(&project_root.to_path_buf()),
         )];
         let (file_path, file_basename) = extract_path_names(&path)?;
         assert!(is_excluded(file_path, file_basename, exclude.iter()));
@@ -210,7 +210,7 @@ mod tests {
         let path = Path::new("foo/bar").absolutize_from(project_root).unwrap();
         let exclude = vec![FilePattern::from_user(
             "bar",
-            &Some(project_root.to_path_buf()),
+            Some(&project_root.to_path_buf()),
         )];
         let (file_path, file_basename) = extract_path_names(&path)?;
         assert!(is_excluded(file_path, file_basename, exclude.iter()));
@@ -220,7 +220,7 @@ mod tests {
             .unwrap();
         let exclude = vec![FilePattern::from_user(
             "baz.py",
-            &Some(project_root.to_path_buf()),
+            Some(&project_root.to_path_buf()),
         )];
         let (file_path, file_basename) = extract_path_names(&path)?;
         assert!(is_excluded(file_path, file_basename, exclude.iter()));
@@ -228,7 +228,7 @@ mod tests {
         let path = Path::new("foo/bar").absolutize_from(project_root).unwrap();
         let exclude = vec![FilePattern::from_user(
             "foo/bar",
-            &Some(project_root.to_path_buf()),
+            Some(&project_root.to_path_buf()),
         )];
         let (file_path, file_basename) = extract_path_names(&path)?;
         assert!(is_excluded(file_path, file_basename, exclude.iter()));
@@ -238,7 +238,7 @@ mod tests {
             .unwrap();
         let exclude = vec![FilePattern::from_user(
             "foo/bar/baz.py",
-            &Some(project_root.to_path_buf()),
+            Some(&project_root.to_path_buf()),
         )];
         let (file_path, file_basename) = extract_path_names(&path)?;
         assert!(is_excluded(file_path, file_basename, exclude.iter()));
@@ -248,7 +248,7 @@ mod tests {
             .unwrap();
         let exclude = vec![FilePattern::from_user(
             "foo/bar/*.py",
-            &Some(project_root.to_path_buf()),
+            Some(&project_root.to_path_buf()),
         )];
         let (file_path, file_basename) = extract_path_names(&path)?;
         assert!(is_excluded(file_path, file_basename, exclude.iter()));
@@ -258,7 +258,7 @@ mod tests {
             .unwrap();
         let exclude = vec![FilePattern::from_user(
             "baz",
-            &Some(project_root.to_path_buf()),
+            Some(&project_root.to_path_buf()),
         )];
         let (file_path, file_basename) = extract_path_names(&path)?;
         assert!(!is_excluded(file_path, file_basename, exclude.iter()));

src/isort/categorize.rs

@@ -15,13 +15,13 @@ pub enum ImportType {
 
 pub fn categorize(
     module_base: &str,
-    level: &Option<usize>,
+    level: Option<&usize>,
     src: &[PathBuf],
     known_first_party: &BTreeSet<String>,
     known_third_party: &BTreeSet<String>,
     extra_standard_library: &BTreeSet<String>,
 ) -> ImportType {
-    if level.map(|level| level > 0).unwrap_or(false) {
+    if level.map(|level| *level > 0).unwrap_or(false) {
         ImportType::LocalFolder
     } else if known_first_party.contains(module_base) {
         ImportType::FirstParty

src/isort/comments.rs

@@ -0,0 +1,40 @@
+use std::borrow::Cow;
+
+use rustpython_ast::Location;
+use rustpython_parser::lexer;
+use rustpython_parser::lexer::Tok;
+
+use crate::ast::helpers;
+use crate::ast::types::Range;
+use crate::SourceCodeLocator;
+
+#[derive(Debug)]
+pub struct Comment<'a> {
+    pub value: Cow<'a, str>,
+    pub location: Location,
+    pub end_location: Location,
+}
+
+/// Collect all comments in an import block.
+pub fn collect_comments<'a>(range: &Range, locator: &'a SourceCodeLocator) -> Vec<Comment<'a>> {
+    let contents = locator.slice_source_code_range(range);
+    lexer::make_tokenizer(&contents)
+        .flatten()
+        .filter_map(|(start, tok, end)| {
+            if matches!(tok, Tok::Comment) {
+                let start = helpers::to_absolute(&start, &range.location);
+                let end = helpers::to_absolute(&end, &range.location);
+                Some(Comment {
+                    value: locator.slice_source_code_range(&Range {
+                        location: start,
+                        end_location: end,
+                    }),
+                    location: start,
+                    end_location: end,
+                })
+            } else {
+                None
+            }
+        })
+        .collect()
+}

src/isort/format.rs

@@ -0,0 +1,182 @@
+use crate::isort::types::{AliasData, CommentSet, ImportFromData, Importable};
+
+// Hard-code four-space indentation for the imports themselves, to match Black.
+const INDENT: &str = "    ";
+
+// Guess a capacity to use for string allocation.
+const CAPACITY: usize = 200;
+
+/// Add a plain import statement to the `RopeBuilder`.
+pub fn format_import(alias: &AliasData, comments: &CommentSet, is_first: bool) -> String {
+    let mut output = String::with_capacity(CAPACITY);
+    if !is_first && !comments.atop.is_empty() {
+        output.push('\n');
+    }
+    for comment in &comments.atop {
+        output.push_str(comment);
+        output.push('\n');
+    }
+    if let Some(asname) = alias.asname {
+        output.push_str("import ");
+        output.push_str(alias.name);
+        output.push_str(" as ");
+        output.push_str(asname);
+    } else {
+        output.push_str("import ");
+        output.push_str(alias.name);
+    }
+    for comment in &comments.inline {
+        output.push_str("  ");
+        output.push_str(comment);
+    }
+    output.push('\n');
+    output
+}
+
+/// Add an import-from statement to the `RopeBuilder`.
+pub fn format_import_from(
+    import_from: &ImportFromData,
+    comments: &CommentSet,
+    aliases: &[(AliasData, CommentSet)],
+    line_length: &usize,
+    is_first: bool,
+) -> String {
+    // We can only inline if: (1) none of the aliases have atop comments, and (3)
+    // only the last alias (if any) has inline comments.
+    if aliases
+        .iter()
+        .all(|(_, CommentSet { atop, .. })| atop.is_empty())
+        && aliases
+            .iter()
+            .rev()
+            .skip(1)
+            .all(|(_, CommentSet { inline, .. })| inline.is_empty())
+    {
+        let (single_line, import_length) =
+            format_single_line(import_from, comments, aliases, is_first);
+        if import_length <= *line_length {
+            return single_line;
+        }
+    }
+
+    format_multi_line(import_from, comments, aliases, is_first)
+}
+
+/// Format an import-from statement in single-line format.
+///
+/// This method assumes that the output source code is syntactically valid.
+fn format_single_line(
+    import_from: &ImportFromData,
+    comments: &CommentSet,
+    aliases: &[(AliasData, CommentSet)],
+    is_first: bool,
+) -> (String, usize) {
+    let mut output = String::with_capacity(CAPACITY);
+    let mut line_length = 0;
+
+    if !is_first && !comments.atop.is_empty() {
+        output.push('\n');
+    }
+    for comment in &comments.atop {
+        output.push_str(comment);
+        output.push('\n');
+    }
+
+    let module_name = import_from.module_name();
+    output.push_str("from ");
+    output.push_str(&module_name);
+    output.push_str(" import ");
+    line_length += 5 + module_name.len() + 8;
+
+    for (index, (AliasData { name, asname }, comments)) in aliases.iter().enumerate() {
+        if let Some(asname) = asname {
+            output.push_str(name);
+            output.push_str(" as ");
+            output.push_str(asname);
+            line_length += name.len() + 4 + asname.len();
+        } else {
+            output.push_str(name);
+            line_length += name.len();
+        }
+        if index < aliases.len() - 1 {
+            output.push_str(", ");
+            line_length += 2;
+        }
+
+        for comment in &comments.inline {
+            output.push(' ');
+            output.push(' ');
+            output.push_str(comment);
+            line_length += 2 + comment.len();
+        }
+    }
+
+    for comment in &comments.inline {
+        output.push(' ');
+        output.push(' ');
+        output.push_str(comment);
+        line_length += 2 + comment.len();
+    }
+
+    output.push('\n');
+
+    (output, line_length)
+}
+
+/// Format an import-from statement in multi-line format.
+fn format_multi_line(
+    import_from: &ImportFromData,
+    comments: &CommentSet,
+    aliases: &[(AliasData, CommentSet)],
+    is_first: bool,
+) -> String {
+    let mut output = String::with_capacity(CAPACITY);
+
+    if !is_first && !comments.atop.is_empty() {
+        output.push('\n');
+    }
+    for comment in &comments.atop {
+        output.push_str(comment);
+        output.push('\n');
+    }
+
+    output.push_str("from ");
+    output.push_str(&import_from.module_name());
+    output.push_str(" import ");
+    output.push('(');
+    for comment in &comments.inline {
+        output.push(' ');
+        output.push(' ');
+        output.push_str(comment);
+    }
+    output.push('\n');
+
+    for (AliasData { name, asname }, comments) in aliases {
+        for comment in &comments.atop {
+            output.push_str(INDENT);
+            output.push_str(comment);
+            output.push('\n');
+        }
+        output.push_str(INDENT);
+        if let Some(asname) = asname {
+            output.push_str(name);
+            output.push_str(" as ");
+            output.push_str(asname);
+        } else {
+            output.push_str(name);
+        }
+        output.push(',');
+
+        for comment in &comments.inline {
+            output.push(' ');
+            output.push(' ');
+            output.push_str(comment);
+        }
+        output.push('\n');
+    }
+
+    output.push(')');
+    output.push('\n');
+
+    output
+}

src/isort/mod.rs

@@ -1,64 +1,266 @@
 use std::collections::{BTreeMap, BTreeSet};
 use std::path::PathBuf;
 
-use fnv::FnvHashSet;
+use fnv::FnvHashMap;
 use itertools::Itertools;
 use ropey::RopeBuilder;
 use rustpython_ast::{Stmt, StmtKind};
 
 use crate::isort::categorize::{categorize, ImportType};
+use crate::isort::comments::Comment;
 use crate::isort::sorting::{member_key, module_key};
-use crate::isort::types::{AliasData, ImportBlock, ImportFromData, Importable, OrderedImportBlock};
+use crate::isort::types::{
+    AliasData, CommentSet, ImportBlock, ImportFromData, Importable, OrderedImportBlock,
+};
 
 mod categorize;
+mod comments;
+pub mod format;
 pub mod plugins;
 pub mod settings;
 mod sorting;
 pub mod track;
 mod types;
 
-// Hard-code four-space indentation for the imports themselves, to match Black.
-const INDENT: &str = "    ";
+#[derive(Debug)]
+pub struct AnnotatedAliasData<'a> {
+    pub name: &'a str,
+    pub asname: Option<&'a String>,
+    pub atop: Vec<Comment<'a>>,
+    pub inline: Vec<Comment<'a>>,
+}
+#[derive(Debug)]
+pub enum AnnotatedImport<'a> {
+    Import {
+        names: Vec<AliasData<'a>>,
+        atop: Vec<Comment<'a>>,
+        inline: Vec<Comment<'a>>,
+    },
+    ImportFrom {
+        module: Option<&'a String>,
+        names: Vec<AnnotatedAliasData<'a>>,
+        level: Option<&'a usize>,
+        atop: Vec<Comment<'a>>,
+        inline: Vec<Comment<'a>>,
+    },
+}
 
-fn normalize_imports<'a>(imports: &'a [&'a Stmt]) -> ImportBlock<'a> {
-    let mut block: ImportBlock = Default::default();
+fn annotate_imports<'a>(
+    imports: &'a [&'a Stmt],
+    comments: Vec<Comment<'a>>,
+) -> Vec<AnnotatedImport<'a>> {
+    let mut annotated = vec![];
+    let mut comments_iter = comments.into_iter().peekable();
     for import in imports {
         match &import.node {
             StmtKind::Import { names } => {
-                for name in names {
-                    block.import.insert(AliasData {
-                        name: &name.node.name,
-                        asname: &name.node.asname,
-                    });
+                // Find comments above.
+                let mut atop = vec![];
+                while let Some(comment) =
+                    comments_iter.next_if(|comment| comment.location.row() < import.location.row())
+                {
+                    atop.push(comment);
                 }
+
+                // Find comments inline.
+                let mut inline = vec![];
+                while let Some(comment) = comments_iter.next_if(|comment| {
+                    comment.end_location.row() == import.end_location.unwrap().row()
+                }) {
+                    inline.push(comment);
+                }
+
+                annotated.push(AnnotatedImport::Import {
+                    names: names
+                        .iter()
+                        .map(|alias| AliasData {
+                            name: &alias.node.name,
+                            asname: alias.node.asname.as_ref(),
+                        })
+                        .collect(),
+                    atop,
+                    inline,
+                });
             }
             StmtKind::ImportFrom {
                 module,
                 names,
                 level,
             } => {
-                for name in names {
-                    if name.node.asname.is_none() {
-                        block
+                // Find comments above.
+                let mut atop = vec![];
+                while let Some(comment) =
+                    comments_iter.next_if(|comment| comment.location.row() < import.location.row())
+                {
+                    atop.push(comment);
+                }
+
+                // Find comments inline.
+                let mut inline = vec![];
+                while let Some(comment) =
+                    comments_iter.next_if(|comment| comment.location.row() == import.location.row())
+                {
+                    inline.push(comment);
+                }
+
+                // Capture names.
+                let mut aliases = vec![];
+                for alias in names {
+                    // Find comments above.
+                    let mut alias_atop = vec![];
+                    while let Some(comment) = comments_iter
+                        .next_if(|comment| comment.location.row() < alias.location.row())
+                    {
+                        alias_atop.push(comment);
+                    }
+
+                    // Find comments inline.
+                    let mut alias_inline = vec![];
+                    while let Some(comment) = comments_iter.next_if(|comment| {
+                        comment.end_location.row() == alias.end_location.unwrap().row()
+                    }) {
+                        alias_inline.push(comment);
+                    }
+
+                    aliases.push(AnnotatedAliasData {
+                        name: &alias.node.name,
+                        asname: alias.node.asname.as_ref(),
+                        atop: alias_atop,
+                        inline: alias_inline,
+                    })
+                }
+
+                annotated.push(AnnotatedImport::ImportFrom {
+                    module: module.as_ref(),
+                    names: aliases,
+                    level: level.as_ref(),
+                    atop,
+                    inline,
+                });
+            }
+            _ => unreachable!("Expected StmtKind::Import | StmtKind::ImportFrom"),
+        }
+    }
+    annotated
+}
+
+fn normalize_imports(imports: Vec<AnnotatedImport>) -> ImportBlock {
+    let mut block: ImportBlock = Default::default();
+    for import in imports {
+        match import {
+            AnnotatedImport::Import {
+                names,
+                atop,
+                inline,
+            } => {
+                // Associate the comments with the first alias (best effort).
+                if let Some(name) = names.first() {
+                    let entry = block
+                        .import
+                        .entry(AliasData {
+                            name: name.name,
+                            asname: name.asname,
+                        })
+                        .or_default();
+                    for comment in atop {
+                        entry.atop.push(comment.value);
+                    }
+                    for comment in inline {
+                        entry.inline.push(comment.value);
+                    }
+                }
+
+                // Create an entry for every alias.
+                for name in &names {
+                    block
+                        .import
+                        .entry(AliasData {
+                            name: name.name,
+                            asname: name.asname,
+                        })
+                        .or_default();
+                }
+            }
+            AnnotatedImport::ImportFrom {
+                module,
+                names,
+                level,
+                atop,
+                inline,
+            } => {
+                // Associate the comments with the first alias (best effort).
+                if let Some(alias) = names.first() {
+                    if alias.asname.is_none() {
+                        let entry = &mut block
                             .import_from
                             .entry(ImportFromData { module, level })
                             .or_default()
-                            .insert(AliasData {
-                                name: &name.node.name,
-                                asname: &name.node.asname,
-                            });
+                            .0;
+                        for comment in atop {
+                            entry.atop.push(comment.value);
+                        }
+                        for comment in inline {
+                            entry.inline.push(comment.value);
+                        }
                     } else {
-                        block.import_from_as.insert((
-                            ImportFromData { module, level },
-                            AliasData {
-                                name: &name.node.name,
-                                asname: &name.node.asname,
-                            },
-                        ));
+                        let entry = &mut block
+                            .import_from_as
+                            .entry((
+                                ImportFromData { module, level },
+                                AliasData {
+                                    name: alias.name,
+                                    asname: alias.asname,
+                                },
+                            ))
+                            .or_default();
+                        for comment in atop {
+                            entry.atop.push(comment.value);
+                        }
+                        for comment in inline {
+                            entry.inline.push(comment.value);
+                        }
+                    }
+                }
+
+                // Create an entry for every alias.
+                for alias in names {
+                    if alias.asname.is_none() {
+                        let entry = block
+                            .import_from
+                            .entry(ImportFromData { module, level })
+                            .or_default()
+                            .1
+                            .entry(AliasData {
+                                name: alias.name,
+                                asname: alias.asname,
+                            })
+                            .or_default();
+                        for comment in alias.atop {
+                            entry.atop.push(comment.value);
+                        }
+                        for comment in alias.inline {
+                            entry.inline.push(comment.value);
+                        }
+                    } else {
+                        let entry = block
+                            .import_from_as
+                            .entry((
+                                ImportFromData { module, level },
+                                AliasData {
+                                    name: alias.name,
+                                    asname: alias.asname,
+                                },
+                            ))
+                            .or_default();
+                        entry
+                            .atop
+                            .extend(alias.atop.into_iter().map(|comment| comment.value));
+                        for comment in alias.inline {
+                            entry.inline.push(comment.value);
+                        }
                     }
                 }
             }
-            _ => unreachable!("Expected StmtKind::Import | StmtKind::ImportFrom"),
         }
     }
     block
@@ -73,10 +275,10 @@ fn categorize_imports<'a>(
 ) -> BTreeMap<ImportType, ImportBlock<'a>> {
     let mut block_by_type: BTreeMap<ImportType, ImportBlock> = Default::default();
     // Categorize `StmtKind::Import`.
-    for alias in block.import {
+    for (alias, comments) in block.import {
         let import_type = categorize(
             &alias.module_base(),
-            &None,
+            None,
             src,
             known_first_party,
             known_third_party,
@@ -86,7 +288,7 @@ fn categorize_imports<'a>(
             .entry(import_type)
             .or_default()
             .import
-            .insert(alias);
+            .insert(alias, comments);
     }
     // Categorize `StmtKind::ImportFrom` (without re-export).
     for (import_from, aliases) in block.import_from {
@@ -105,7 +307,7 @@ fn categorize_imports<'a>(
             .insert(import_from, aliases);
     }
     // Categorize `StmtKind::ImportFrom` (with re-export).
-    for (import_from, alias) in block.import_from_as {
+    for ((import_from, alias), comments) in block.import_from_as {
         let classification = categorize(
             &import_from.module_base(),
             import_from.level,
@@ -118,7 +320,7 @@ fn categorize_imports<'a>(
             .entry(classification)
             .or_default()
             .import_from_as
-            .insert((import_from, alias));
+            .insert((import_from, alias), comments);
     }
     block_by_type
 }
@@ -131,7 +333,7 @@ fn sort_imports(block: ImportBlock) -> OrderedImportBlock {
         block
             .import
             .into_iter()
-            .sorted_by_cached_key(|alias| module_key(alias.name, alias.asname)),
+            .sorted_by_cached_key(|(alias, _)| module_key(alias.name, alias.asname)),
     );
 
     // Sort `StmtKind::ImportFrom`.
@@ -145,29 +347,47 @@ fn sort_imports(block: ImportBlock) -> OrderedImportBlock {
                 block
                     .import_from_as
                     .into_iter()
-                    .map(|(import_from, alias)| (import_from, FnvHashSet::from_iter([alias]))),
+                    .map(|((import_from, alias), comments)| {
+                        (
+                            import_from,
+                            (
+                                CommentSet {
+                                    atop: comments.atop,
+                                    inline: Default::default(),
+                                },
+                                FnvHashMap::from_iter([(
+                                    alias,
+                                    CommentSet {
+                                        atop: Default::default(),
+                                        inline: comments.inline,
+                                    },
+                                )]),
+                            ),
+                        )
+                    }),
             )
-            .map(|(import_from, aliases)| {
+            .map(|(import_from, (comments, aliases))| {
                 // Within each `StmtKind::ImportFrom`, sort the members.
                 (
                     import_from,
+                    comments,
                     aliases
                         .into_iter()
-                        .sorted_by_cached_key(|alias| member_key(alias.name, alias.asname))
-                        .collect::<Vec<AliasData>>(),
+                        .sorted_by_cached_key(|(alias, _)| member_key(alias.name, alias.asname))
+                        .collect::<Vec<(AliasData, CommentSet)>>(),
                 )
             })
-            .sorted_by_cached_key(|(import_from, aliases)| {
+            .sorted_by_cached_key(|(import_from, _, aliases)| {
                 // Sort each `StmtKind::ImportFrom` by module key, breaking ties based on
                 // members.
                 (
                     import_from
                         .module
                         .as_ref()
-                        .map(|module| module_key(module, &None)),
+                        .map(|module| module_key(module, None)),
                     aliases
                         .first()
-                        .map(|alias| member_key(alias.name, alias.asname)),
+                        .map(|(alias, _)| member_key(alias.name, alias.asname)),
                 )
             }),
     );
@@ -176,15 +396,18 @@ fn sort_imports(block: ImportBlock) -> OrderedImportBlock {
 }
 
 pub fn format_imports(
-    block: Vec<&Stmt>,
+    block: &[&Stmt],
+    comments: Vec<Comment>,
     line_length: &usize,
     src: &[PathBuf],
     known_first_party: &BTreeSet<String>,
     known_third_party: &BTreeSet<String>,
     extra_standard_library: &BTreeSet<String>,
 ) -> String {
+    let block = annotate_imports(block, comments);
+
     // Normalize imports (i.e., deduplicate, aggregate `from` imports).
-    let block = normalize_imports(&block);
+    let block = normalize_imports(block);
 
     // Categorize by type (e.g., first-party vs. third-party).
     let block_by_type = categorize_imports(
@@ -195,81 +418,38 @@ pub fn format_imports(
         extra_standard_library,
     );
 
-    // Generate replacement source code.
     let mut output = RopeBuilder::new();
-    let mut first_block = true;
+
+    // Generate replacement source code.
+    let mut is_first_block = true;
     for import_block in block_by_type.into_values() {
         let import_block = sort_imports(import_block);
 
         // Add a blank line between every section.
-        if !first_block {
+        if !is_first_block {
             output.append("\n");
         } else {
-            first_block = false;
+            is_first_block = false;
         }
 
+        let mut is_first_statement = true;
+
         // Format `StmtKind::Import` statements.
-        for AliasData { name, asname } in import_block.import.iter() {
-            if let Some(asname) = asname {
-                output.append(&format!("import {} as {}\n", name, asname));
-            } else {
-                output.append(&format!("import {}\n", name));
-            }
+        for (alias, comments) in import_block.import.iter() {
+            output.append(&format::format_import(alias, comments, is_first_statement));
+            is_first_statement = false;
         }
 
         // Format `StmtKind::ImportFrom` statements.
-        for (import_from, aliases) in import_block.import_from.iter() {
-            let prelude: String = format!("from {} import ", import_from.module_name());
-            let members: Vec<String> = aliases
-                .iter()
-                .map(|AliasData { name, asname }| {
-                    if let Some(asname) = asname {
-                        format!("{} as {}", name, asname)
-                    } else {
-                        name.to_string()
-                    }
-                })
-                .collect();
-
-            // Can we fit the import on a single line?
-            let expected_len: usize =
-                    // `from base import `
-                    prelude.len()
-                        // `member( as alias)?`
-                        + members.iter().map(|part| part.len()).sum::<usize>()
-                        // `, `
-                        + 2 * (members.len() - 1);
-
-            if expected_len <= *line_length {
-                // `from base import `
-                output.append(&prelude);
-                // `member( as alias)?(, )?`
-                for (index, part) in members.into_iter().enumerate() {
-                    if index > 0 {
-                        output.append(", ");
-                    }
-                    output.append(&part);
-                }
-                // `\n`
-                output.append("\n");
-            } else {
-                // `from base import (\n`
-                output.append(&prelude);
-                output.append("(");
-                output.append("\n");
-
-                // `    member( as alias)?,\n`
-                for part in members {
-                    output.append(INDENT);
-                    output.append(&part);
-                    output.append(",");
-                    output.append("\n");
-                }
-
-                // `)\n`
-                output.append(")");
-                output.append("\n");
-            }
+        for (import_from, comments, aliases) in import_block.import_from.iter() {
+            output.append(&format::format_import_from(
+                import_from,
+                comments,
+                aliases,
+                line_length,
+                is_first_statement,
+            ));
+            is_first_statement = false;
         }
     }
     output.finish().to_string()
@@ -287,13 +467,17 @@ mod tests {
     use crate::linter::test_path;
     use crate::Settings;
 
+    #[test_case(Path::new("add_newline_before_comments.py"))]
     #[test_case(Path::new("combine_import_froms.py"))]
+    #[test_case(Path::new("comments.py"))]
     #[test_case(Path::new("deduplicate_imports.py"))]
     #[test_case(Path::new("fit_line_length.py"))]
+    #[test_case(Path::new("fit_line_length_comment.py"))]
     #[test_case(Path::new("import_from_after_import.py"))]
     #[test_case(Path::new("leading_prefix.py"))]
     #[test_case(Path::new("no_reorder_within_section.py"))]
     #[test_case(Path::new("order_by_type.py"))]
+    #[test_case(Path::new("preserve_comment_order.py"))]
     #[test_case(Path::new("preserve_indentation.py"))]
     #[test_case(Path::new("reorder_within_section.py"))]
     #[test_case(Path::new("separate_first_party_imports.py"))]
@@ -303,6 +487,7 @@ mod tests {
     #[test_case(Path::new("skip.py"))]
     #[test_case(Path::new("sort_similar_imports.py"))]
     #[test_case(Path::new("trailing_suffix.py"))]
+    #[test_case(Path::new("type_comments.py"))]
     fn isort(path: &Path) -> Result<()> {
         let snapshot = format!("{}", path.to_string_lossy());
         let mut checks = test_path(

src/isort/plugins.rs

@@ -5,7 +5,7 @@ use crate::ast::types::Range;
 use crate::autofix::{fixer, Fix};
 use crate::checks::CheckKind;
 use crate::docstrings::helpers::leading_space;
-use crate::isort::format_imports;
+use crate::isort::{comments, format_imports};
 use crate::{Check, Settings, SourceCodeLocator};
 
 fn extract_range(body: &[&Stmt]) -> Range {
@@ -44,7 +44,15 @@ fn match_trailing_content(body: &[&Stmt], locator: &SourceCodeLocator) -> bool {
         end_location: Location::new(end_location.row() + 1, 0),
     };
     let suffix = locator.slice_source_code_range(&range);
-    suffix.chars().any(|char| !char.is_whitespace())
+    for char in suffix.chars() {
+        if char == '#' {
+            return false;
+        }
+        if !char.is_whitespace() {
+            return true;
+        }
+    }
+    false
 }
 
 /// I001
@@ -57,13 +65,23 @@ pub fn check_imports(
     let range = extract_range(&body);
     let indentation = extract_indentation(&body, locator);
 
+    // Extract comments. Take care to grab any inline comments from the last line.
+    let comments = comments::collect_comments(
+        &Range {
+            location: range.location,
+            end_location: Location::new(range.end_location.row() + 1, 0),
+        },
+        locator,
+    );
+
     // Special-cases: there's leading or trailing content in the import block.
     let has_leading_content = match_leading_content(&body, locator);
     let has_trailing_content = match_trailing_content(&body, locator);
 
     // Generate the sorted import block.
     let expected = format_imports(
-        body,
+        &body,
+        comments,
         &(settings.line_length - indentation.len()),
         &settings.src,
         &settings.isort.known_first_party,

src/isort/snapshots/ruff__isort__tests__add_newline_before_comments.py.snap

@@ -0,0 +1,22 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+- kind: UnsortedImports
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 8
+    column: 0
+  fix:
+    patch:
+      content: "import os\n\n# This is a comment in the same section, so we need to add one newline.\nimport sys\n\nimport numpy as np\n\n# This is a comment, but it starts a new section, so we don't need to add a newline\n# before it.\nimport leading_prefix\n"
+      location:
+        row: 1
+        column: 0
+      end_location:
+        row: 8
+        column: 0
+    applied: false
+

src/isort/snapshots/ruff__isort__tests__comments.py.snap

@@ -0,0 +1,22 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+- kind: UnsortedImports
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 26
+    column: 0
+  fix:
+    patch:
+      content: "import B  # Comment 4\n\n# Comment 3a\n# Comment 3b\nimport C\nimport D\n\n# Comment 5\n# Comment 6\nfrom A import (\n    a,  # Comment 7  # Comment 9\n    b,  # Comment 10\n    c,  # Comment 8  # Comment 11\n)\n"
+      location:
+        row: 3
+        column: 0
+      end_location:
+        row: 26
+        column: 0
+    applied: false
+

src/isort/snapshots/ruff__isort__tests__fit_line_length_comment.py.snap

@@ -0,0 +1,22 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+- kind: UnsortedImports
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 5
+    column: 0
+  fix:
+    patch:
+      content: "import a\n\n# Don't take this comment into account when determining whether the next import can fit on one line.\nfrom b import c\nfrom d import (  # Do take this comment into account when determining whether the next import can fit on one line.\n    e,\n)\n"
+      location:
+        row: 1
+        column: 0
+      end_location:
+        row: 5
+        column: 0
+    applied: false
+

src/isort/snapshots/ruff__isort__tests__preserve_comment_order.py.snap

@@ -0,0 +1,22 @@
+---
+source: src/isort/mod.rs
+expression: checks
+---
+- kind: UnsortedImports
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 12
+    column: 0
+  fix:
+    patch:
+      content: "import abc\nimport io\n\n# Old MacDonald had a farm,\n# EIEIO\n# And on his farm he had a cow,\n# EIEIO\n# With a moo-moo here and a moo-moo there\n# Here a moo, there a moo, everywhere moo-moo\n# Old MacDonald had a farm,\n# EIEIO\nfrom errno import EIO\n"
+      location:
+        row: 1
+        column: 0
+      end_location:
+        row: 12
+        column: 0
+    applied: false
+

src/isort/snapshots/ruff__isort__tests__type_comments.py.snap

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

src/isort/sorting.rs

@@ -10,15 +10,15 @@ pub enum Prefix {
 
 pub fn module_key<'a>(
     name: &'a str,
-    asname: &'a Option<String>,
-) -> (String, &'a str, &'a Option<String>) {
+    asname: Option<&'a String>,
+) -> (String, &'a str, Option<&'a String>) {
     (name.to_lowercase(), name, asname)
 }
 
 pub fn member_key<'a>(
     name: &'a str,
-    asname: &'a Option<String>,
-) -> (Prefix, String, &'a Option<String>) {
+    asname: Option<&'a String>,
+) -> (Prefix, String, Option<&'a String>) {
     (
         if name.len() > 1 && string::is_upper(name) {
             // Ex) `CONSTANT`

src/isort/types.rs

@@ -1,15 +1,25 @@
-use fnv::{FnvHashMap, FnvHashSet};
+use std::borrow::Cow;
+
+use fnv::FnvHashMap;
+
+use crate::ast;
 
 #[derive(Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
 pub struct ImportFromData<'a> {
-    pub module: &'a Option<String>,
-    pub level: &'a Option<usize>,
+    pub module: Option<&'a String>,
+    pub level: Option<&'a usize>,
 }
 
 #[derive(Debug, Hash, Ord, PartialOrd, Eq, PartialEq)]
 pub struct AliasData<'a> {
     pub name: &'a str,
-    pub asname: &'a Option<String>,
+    pub asname: Option<&'a String>,
+}
+
+#[derive(Debug, Default)]
+pub struct CommentSet<'a> {
+    pub atop: Vec<Cow<'a, str>>,
+    pub inline: Vec<Cow<'a, str>>,
 }
 
 pub trait Importable {
@@ -29,16 +39,7 @@ impl Importable for AliasData<'_> {
 
 impl Importable for ImportFromData<'_> {
     fn module_name(&self) -> String {
-        let mut module_name = String::new();
-        if let Some(level) = self.level {
-            if level > &0 {
-                module_name.push_str(&".".repeat(*level));
-            }
-        }
-        if let Some(module) = self.module {
-            module_name.push_str(module);
-        }
-        module_name
+        ast::helpers::format_import_from(self.level, self.module)
     }
 
     fn module_base(&self) -> String {
@@ -50,17 +51,24 @@ impl Importable for ImportFromData<'_> {
 pub struct ImportBlock<'a> {
     // Set of (name, asname), used to track regular imports.
     // Ex) `import module`
-    pub import: FnvHashSet<AliasData<'a>>,
+    pub import: FnvHashMap<AliasData<'a>, CommentSet<'a>>,
     // Map from (module, level) to `AliasData`, used to track 'from' imports.
     // Ex) `from module import member`
-    pub import_from: FnvHashMap<ImportFromData<'a>, FnvHashSet<AliasData<'a>>>,
+    pub import_from:
+        FnvHashMap<ImportFromData<'a>, (CommentSet<'a>, FnvHashMap<AliasData<'a>, CommentSet<'a>>)>,
     // Set of (module, level, name, asname), used to track re-exported 'from' imports.
     // Ex) `from module import member as member`
-    pub import_from_as: FnvHashSet<(ImportFromData<'a>, AliasData<'a>)>,
+    pub import_from_as: FnvHashMap<(ImportFromData<'a>, AliasData<'a>), CommentSet<'a>>,
 }
 
+type AliasDataWithComments<'a> = (AliasData<'a>, CommentSet<'a>);
+
 #[derive(Debug, Default)]
 pub struct OrderedImportBlock<'a> {
-    pub import: Vec<AliasData<'a>>,
-    pub import_from: Vec<(ImportFromData<'a>, Vec<AliasData<'a>>)>,
+    pub import: Vec<AliasDataWithComments<'a>>,
+    pub import_from: Vec<(
+        ImportFromData<'a>,
+        CommentSet<'a>,
+        Vec<AliasDataWithComments<'a>>,
+    )>,
 }

src/lib.rs

@@ -64,14 +64,16 @@ pub fn check(path: &Path, contents: &str, autofix: bool) -> Result<Vec<Check>> {
         Some(path) => debug!("Found project root at: {:?}", path),
         None => debug!("Unable to identify project root; assuming current directory..."),
     };
-    let pyproject = pyproject::find_pyproject_toml(&project_root);
+    let pyproject = pyproject::find_pyproject_toml(project_root.as_ref());
     match &pyproject {
         Some(path) => debug!("Found pyproject.toml at: {:?}", path),
         None => debug!("Unable to find pyproject.toml; using default settings..."),
     };
 
-    let settings =
-        Settings::from_configuration(Configuration::from_pyproject(&pyproject, &project_root)?);
+    let settings = Settings::from_configuration(Configuration::from_pyproject(
+        pyproject.as_ref(),
+        project_root.as_ref(),
+    )?);
 
     // Tokenize once.
     let tokens: Vec<LexResult> = tokenize(contents);

src/main.rs

@@ -208,7 +208,7 @@ fn inner_main() -> Result<ExitCode> {
     };
     let pyproject = cli
         .config
-        .or_else(|| pyproject::find_pyproject_toml(&project_root));
+        .or_else(|| pyproject::find_pyproject_toml(project_root.as_ref()));
     match &pyproject {
         Some(path) => debug!("Found pyproject.toml at: {:?}", path),
         None => debug!("Unable to find pyproject.toml; using default settings..."),
@@ -218,15 +218,16 @@ fn inner_main() -> Result<ExitCode> {
     let exclude: Vec<FilePattern> = cli
         .exclude
         .iter()
-        .map(|path| FilePattern::from_user(path, &project_root))
+        .map(|path| FilePattern::from_user(path, project_root.as_ref()))
         .collect();
     let extend_exclude: Vec<FilePattern> = cli
         .extend_exclude
         .iter()
-        .map(|path| FilePattern::from_user(path, &project_root))
+        .map(|path| FilePattern::from_user(path, project_root.as_ref()))
         .collect();
 
-    let mut configuration = Configuration::from_pyproject(&pyproject, &project_root)?;
+    let mut configuration =
+        Configuration::from_pyproject(pyproject.as_ref(), project_root.as_ref())?;
     if !exclude.is_empty() {
         configuration.exclude = exclude;
     }
@@ -235,7 +236,7 @@ fn inner_main() -> Result<ExitCode> {
     }
     if !cli.per_file_ignores.is_empty() {
         configuration.per_file_ignores =
-            collect_per_file_ignores(cli.per_file_ignores, &project_root);
+            collect_per_file_ignores(cli.per_file_ignores, project_root.as_ref());
     }
     if !cli.select.is_empty() {
         warn_on(
@@ -244,7 +245,7 @@ fn inner_main() -> Result<ExitCode> {
             &cli.ignore,
             &cli.extend_ignore,
             &configuration,
-            &pyproject,
+            pyproject.as_ref(),
         );
         configuration.select = cli.select;
     }
@@ -255,7 +256,7 @@ fn inner_main() -> Result<ExitCode> {
             &cli.ignore,
             &cli.extend_ignore,
             &configuration,
-            &pyproject,
+            pyproject.as_ref(),
         );
         configuration.extend_select = cli.extend_select;
     }

src/noqa.rs

@@ -72,10 +72,7 @@ fn add_noqa_inner(
         // Grab the noqa (logical) line number for the current (physical) line.
         // If there are newlines at the end of the file, they won't be represented in
         // `noqa_line_for`, so fallback to the current line.
-        let noqa_lineno = noqa_line_for
-            .get(&lineno)
-            .map(|lineno| lineno - 1)
-            .unwrap_or(lineno);
+        let noqa_lineno = noqa_line_for.get(&(lineno + 1)).unwrap_or(&(lineno + 1)) - 1;
 
         if !codes.is_empty() {
             let matches = matches_by_line.entry(noqa_lineno).or_default();

src/pycodestyle/checks.rs

@@ -1,6 +1,6 @@
 use itertools::izip;
 use rustpython_ast::Location;
-use rustpython_parser::ast::{Cmpop, Constant, Expr, ExprKind, Unaryop};
+use rustpython_parser::ast::{Cmpop, Constant, Expr, ExprKind, Stmt, Unaryop};
 
 use crate::ast::types::Range;
 use crate::checks::{Check, CheckKind, RejectedCmpop};
@@ -47,12 +47,16 @@ pub fn ambiguous_function_name(name: &str, location: Range) -> Option<Check> {
 }
 
 /// E731
-pub fn do_not_assign_lambda(value: &Expr, location: Range) -> Option<Check> {
-    if let ExprKind::Lambda { .. } = &value.node {
-        Some(Check::new(CheckKind::DoNotAssignLambda, location))
-    } else {
-        None
+pub fn do_not_assign_lambda(target: &Expr, value: &Expr, stmt: &Stmt) -> Option<Check> {
+    if let ExprKind::Name { .. } = &target.node {
+        if let ExprKind::Lambda { .. } = &value.node {
+            return Some(Check::new(
+                CheckKind::DoNotAssignLambda,
+                Range::from_located(stmt),
+            ));
+        }
     }
+    None
 }
 
 /// E713, E714

src/pyflakes/checks.rs

@@ -64,9 +64,9 @@ pub fn unused_variables(scope: &Scope, dummy_variable_rgx: &Regex) -> Vec<Check>
         if binding.used.is_none()
             && matches!(binding.kind, BindingKind::Assignment)
             && !dummy_variable_rgx.is_match(name)
-            && name != "__tracebackhide__"
-            && name != "__traceback_info__"
-            && name != "__traceback_supplement__"
+            && name != &"__tracebackhide__"
+            && name != &"__traceback_info__"
+            && name != &"__traceback_supplement__"
         {
             checks.push(Check::new(
                 CheckKind::UnusedVariable(name.to_string()),

src/pyupgrade/checks.rs

@@ -115,7 +115,7 @@ pub fn useless_object_inheritance(name: &str, bases: &[Expr], scope: &Scope) ->
     for expr in bases {
         if let ExprKind::Name { id, .. } = &expr.node {
             if id == "object" {
-                match scope.values.get(id) {
+                match scope.values.get(&id.as_str()) {
                     None
                     | Some(Binding {
                         kind: BindingKind::Builtin,

src/settings/configuration.rs

@@ -65,8 +65,8 @@ static DEFAULT_DUMMY_VARIABLE_RGX: Lazy<Regex> =
 
 impl Configuration {
     pub fn from_pyproject(
-        pyproject: &Option<PathBuf>,
-        project_root: &Option<PathBuf>,
+        pyproject: Option<&PathBuf>,
+        project_root: Option<&PathBuf>,
     ) -> Result<Self> {
         let options = load_options(pyproject)?;
         Ok(Configuration {

src/settings/pyproject.rs

@@ -36,7 +36,7 @@ fn parse_pyproject_toml(path: &Path) -> Result<Pyproject> {
     toml::from_str(&contents).map_err(|e| e.into())
 }
 
-pub fn find_pyproject_toml(path: &Option<PathBuf>) -> Option<PathBuf> {
+pub fn find_pyproject_toml(path: Option<&PathBuf>) -> Option<PathBuf> {
     if let Some(path) = path {
         let path_pyproject_toml = path.join("pyproject.toml");
         if path_pyproject_toml.is_file() {
@@ -80,7 +80,7 @@ pub fn find_project_root(sources: &[PathBuf]) -> Option<PathBuf> {
     None
 }
 
-pub fn load_options(pyproject: &Option<PathBuf>) -> Result<Options> {
+pub fn load_options(pyproject: Option<&PathBuf>) -> Result<Options> {
     match pyproject {
         Some(pyproject) => Ok(parse_pyproject_toml(pyproject)?
             .tool
@@ -323,7 +323,7 @@ other-attribute = 1
         assert_eq!(project_root, cwd.join("resources/test/fixtures"));
 
         let path =
-            find_pyproject_toml(&Some(project_root)).expect("Unable to find pyproject.toml.");
+            find_pyproject_toml(Some(&project_root)).expect("Unable to find pyproject.toml.");
         assert_eq!(path, cwd.join("resources/test/fixtures/pyproject.toml"));
 
         let pyproject = parse_pyproject_toml(&path)?;

src/settings/types.rs

@@ -51,7 +51,7 @@ pub enum FilePattern {
 }
 
 impl FilePattern {
-    pub fn from_user(pattern: &str, project_root: &Option<PathBuf>) -> Self {
+    pub fn from_user(pattern: &str, project_root: Option<&PathBuf>) -> Self {
         let path = Path::new(pattern);
         let absolute_path = match project_root {
             Some(project_root) => fs::normalize_path_to(path, project_root),
@@ -79,7 +79,7 @@ impl PerFileIgnore {
     pub fn new(
         pattern: &str,
         prefixes: &[CheckCodePrefix],
-        project_root: &Option<PathBuf>,
+        project_root: Option<&PathBuf>,
     ) -> Self {
         let pattern = FilePattern::from_user(pattern, project_root);
         let codes = BTreeSet::from_iter(prefixes.iter().flat_map(|prefix| prefix.codes()));

src/snapshots/ruff__linter__tests__E731_E731.py.snap

@@ -26,20 +26,4 @@ expression: checks
     row: 7
     column: 29
   fix: ~
-- kind: DoNotAssignLambda
-  location:
-    row: 12
-    column: 0
-  end_location:
-    row: 12
-    column: 27
-  fix: ~
-- kind: DoNotAssignLambda
-  location:
-    row: 16
-    column: 0
-  end_location:
-    row: 16
-    column: 25
-  fix: ~