Bump version to 0.0.108

.pre-commit-config.yaml

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

Cargo.lock

@@ -920,7 +920,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.107-dev.0"
+version = "0.0.108-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.15",
@@ -2221,7 +2221,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.107"
+version = "0.0.108"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2266,7 +2266,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.107"
+version = "0.0.108"
 dependencies = [
  "anyhow",
  "clap 4.0.15",
@@ -2295,7 +2295,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.1.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
 dependencies = [
  "num-bigint",
  "rustpython-common",
@@ -2305,7 +2305,7 @@ dependencies = [
 [[package]]
 name = "rustpython-common"
 version = "0.0.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
 dependencies = [
  "ascii",
  "cfg-if 1.0.0",
@@ -2328,7 +2328,7 @@ dependencies = [
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
 dependencies = [
  "bincode",
  "bitflags",
@@ -2345,7 +2345,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
 dependencies = [
  "ahash",
  "anyhow",

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.107"
+version = "0.0.108"
 edition = "2021"
 
 [lib]
@@ -33,9 +33,9 @@ path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
 ropey = { version = "1.5.0" }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
 serde = { version = "1.0.143", features = ["derive"] }
 serde_json = { version = "1.0.83" }
 strum = { version = "0.24.1", features = ["strum_macros"] }

README.md

@@ -97,7 +97,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.107
+    rev: v0.0.108
     hooks:
       - id: ruff
 ```
@@ -431,6 +431,7 @@ For more, see [pyupgrade](https://pypi.org/project/pyupgrade/3.2.0/) on PyPI.
 | U007 | UsePEP604Annotation | Use `X \| Y` for type annotations | 🛠 |
 | U008 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` | 🛠 |
 | U009 | PEP3120UnnecessaryCodingComment | utf-8 encoding declaration is unnecessary | 🛠 |
+| U010 | UnnecessaryFutureImport | Unnessary __future__ import `...` for target Python version |  |
 
 ### pep8-naming
 
@@ -464,7 +465,7 @@ For more, see [flake8-comprehensions](https://pypi.org/project/flake8-comprehens
 | C401 | UnnecessaryGeneratorSet | Unnecessary generator (rewrite as a `set` comprehension) | 🛠 |
 | C402 | UnnecessaryGeneratorDict | Unnecessary generator (rewrite as a `dict` comprehension) | 🛠 |
 | C403 | UnnecessaryListComprehensionSet | Unnecessary `list` comprehension (rewrite as a `set` comprehension) | 🛠 |
-| C404 | UnnecessaryListComprehensionDict | Unnecessary `list` comprehension (rewrite as a `dict` comprehension) |  |
+| C404 | UnnecessaryListComprehensionDict | Unnecessary `list` comprehension (rewrite as a `dict` comprehension) | 🛠 |
 | C405 | UnnecessaryLiteralSet | Unnecessary `(list\|tuple)` literal (rewrite as a `set` literal) | 🛠 |
 | C406 | UnnecessaryLiteralDict | Unnecessary `(list\|tuple)` literal (rewrite as a `dict` literal) | 🛠 |
 | C408 | UnnecessaryCollectionCall | Unnecessary `(dict\|list\|tuple)` call (rewrite as a literal) | 🛠 |
@@ -545,6 +546,7 @@ For more, see [flake8-annotations](https://pypi.org/project/flake8-annotations/2
 | ANN204 | MissingReturnTypeMagicMethod | Missing return type annotation for magic method `...` |  |
 | ANN205 | MissingReturnTypeStaticMethod | Missing return type annotation for staticmethod `...` |  |
 | ANN206 | MissingReturnTypeClassMethod | Missing return type annotation for classmethod `...` |  |
+| ANN401 | DynamicallyTypedExpression | Dynamically typed expressions (typing.Any) are disallowed in `...` |  |
 
 ### Ruff-specific rules
 
@@ -552,6 +554,7 @@ For more, see [flake8-annotations](https://pypi.org/project/flake8-annotations/2
 | ---- | ---- | ------- | --- |
 | RUF001 | AmbiguousUnicodeCharacterString | String contains ambiguous unicode character '𝐁' (did you mean 'B'?) | 🛠 |
 | RUF002 | AmbiguousUnicodeCharacterDocstring | Docstring contains ambiguous unicode character '𝐁' (did you mean 'B'?) | 🛠 |
+| RUF003 | AmbiguousUnicodeCharacterComment | Comment contains ambiguous unicode character '𝐁' (did you mean 'B'?) |  |
 
 ### Meta rules
 
@@ -634,7 +637,7 @@ including:
 - [`flake8-annotations`](https://pypi.org/project/flake8-annotations/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
 - [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (17/32)
-- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (11/34)
+- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (12/34)
 - [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
 
 Beyond rule-set parity, Ruff suffers from the following limitations vis-à-vis Flake8:
@@ -659,7 +662,7 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 - [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (17/32)
 
 Ruff also implements the functionality that you get from [`yesqa`](https://github.com/asottile/yesqa),
-and a subset of the rules implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (11/34).
+and a subset of the rules implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (12/34).
 
 If you're looking to use Ruff, but rely on an unsupported Flake8 plugin, free to file an Issue.
 

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.107"
+version = "0.0.108"
 dependencies = [
  "anyhow",
  "clap",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.107"
+version = "0.0.108"
 dependencies = [
  "anyhow",
  "bincode",
@@ -2028,7 +2028,7 @@ dependencies = [
 [[package]]
 name = "rustpython-ast"
 version = "0.1.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
 dependencies = [
  "num-bigint",
  "rustpython-common",
@@ -2038,7 +2038,7 @@ dependencies = [
 [[package]]
 name = "rustpython-common"
 version = "0.0.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
 dependencies = [
  "ascii",
  "cfg-if 1.0.0",
@@ -2061,7 +2061,7 @@ dependencies = [
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
 dependencies = [
  "bincode",
  "bitflags",
@@ -2078,7 +2078,7 @@ dependencies = [
 [[package]]
 name = "rustpython-parser"
 version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=77b821a1941019fe34f73ce17cea013ae1b98fd0#77b821a1941019fe34f73ce17cea013ae1b98fd0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb#27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb"
 dependencies = [
  "ahash",
  "anyhow",

flake8_to_ruff/Cargo.toml

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

flake8_to_ruff/src/converter.rs

@@ -128,6 +128,12 @@ pub fn convert(
                         Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
                     }
                 }
+                "allow-star-arg-any" | "allow_star_arg_any" => {
+                    match parser::parse_bool(value.as_ref()) {
+                        Ok(bool) => flake8_annotations.allow_star_arg_any = Some(bool),
+                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
+                    }
+                }
                 // flake8-quotes
                 "quotes" | "inline-quotes" | "inline_quotes" => match value.trim() {
                     "'" | "single" => flake8_quotes.inline_quotes = Some(Quote::Single),

resources/test/fixtures/RUF001.py

@@ -2,5 +2,6 @@ x = "𝐁ad string"
 
 
 def f():
-    """Here's a comment with an unusual parenthesis: ）"""
+    """Here's a docstring with an unusual parenthesis: ）"""
+    # And here's a comment with an unusual punctuation mark: ᜵
     ...

resources/test/fixtures/RUF002.py

@@ -2,5 +2,6 @@ x = "𝐁ad string"
 
 
 def f():
-    """Here's a comment with an unusual parenthesis: ）"""
+    """Here's a docstring with an unusual parenthesis: ）"""
+    # And here's a comment with an unusual punctuation mark: ᜵
     ...

resources/test/fixtures/RUF003.py

@@ -0,0 +1,7 @@
+x = "𝐁ad string"
+
+
+def f():
+    """Here's a docstring with an unusual parenthesis: ）"""
+    # And here's a comment with an unusual punctuation mark: ᜵
+    ...

resources/test/fixtures/U010.py

@@ -0,0 +1,5 @@
+from __future__ import annotations, nested_scopes, generators
+
+from __future__ import absolute_import, division
+
+from __future__ import generator_stop

resources/test/fixtures/flake8_annotations/allow_star_arg_any.py

@@ -0,0 +1,57 @@
+from typing import Any
+
+
+# OK
+def foo(a: int, *args: str, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: Any, *args: str, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: str, **kwargs: str) -> Any:
+    pass
+
+
+# OK
+def foo(a: int, *args: Any, **kwargs: Any) -> int:
+    pass
+
+
+# OK
+def foo(a: int, *args: Any, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: str, **kwargs: Any) -> int:
+    pass
+
+
+class Bar:
+    # OK
+    def foo_method(self, a: int, *params: str, **options: str) -> int:
+        pass
+
+    # ANN401
+    def foo_method(self, a: Any, *params: str, **options: str) -> int:
+        pass
+
+    # ANN401
+    def foo_method(self, a: int, *params: str, **options: str) -> Any:
+        pass
+
+    # OK
+    def foo_method(self, a: int, *params: Any, **options: Any) -> int:
+        pass
+
+    # OK
+    def foo_method(self, a: int, *params: Any, **options: str) -> int:
+        pass
+
+    # OK
+    def foo_method(self, a: int, *params: str, **options: Any) -> int:
+        pass

resources/test/fixtures/flake8_annotations/annotation_presence.py

@@ -1,4 +1,4 @@
-from typing import Type
+from typing import Any, Type
 
 # Error
 def foo(a, b):
@@ -35,6 +35,36 @@ def foo() -> int:
     pass
 
 
+# OK
+def foo(a: int, *args: str, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: Any, *args: str, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: str, **kwargs: str) -> Any:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: Any, **kwargs: Any) -> int:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: Any, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: str, **kwargs: Any) -> int:
+    pass
+
+
 class Foo:
     # OK
     def foo(self: "Foo", a: int, b: int) -> int:
@@ -44,6 +74,26 @@ class Foo:
     def foo(self, a: int, b: int) -> int:
         pass
 
+    # ANN401
+    def foo(self: "Foo", a: Any, *params: str, **options: str) -> int:
+        pass
+
+    # ANN401
+    def foo(self: "Foo", a: int, *params: str, **options: str) -> Any:
+        pass
+
+    # ANN401
+    def foo(self: "Foo", a: int, *params: Any, **options: Any) -> int:
+        pass
+
+    # ANN401
+    def foo(self: "Foo", a: int, *params: Any, **options: str) -> int:
+        pass
+
+    # ANN401
+    def foo(self: "Foo", a: int, *params: str, **options: Any) -> int:
+        pass
+
     # OK
     @classmethod
     def foo(cls: Type["Foo"], a: int, b: int) -> int:

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.107"
+version = "0.0.108"
 edition = "2021"
 
 [dependencies]
@@ -9,8 +9,8 @@ clap = { version = "4.0.1", features = ["derive"] }
 codegen = { version = "0.2.0" }
 itertools = { version = "0.10.5" }
 ruff = { path = ".." }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "27bf82a2251d7e6ac6cd75e6ad51be12a53d84bb" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
 strum_macros = { version = "0.24.3" }

src/check_ast.rs

@@ -624,6 +624,14 @@ where
                             }
                         }
 
+                        if self.settings.enabled.contains(&CheckCode::U010) {
+                            pyupgrade::plugins::unnecessary_future_import(
+                                self,
+                                stmt,
+                                &alias.node.name,
+                            );
+                        }
+
                         if self.settings.enabled.contains(&CheckCode::F404) && !self.futures_allowed
                         {
                             self.add_check(Check::new(
@@ -1111,9 +1119,12 @@ where
                 if self.settings.enabled.contains(&CheckCode::C404) {
                     if let Some(check) =
                         flake8_comprehensions::checks::unnecessary_list_comprehension_dict(
+                            expr,
                             func,
                             args,
                             keywords,
+                            self.locator,
+                            self.patch(),
                             Range::from_located(expr),
                         )
                     {
@@ -2397,6 +2408,7 @@ impl<'a> Checker<'a> {
                 || self.settings.enabled.contains(&CheckCode::ANN204)
                 || self.settings.enabled.contains(&CheckCode::ANN205)
                 || self.settings.enabled.contains(&CheckCode::ANN206)
+                || self.settings.enabled.contains(&CheckCode::ANN401)
             {
                 flake8_annotations::plugins::definition(self, &definition, &visibility);
             }

src/check_tokens.rs

@@ -5,6 +5,7 @@ use rustpython_parser::lexer::{LexResult, Tok};
 use crate::autofix::fixer;
 use crate::checks::{Check, CheckCode};
 use crate::lex::docstring_detection::StateMachine;
+use crate::rules::checks::Context;
 use crate::source_code_locator::SourceCodeLocator;
 use crate::{flake8_quotes, pycodestyle, rules, Settings};
 
@@ -16,7 +17,8 @@ pub fn check_tokens(
     autofix: &fixer::Mode,
 ) {
     let enforce_ambiguous_unicode_character = settings.enabled.contains(&CheckCode::RUF001)
-        || settings.enabled.contains(&CheckCode::RUF002);
+        || settings.enabled.contains(&CheckCode::RUF002)
+        || settings.enabled.contains(&CheckCode::RUF003);
     let enforce_quotes = settings.enabled.contains(&CheckCode::Q000)
         || settings.enabled.contains(&CheckCode::Q001)
         || settings.enabled.contains(&CheckCode::Q002)
@@ -31,14 +33,22 @@ pub fn check_tokens(
             false
         };
 
-        // RUF001, RUF002
+        // RUF001, RUF002, RUF003
         if enforce_ambiguous_unicode_character {
-            if matches!(tok, Tok::String { .. }) {
+            if matches!(tok, Tok::String { .. } | Tok::Comment) {
                 for check in rules::checks::ambiguous_unicode_character(
                     locator,
                     start,
                     end,
-                    is_docstring,
+                    if matches!(tok, Tok::String { .. }) {
+                        if is_docstring {
+                            Context::Docstring
+                        } else {
+                            Context::String
+                        }
+                    } else {
+                        Context::Comment
+                    },
                     autofix.patch(),
                 ) {
                     if settings.enabled.contains(check.kind.code()) {

src/checks.rs

@@ -128,6 +128,7 @@ pub enum CheckCode {
     ANN204,
     ANN205,
     ANN206,
+    ANN401,
     // pyupgrade
     U001,
     U002,
@@ -138,6 +139,7 @@ pub enum CheckCode {
     U007,
     U008,
     U009,
+    U010,
     // pydocstyle
     D100,
     D101,
@@ -202,6 +204,7 @@ pub enum CheckCode {
     // Ruff
     RUF001,
     RUF002,
+    RUF003,
     // Meta
     M001,
 }
@@ -388,6 +391,7 @@ pub enum CheckKind {
     MissingReturnTypeMagicMethod(String),
     MissingReturnTypeStaticMethod(String),
     MissingReturnTypeClassMethod(String),
+    DynamicallyTypedExpression(String),
     // pyupgrade
     TypeOfPrimitive(Primitive),
     UnnecessaryAbspath,
@@ -398,6 +402,7 @@ pub enum CheckKind {
     UsePEP604Annotation,
     SuperCallWithParameters,
     PEP3120UnnecessaryCodingComment,
+    UnnecessaryFutureImport(String),
     // pydocstyle
     BlankLineAfterLastSection(String),
     BlankLineAfterSection(String),
@@ -462,6 +467,7 @@ pub enum CheckKind {
     // Ruff
     AmbiguousUnicodeCharacterString(char, char),
     AmbiguousUnicodeCharacterDocstring(char, char),
+    AmbiguousUnicodeCharacterComment(char, char),
     // Meta
     UnusedNOQA(Option<Vec<String>>),
 }
@@ -480,7 +486,8 @@ impl CheckCode {
             | CheckCode::Q003
             | CheckCode::W605
             | CheckCode::RUF001
-            | CheckCode::RUF002 => &LintSource::Tokens,
+            | CheckCode::RUF002
+            | CheckCode::RUF003 => &LintSource::Tokens,
             CheckCode::E902 => &LintSource::FileSystem,
             _ => &LintSource::AST,
         }
@@ -609,6 +616,7 @@ impl CheckCode {
             CheckCode::ANN204 => CheckKind::MissingReturnTypeMagicMethod("...".to_string()),
             CheckCode::ANN205 => CheckKind::MissingReturnTypeStaticMethod("...".to_string()),
             CheckCode::ANN206 => CheckKind::MissingReturnTypeClassMethod("...".to_string()),
+            CheckCode::ANN401 => CheckKind::DynamicallyTypedExpression("...".to_string()),
             // pyupgrade
             CheckCode::U001 => CheckKind::UselessMetaclassType,
             CheckCode::U002 => CheckKind::UnnecessaryAbspath,
@@ -622,6 +630,7 @@ impl CheckCode {
             CheckCode::U007 => CheckKind::UsePEP604Annotation,
             CheckCode::U008 => CheckKind::SuperCallWithParameters,
             CheckCode::U009 => CheckKind::PEP3120UnnecessaryCodingComment,
+            CheckCode::U010 => CheckKind::UnnecessaryFutureImport("...".to_string()),
             // pydocstyle
             CheckCode::D100 => CheckKind::PublicModule,
             CheckCode::D101 => CheckKind::PublicClass,
@@ -702,6 +711,7 @@ impl CheckCode {
             // Ruff
             CheckCode::RUF001 => CheckKind::AmbiguousUnicodeCharacterString('𝐁', 'B'),
             CheckCode::RUF002 => CheckKind::AmbiguousUnicodeCharacterDocstring('𝐁', 'B'),
+            CheckCode::RUF003 => CheckKind::AmbiguousUnicodeCharacterComment('𝐁', 'B'),
             // Meta
             CheckCode::M001 => CheckKind::UnusedNOQA(None),
         }
@@ -803,6 +813,7 @@ impl CheckCode {
             CheckCode::ANN204 => CheckCategory::Flake8Annotations,
             CheckCode::ANN205 => CheckCategory::Flake8Annotations,
             CheckCode::ANN206 => CheckCategory::Flake8Annotations,
+            CheckCode::ANN401 => CheckCategory::Flake8Annotations,
             CheckCode::U001 => CheckCategory::Pyupgrade,
             CheckCode::U002 => CheckCategory::Pyupgrade,
             CheckCode::U003 => CheckCategory::Pyupgrade,
@@ -812,6 +823,7 @@ impl CheckCode {
             CheckCode::U007 => CheckCategory::Pyupgrade,
             CheckCode::U008 => CheckCategory::Pyupgrade,
             CheckCode::U009 => CheckCategory::Pyupgrade,
+            CheckCode::U010 => CheckCategory::Pyupgrade,
             CheckCode::D100 => CheckCategory::Pydocstyle,
             CheckCode::D101 => CheckCategory::Pydocstyle,
             CheckCode::D102 => CheckCategory::Pydocstyle,
@@ -873,6 +885,7 @@ impl CheckCode {
             CheckCode::N818 => CheckCategory::PEP8Naming,
             CheckCode::RUF001 => CheckCategory::Ruff,
             CheckCode::RUF002 => CheckCategory::Ruff,
+            CheckCode::RUF003 => CheckCategory::Ruff,
             CheckCode::M001 => CheckCategory::Meta,
         }
     }
@@ -984,6 +997,7 @@ impl CheckKind {
             CheckKind::MissingReturnTypeMagicMethod(_) => &CheckCode::ANN204,
             CheckKind::MissingReturnTypeStaticMethod(_) => &CheckCode::ANN205,
             CheckKind::MissingReturnTypeClassMethod(_) => &CheckCode::ANN206,
+            CheckKind::DynamicallyTypedExpression(_) => &CheckCode::ANN401,
             // pyupgrade
             CheckKind::TypeOfPrimitive(_) => &CheckCode::U003,
             CheckKind::UnnecessaryAbspath => &CheckCode::U002,
@@ -994,6 +1008,7 @@ impl CheckKind {
             CheckKind::UselessObjectInheritance(_) => &CheckCode::U004,
             CheckKind::SuperCallWithParameters => &CheckCode::U008,
             CheckKind::PEP3120UnnecessaryCodingComment => &CheckCode::U009,
+            CheckKind::UnnecessaryFutureImport(_) => &CheckCode::U010,
             // pydocstyle
             CheckKind::BlankLineAfterLastSection(_) => &CheckCode::D413,
             CheckKind::BlankLineAfterSection(_) => &CheckCode::D410,
@@ -1058,6 +1073,7 @@ impl CheckKind {
             // Ruff
             CheckKind::AmbiguousUnicodeCharacterString(..) => &CheckCode::RUF001,
             CheckKind::AmbiguousUnicodeCharacterDocstring(..) => &CheckCode::RUF002,
+            CheckKind::AmbiguousUnicodeCharacterComment(..) => &CheckCode::RUF003,
             // Meta
             CheckKind::UnusedNOQA(_) => &CheckCode::M001,
         }
@@ -1405,6 +1421,9 @@ impl CheckKind {
             CheckKind::MissingReturnTypeClassMethod(name) => {
                 format!("Missing return type annotation for classmethod `{name}`")
             }
+            CheckKind::DynamicallyTypedExpression(name) => {
+                format!("Dynamically typed expressions (typing.Any) are disallowed in `{name}`")
+            }
             // pyupgrade
             CheckKind::TypeOfPrimitive(primitive) => {
                 format!("Use `{}` instead of `type(...)`", primitive.builtin())
@@ -1430,6 +1449,9 @@ impl CheckKind {
             CheckKind::SuperCallWithParameters => {
                 "Use `super()` instead of `super(__class__, self)`".to_string()
             }
+            CheckKind::UnnecessaryFutureImport(name) => {
+                format!("Unnessary __future__ import `{name}` for target Python version")
+            }
             // pydocstyle
             CheckKind::FitsOnOneLine => "One-line docstring should fit on one line".to_string(),
             CheckKind::BlankLineAfterSummary => {
@@ -1606,6 +1628,12 @@ impl CheckKind {
                      '{representant}'?)"
                 )
             }
+            CheckKind::AmbiguousUnicodeCharacterComment(confusable, representant) => {
+                format!(
+                    "Comment contains ambiguous unicode character '{confusable}' (did you mean \
+                     '{representant}'?)"
+                )
+            }
             // Meta
             CheckKind::UnusedNOQA(codes) => match codes {
                 None => "Unused `noqa` directive".to_string(),
@@ -1687,6 +1715,7 @@ impl CheckKind {
                 | CheckKind::UnnecessaryGeneratorSet
                 | CheckKind::UnnecessaryListCall
                 | CheckKind::UnnecessaryListComprehensionSet
+                | CheckKind::UnnecessaryListComprehensionDict
                 | CheckKind::UnnecessaryLiteralDict(_)
                 | CheckKind::UnnecessaryLiteralSet(_)
                 | CheckKind::UnnecessaryLiteralWithinListCall(_)

src/checks_gen.rs

@@ -30,6 +30,9 @@ pub enum CheckCodePrefix {
     ANN204,
     ANN205,
     ANN206,
+    ANN4,
+    ANN40,
+    ANN401,
     B,
     B0,
     B00,
@@ -233,6 +236,7 @@ pub enum CheckCodePrefix {
     RUF00,
     RUF001,
     RUF002,
+    RUF003,
     T,
     T2,
     T20,
@@ -250,6 +254,8 @@ pub enum CheckCodePrefix {
     U007,
     U008,
     U009,
+    U01,
+    U010,
     W,
     W2,
     W29,
@@ -287,6 +293,7 @@ impl CheckCodePrefix {
                 CheckCode::ANN204,
                 CheckCode::ANN205,
                 CheckCode::ANN206,
+                CheckCode::ANN401,
             ],
             CheckCodePrefix::ANN0 => vec![CheckCode::ANN001, CheckCode::ANN002, CheckCode::ANN003],
             CheckCodePrefix::ANN00 => vec![CheckCode::ANN001, CheckCode::ANN002, CheckCode::ANN003],
@@ -316,6 +323,9 @@ impl CheckCodePrefix {
             CheckCodePrefix::ANN204 => vec![CheckCode::ANN204],
             CheckCodePrefix::ANN205 => vec![CheckCode::ANN205],
             CheckCodePrefix::ANN206 => vec![CheckCode::ANN206],
+            CheckCodePrefix::ANN4 => vec![CheckCode::ANN401],
+            CheckCodePrefix::ANN40 => vec![CheckCode::ANN401],
+            CheckCodePrefix::ANN401 => vec![CheckCode::ANN401],
             CheckCodePrefix::B => vec![
                 CheckCode::B002,
                 CheckCode::B003,
@@ -926,11 +936,12 @@ impl CheckCodePrefix {
             CheckCodePrefix::Q001 => vec![CheckCode::Q001],
             CheckCodePrefix::Q002 => vec![CheckCode::Q002],
             CheckCodePrefix::Q003 => vec![CheckCode::Q003],
-            CheckCodePrefix::RUF => vec![CheckCode::RUF001, CheckCode::RUF002],
-            CheckCodePrefix::RUF0 => vec![CheckCode::RUF001, CheckCode::RUF002],
-            CheckCodePrefix::RUF00 => vec![CheckCode::RUF001, CheckCode::RUF002],
+            CheckCodePrefix::RUF => vec![CheckCode::RUF001, CheckCode::RUF002, CheckCode::RUF003],
+            CheckCodePrefix::RUF0 => vec![CheckCode::RUF001, CheckCode::RUF002, CheckCode::RUF003],
+            CheckCodePrefix::RUF00 => vec![CheckCode::RUF001, CheckCode::RUF002, CheckCode::RUF003],
             CheckCodePrefix::RUF001 => vec![CheckCode::RUF001],
             CheckCodePrefix::RUF002 => vec![CheckCode::RUF002],
+            CheckCodePrefix::RUF003 => vec![CheckCode::RUF003],
             CheckCodePrefix::T => vec![CheckCode::T201, CheckCode::T203],
             CheckCodePrefix::T2 => vec![CheckCode::T201, CheckCode::T203],
             CheckCodePrefix::T20 => vec![CheckCode::T201, CheckCode::T203],
@@ -946,6 +957,7 @@ impl CheckCodePrefix {
                 CheckCode::U007,
                 CheckCode::U008,
                 CheckCode::U009,
+                CheckCode::U010,
             ],
             CheckCodePrefix::U0 => vec![
                 CheckCode::U001,
@@ -957,6 +969,7 @@ impl CheckCodePrefix {
                 CheckCode::U007,
                 CheckCode::U008,
                 CheckCode::U009,
+                CheckCode::U010,
             ],
             CheckCodePrefix::U00 => vec![
                 CheckCode::U001,
@@ -978,6 +991,8 @@ impl CheckCodePrefix {
             CheckCodePrefix::U007 => vec![CheckCode::U007],
             CheckCodePrefix::U008 => vec![CheckCode::U008],
             CheckCodePrefix::U009 => vec![CheckCode::U009],
+            CheckCodePrefix::U01 => vec![CheckCode::U010],
+            CheckCodePrefix::U010 => vec![CheckCode::U010],
             CheckCodePrefix::W => vec![CheckCode::W292, CheckCode::W605],
             CheckCodePrefix::W2 => vec![CheckCode::W292],
             CheckCodePrefix::W29 => vec![CheckCode::W292],
@@ -1015,6 +1030,9 @@ impl CheckCodePrefix {
             CheckCodePrefix::ANN204 => PrefixSpecificity::Explicit,
             CheckCodePrefix::ANN205 => PrefixSpecificity::Explicit,
             CheckCodePrefix::ANN206 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::ANN4 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::ANN40 => PrefixSpecificity::Tens,
+            CheckCodePrefix::ANN401 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B => PrefixSpecificity::Category,
             CheckCodePrefix::B0 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::B00 => PrefixSpecificity::Tens,
@@ -1218,6 +1236,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::RUF00 => PrefixSpecificity::Tens,
             CheckCodePrefix::RUF001 => PrefixSpecificity::Explicit,
             CheckCodePrefix::RUF002 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::RUF003 => PrefixSpecificity::Explicit,
             CheckCodePrefix::T => PrefixSpecificity::Category,
             CheckCodePrefix::T2 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::T20 => PrefixSpecificity::Tens,
@@ -1235,6 +1254,8 @@ impl CheckCodePrefix {
             CheckCodePrefix::U007 => PrefixSpecificity::Explicit,
             CheckCodePrefix::U008 => PrefixSpecificity::Explicit,
             CheckCodePrefix::U009 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::U01 => PrefixSpecificity::Tens,
+            CheckCodePrefix::U010 => PrefixSpecificity::Explicit,
             CheckCodePrefix::W => PrefixSpecificity::Category,
             CheckCodePrefix::W2 => PrefixSpecificity::Hundreds,
             CheckCodePrefix::W29 => PrefixSpecificity::Tens,

src/flake8_annotations/mod.rs

@@ -45,6 +45,7 @@ mod tests {
                     CheckCode::ANN204,
                     CheckCode::ANN205,
                     CheckCode::ANN206,
+                    CheckCode::ANN401,
                 ])
             },
             &fixer::Mode::Generate,
@@ -63,6 +64,7 @@ mod tests {
                     mypy_init_return: false,
                     suppress_dummy_args: true,
                     suppress_none_returning: false,
+                    allow_star_arg_any: false,
                 },
                 ..Settings::for_rules(vec![
                     CheckCode::ANN001,
@@ -88,6 +90,7 @@ mod tests {
                     mypy_init_return: true,
                     suppress_dummy_args: false,
                     suppress_none_returning: false,
+                    allow_star_arg_any: false,
                 },
                 ..Settings::for_rules(vec![
                     CheckCode::ANN201,
@@ -113,6 +116,7 @@ mod tests {
                     mypy_init_return: false,
                     suppress_dummy_args: false,
                     suppress_none_returning: true,
+                    allow_star_arg_any: false,
                 },
                 ..Settings::for_rules(vec![
                     CheckCode::ANN201,
@@ -128,4 +132,24 @@ mod tests {
         insta::assert_yaml_snapshot!(checks);
         Ok(())
     }
+
+    #[test]
+    fn allow_star_arg_any() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/flake8_annotations/allow_star_arg_any.py"),
+            &Settings {
+                flake8_annotations: flake8_annotations::settings::Settings {
+                    mypy_init_return: false,
+                    suppress_dummy_args: false,
+                    suppress_none_returning: false,
+                    allow_star_arg_any: true,
+                },
+                ..Settings::for_rules(vec![CheckCode::ANN401])
+            },
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
 }

src/flake8_annotations/plugins.rs

@@ -48,6 +48,16 @@ fn is_none_returning(body: &[Stmt]) -> bool {
     true
 }
 
+/// ANN401
+fn check_dynamically_typed(checker: &mut Checker, annotation: &Expr, name: &str) {
+    if checker.match_typing_module(annotation, "Any") {
+        checker.add_check(Check::new(
+            CheckKind::DynamicallyTypedExpression(name.to_string()),
+            Range::from_located(annotation),
+        ));
+    };
+}
+
 fn match_function_def(stmt: &Stmt) -> (&str, &Arguments, &Option<Box<Expr>>, &Vec<Stmt>) {
     match &stmt.node {
         StmtKind::FunctionDef {
@@ -81,14 +91,18 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
         DefinitionKind::Function(stmt) | DefinitionKind::NestedFunction(stmt) => {
             let (name, args, returns, body) = match_function_def(stmt);
 
-            // ANN001
+            // ANN001, ANN401
             for arg in args
                 .args
                 .iter()
                 .chain(args.posonlyargs.iter())
                 .chain(args.kwonlyargs.iter())
             {
-                if arg.node.annotation.is_none() {
+                if let Some(expr) = &arg.node.annotation {
+                    if checker.settings.enabled.contains(&CheckCode::ANN401) {
+                        check_dynamically_typed(checker, expr, &arg.node.arg);
+                    };
+                } else {
                     if !(checker.settings.flake8_annotations.suppress_dummy_args
                         && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
                     {
@@ -102,9 +116,16 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
                 }
             }
 
-            // ANN002
+            // ANN002, ANN401
             if let Some(arg) = &args.vararg {
-                if arg.node.annotation.is_none() {
+                if let Some(expr) = &arg.node.annotation {
+                    if !checker.settings.flake8_annotations.allow_star_arg_any {
+                        if checker.settings.enabled.contains(&CheckCode::ANN401) {
+                            let name = arg.node.arg.to_string();
+                            check_dynamically_typed(checker, expr, &format!("*{name}"));
+                        }
+                    }
+                } else {
                     if !(checker.settings.flake8_annotations.suppress_dummy_args
                         && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
                     {
@@ -118,9 +139,16 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
                 }
             }
 
-            // ANN003
+            // ANN003, ANN401
             if let Some(arg) = &args.kwarg {
-                if arg.node.annotation.is_none() {
+                if let Some(expr) = &arg.node.annotation {
+                    if !checker.settings.flake8_annotations.allow_star_arg_any {
+                        if checker.settings.enabled.contains(&CheckCode::ANN401) {
+                            let name = arg.node.arg.to_string();
+                            check_dynamically_typed(checker, expr, &format!("**{name}"));
+                        }
+                    }
+                } else {
                     if !(checker.settings.flake8_annotations.suppress_dummy_args
                         && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
                     {
@@ -134,8 +162,12 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
                 }
             }
 
-            // ANN201, ANN202
-            if returns.is_none() {
+            // ANN201, ANN202, ANN401
+            if let Some(expr) = &returns {
+                if checker.settings.enabled.contains(&CheckCode::ANN401) {
+                    check_dynamically_typed(checker, expr, name);
+                };
+            } else {
                 // Allow omission of return annotation in `__init__` functions, if the function
                 // only returns `None` (explicitly or implicitly).
                 if checker.settings.flake8_annotations.suppress_none_returning
@@ -179,7 +211,13 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
                     usize::from(!visibility::is_staticmethod(stmt)),
                 )
             {
-                if arg.node.annotation.is_none() {
+                // ANN401 for dynamically typed arguments
+                if let Some(annotation) = &arg.node.annotation {
+                    has_any_typed_arg = true;
+                    if checker.settings.enabled.contains(&CheckCode::ANN401) {
+                        check_dynamically_typed(checker, annotation, &arg.node.arg);
+                    }
+                } else {
                     if !(checker.settings.flake8_annotations.suppress_dummy_args
                         && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
                     {
@@ -190,14 +228,20 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
                             ));
                         }
                     }
-                } else {
-                    has_any_typed_arg = true;
                 }
             }
 
-            // ANN002
+            // ANN002, ANN401
             if let Some(arg) = &args.vararg {
-                if arg.node.annotation.is_none() {
+                has_any_typed_arg = true;
+                if let Some(expr) = &arg.node.annotation {
+                    if !checker.settings.flake8_annotations.allow_star_arg_any {
+                        if checker.settings.enabled.contains(&CheckCode::ANN401) {
+                            let name = arg.node.arg.to_string();
+                            check_dynamically_typed(checker, expr, &format!("*{name}"));
+                        }
+                    }
+                } else {
                     if !(checker.settings.flake8_annotations.suppress_dummy_args
                         && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
                     {
@@ -208,14 +252,20 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
                             ));
                         }
                     }
-                } else {
-                    has_any_typed_arg = true;
                 }
             }
 
-            // ANN003
+            // ANN003, ANN401
             if let Some(arg) = &args.kwarg {
-                if arg.node.annotation.is_none() {
+                has_any_typed_arg = true;
+                if let Some(expr) = &arg.node.annotation {
+                    if !checker.settings.flake8_annotations.allow_star_arg_any {
+                        if checker.settings.enabled.contains(&CheckCode::ANN401) {
+                            let name = arg.node.arg.to_string();
+                            check_dynamically_typed(checker, expr, &format!("**{name}"));
+                        }
+                    }
+                } else {
                     if !(checker.settings.flake8_annotations.suppress_dummy_args
                         && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
                     {
@@ -226,8 +276,6 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
                             ));
                         }
                     }
-                } else {
-                    has_any_typed_arg = true;
                 }
             }
 
@@ -255,7 +303,11 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
             }
 
             // ANN201, ANN202
-            if returns.is_none() {
+            if let Some(expr) = &returns {
+                if checker.settings.enabled.contains(&CheckCode::ANN401) {
+                    check_dynamically_typed(checker, expr, name);
+                }
+            } else {
                 // Allow omission of return annotation in `__init__` functions, if the function
                 // only returns `None` (explicitly or implicitly).
                 if checker.settings.flake8_annotations.suppress_none_returning

src/flake8_annotations/settings.rs

@@ -16,6 +16,8 @@ pub struct Options {
     /// - Explicit `return` statement(s) all return `None` (explicitly or
     ///   implicitly).
     pub suppress_none_returning: Option<bool>,
+    /// Suppress ANN401 for dynamically typed *args and **kwargs.
+    pub allow_star_arg_any: Option<bool>,
 }
 
 #[derive(Debug, Hash, Default)]
@@ -23,6 +25,7 @@ pub struct Settings {
     pub mypy_init_return: bool,
     pub suppress_dummy_args: bool,
     pub suppress_none_returning: bool,
+    pub allow_star_arg_any: bool,
 }
 
 impl Settings {
@@ -31,6 +34,7 @@ impl Settings {
             mypy_init_return: options.mypy_init_return.unwrap_or_default(),
             suppress_dummy_args: options.suppress_dummy_args.unwrap_or_default(),
             suppress_none_returning: options.suppress_none_returning.unwrap_or_default(),
+            allow_star_arg_any: options.allow_star_arg_any.unwrap_or_default(),
         }
     }
 }

src/flake8_annotations/snapshots/ruff__flake8_annotations__tests__allow_star_arg_any.snap

@@ -0,0 +1,41 @@
+---
+source: src/flake8_annotations/mod.rs
+expression: checks
+---
+- kind:
+    DynamicallyTypedExpression: a
+  location:
+    row: 10
+    column: 11
+  end_location:
+    row: 10
+    column: 14
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: foo
+  location:
+    row: 15
+    column: 46
+  end_location:
+    row: 15
+    column: 49
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: a
+  location:
+    row: 40
+    column: 28
+  end_location:
+    row: 40
+    column: 31
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: foo_method
+  location:
+    row: 44
+    column: 66
+  end_location:
+    row: 44
+    column: 69
+  fix: ~
+

src/flake8_annotations/snapshots/ruff__flake8_annotations__tests__defaults.snap

@@ -75,21 +75,129 @@ expression: checks
     column: 0
   fix: ~
 - kind:
-    MissingTypeSelf: self
+    DynamicallyTypedExpression: a
   location:
     row: 44
-    column: 12
+    column: 11
   end_location:
     row: 44
+    column: 14
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: foo
+  location:
+    row: 49
+    column: 46
+  end_location:
+    row: 49
+    column: 49
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: "*args"
+  location:
+    row: 54
+    column: 23
+  end_location:
+    row: 54
+    column: 26
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: "**kwargs"
+  location:
+    row: 54
+    column: 38
+  end_location:
+    row: 54
+    column: 41
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: "*args"
+  location:
+    row: 59
+    column: 23
+  end_location:
+    row: 59
+    column: 26
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: "**kwargs"
+  location:
+    row: 64
+    column: 38
+  end_location:
+    row: 64
+    column: 41
+  fix: ~
+- kind:
+    MissingTypeSelf: self
+  location:
+    row: 74
+    column: 12
+  end_location:
+    row: 74
     column: 16
   fix: ~
+- kind:
+    DynamicallyTypedExpression: a
+  location:
+    row: 78
+    column: 28
+  end_location:
+    row: 78
+    column: 31
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: foo
+  location:
+    row: 82
+    column: 66
+  end_location:
+    row: 82
+    column: 69
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: "*params"
+  location:
+    row: 86
+    column: 42
+  end_location:
+    row: 86
+    column: 45
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: "**options"
+  location:
+    row: 86
+    column: 58
+  end_location:
+    row: 86
+    column: 61
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: "*params"
+  location:
+    row: 90
+    column: 42
+  end_location:
+    row: 90
+    column: 45
+  fix: ~
+- kind:
+    DynamicallyTypedExpression: "**options"
+  location:
+    row: 94
+    column: 58
+  end_location:
+    row: 94
+    column: 61
+  fix: ~
 - kind:
     MissingTypeCls: cls
   location:
-    row: 54
+    row: 104
     column: 12
   end_location:
-    row: 54
+    row: 104
     column: 15
   fix: ~
 

src/flake8_bugbear/plugins/useless_comparison.rs

@@ -5,10 +5,10 @@ use crate::check_ast::Checker;
 use crate::checks::{Check, CheckKind};
 
 pub fn useless_comparison(checker: &mut Checker, expr: &Expr) {
-    if let ExprKind::Compare { left, .. } = &expr.node {
+    if matches!(expr.node, ExprKind::Compare { .. }) {
         checker.add_check(Check::new(
             CheckKind::UselessComparison,
-            Range::from_located(left),
+            Range::from_located(expr),
         ));
     }
 }

src/flake8_comprehensions/checks.rs

@@ -149,19 +149,26 @@ pub fn unnecessary_list_comprehension_set(
 
 /// C404 (`dict([...])`)
 pub fn unnecessary_list_comprehension_dict(
+    expr: &Expr,
     func: &Expr,
     args: &[Expr],
     keywords: &[Keyword],
+    locator: &SourceCodeLocator,
+    fix: bool,
     location: Range,
 ) -> Option<Check> {
     let argument = exactly_one_argument_with_matching_function("dict", func, args, keywords)?;
     if let ExprKind::ListComp { elt, .. } = &argument {
         match &elt.node {
             ExprKind::Tuple { elts, .. } if elts.len() == 2 => {
-                return Some(Check::new(
-                    CheckKind::UnnecessaryListComprehensionDict,
-                    location,
-                ));
+                let mut check = Check::new(CheckKind::UnnecessaryListComprehensionDict, location);
+                if fix {
+                    match fixes::fix_unnecessary_list_comprehension_dict(locator, expr) {
+                        Ok(fix) => check.amend(fix),
+                        Err(e) => error!("Failed to generate fix: {}", e),
+                    }
+                }
+                return Some(check);
             }
             _ => {}
         }

src/flake8_comprehensions/fixes.rs

@@ -220,6 +220,64 @@ pub fn fix_unnecessary_list_comprehension_set(
     ))
 }
 
+/// (C404) Convert `dict([(i, i) for i in range(3)])` to `{i: i for i in
+/// range(3)}`.
+pub fn fix_unnecessary_list_comprehension_dict(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    let module_text = locator.slice_source_code_range(&Range::from_located(expr));
+    let mut tree = match_module(&module_text)?;
+    let mut body = match_expr(&mut tree)?;
+    let call = match_call(body)?;
+    let arg = match_arg(call)?;
+
+    let list_comp = if let Expression::ListComp(list_comp) = &arg.value {
+        list_comp
+    } else {
+        return Err(anyhow::anyhow!("Expected node to be: Expression::ListComp"));
+    };
+
+    let tuple = if let Expression::Tuple(tuple) = &*list_comp.elt {
+        tuple
+    } else {
+        return Err(anyhow::anyhow!("Expected node to be: Expression::Tuple"));
+    };
+
+    let (key, comma, value) = match &tuple.elements[..] {
+        [Element::Simple {
+            value: key,
+            comma: Some(comma),
+        }, Element::Simple { value, .. }] => (key, comma, value),
+        _ => return Err(anyhow::anyhow!("Expected tuple with two elements")),
+    };
+
+    body.value = Expression::DictComp(Box::new(DictComp {
+        key: Box::new(key.clone()),
+        value: Box::new(value.clone()),
+        for_in: list_comp.for_in.clone(),
+        whitespace_before_colon: comma.whitespace_before.clone(),
+        whitespace_after_colon: comma.whitespace_after.clone(),
+        lbrace: LeftCurlyBrace {
+            whitespace_after: call.whitespace_before_args.clone(),
+        },
+        rbrace: RightCurlyBrace {
+            whitespace_before: arg.whitespace_after_arg.clone(),
+        },
+        lpar: list_comp.lpar.clone(),
+        rpar: list_comp.rpar.clone(),
+    }));
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
 /// (C405) Convert `set((1, 2))` to `{1, 2}`.
 pub fn fix_unnecessary_literal_set(
     locator: &SourceCodeLocator,

src/linter.rs

@@ -445,6 +445,7 @@ mod tests {
     #[test_case(CheckCode::U009, Path::new("U009_1.py"); "U009_1")]
     #[test_case(CheckCode::U009, Path::new("U009_2.py"); "U009_2")]
     #[test_case(CheckCode::U009, Path::new("U009_3.py"); "U009_3")]
+    #[test_case(CheckCode::U010, Path::new("U010.py"); "U010")]
     #[test_case(CheckCode::W292, Path::new("W292_0.py"); "W292_0")]
     #[test_case(CheckCode::W292, Path::new("W292_1.py"); "W292_1")]
     #[test_case(CheckCode::W292, Path::new("W292_2.py"); "W292_2")]
@@ -452,6 +453,7 @@ mod tests {
     #[test_case(CheckCode::W605, Path::new("W605_1.py"); "W605_1")]
     #[test_case(CheckCode::RUF001, Path::new("RUF001.py"); "RUF001")]
     #[test_case(CheckCode::RUF002, Path::new("RUF002.py"); "RUF002")]
+    #[test_case(CheckCode::RUF003, Path::new("RUF003.py"); "RUF003")]
     fn checks(check_code: CheckCode, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", check_code.as_ref(), path.to_string_lossy());
         let mut checks = check_path(

src/pyupgrade/checks.rs

@@ -4,6 +4,30 @@ use crate::ast::helpers;
 use crate::ast::types::{Binding, BindingKind, Range, Scope, ScopeKind};
 use crate::checks::{Check, CheckKind};
 use crate::pyupgrade::types::Primitive;
+use crate::settings::types::PythonVersion;
+
+pub const PY33_PLUS_REMOVE_FUTURES: &[&str] = &[
+    "nested_scopes",
+    "generators",
+    "with_statement",
+    "division",
+    "absolute_import",
+    "with_statement",
+    "print_function",
+    "unicode_literals",
+];
+
+pub const PY37_PLUS_REMOVE_FUTURES: &[&str] = &[
+    "nested_scopes",
+    "generators",
+    "with_statement",
+    "division",
+    "absolute_import",
+    "with_statement",
+    "print_function",
+    "unicode_literals",
+    "generator_stop",
+];
 
 /// U008
 pub fn super_args(
@@ -155,3 +179,20 @@ pub fn type_of_primitive(func: &Expr, args: &[Expr], location: Range) -> Option<
 
     None
 }
+
+/// U010
+pub fn unnecessary_future_import(
+    version: PythonVersion,
+    name: &str,
+    location: Range,
+) -> Option<Check> {
+    if (version >= PythonVersion::Py33 && PY33_PLUS_REMOVE_FUTURES.contains(&name))
+        || (version >= PythonVersion::Py37 && PY37_PLUS_REMOVE_FUTURES.contains(&name))
+    {
+        return Some(Check::new(
+            CheckKind::UnnecessaryFutureImport(name.to_string()),
+            location,
+        ));
+    }
+    None
+}

src/pyupgrade/plugins/mod.rs

@@ -2,6 +2,7 @@ pub use deprecated_unittest_alias::deprecated_unittest_alias;
 pub use super_call_with_parameters::super_call_with_parameters;
 pub use type_of_primitive::type_of_primitive;
 pub use unnecessary_abspath::unnecessary_abspath;
+pub use unnecessary_future_import::unnecessary_future_import;
 pub use use_pep585_annotation::use_pep585_annotation;
 pub use use_pep604_annotation::use_pep604_annotation;
 pub use useless_metaclass_type::useless_metaclass_type;
@@ -11,6 +12,7 @@ mod deprecated_unittest_alias;
 mod super_call_with_parameters;
 mod type_of_primitive;
 mod unnecessary_abspath;
+mod unnecessary_future_import;
 mod use_pep585_annotation;
 mod use_pep604_annotation;
 mod useless_metaclass_type;

src/pyupgrade/plugins/unnecessary_future_import.rs

@@ -0,0 +1,15 @@
+use rustpython_parser::ast::Stmt;
+
+use crate::ast::types::Range;
+use crate::check_ast::Checker;
+use crate::pyupgrade::checks;
+
+pub fn unnecessary_future_import(checker: &mut Checker, stmt: &Stmt, name: &str) {
+    if let Some(check) = checks::unnecessary_future_import(
+        checker.settings.target_version,
+        name,
+        Range::from_located(stmt),
+    ) {
+        checker.add_check(check);
+    }
+}

src/rules/checks.rs

@@ -1596,11 +1596,17 @@ static CONFUSABLES: Lazy<BTreeMap<u32, u32>> = Lazy::new(|| {
     ])
 });
 
+pub enum Context {
+    String,
+    Docstring,
+    Comment,
+}
+
 pub fn ambiguous_unicode_character(
     locator: &SourceCodeLocator,
     start: &Location,
     end: &Location,
-    is_docstring: bool,
+    context: Context,
     fix: bool,
 ) -> Vec<Check> {
     let mut checks = vec![];
@@ -1623,10 +1629,17 @@ pub fn ambiguous_unicode_character(
                 };
                 let end_location = Location::new(location.row(), location.column() + 1);
                 let mut check = Check::new(
-                    if is_docstring {
-                        CheckKind::AmbiguousUnicodeCharacterDocstring(current_char, representant)
-                    } else {
-                        CheckKind::AmbiguousUnicodeCharacterString(current_char, representant)
+                    match context {
+                        Context::String => {
+                            CheckKind::AmbiguousUnicodeCharacterString(current_char, representant)
+                        }
+                        Context::Docstring => CheckKind::AmbiguousUnicodeCharacterDocstring(
+                            current_char,
+                            representant,
+                        ),
+                        Context::Comment => {
+                            CheckKind::AmbiguousUnicodeCharacterComment(current_char, representant)
+                        }
                     },
                     Range {
                         location,

src/settings/types.rs

@@ -11,7 +11,7 @@ use crate::checks::CheckCode;
 use crate::checks_gen::CheckCodePrefix;
 use crate::fs;
 
-#[derive(Clone, Debug, PartialOrd, PartialEq, Eq, Serialize, Deserialize, Hash)]
+#[derive(Clone, Copy, Debug, PartialOrd, PartialEq, Eq, Serialize, Deserialize, Hash)]
 #[serde(rename_all = "lowercase")]
 pub enum PythonVersion {
     Py33,

src/snapshots/ruff__linter__tests__B015_B015.py.snap

@@ -8,7 +8,7 @@ expression: checks
     column: 0
   end_location:
     row: 3
-    column: 1
+    column: 6
   fix: ~
 - kind: UselessComparison
   location:
@@ -16,7 +16,7 @@ expression: checks
     column: 0
   end_location:
     row: 7
-    column: 1
+    column: 11
   fix: ~
 - kind: UselessComparison
   location:
@@ -24,7 +24,7 @@ expression: checks
     column: 4
   end_location:
     row: 17
-    column: 5
+    column: 15
   fix: ~
 - kind: UselessComparison
   location:
@@ -32,6 +32,6 @@ expression: checks
     column: 4
   end_location:
     row: 24
-    column: 5
+    column: 10
   fix: ~
 

src/snapshots/ruff__linter__tests__C404_C404.py.snap

@@ -9,5 +9,14 @@ expression: checks
   end_location:
     row: 1
     column: 32
-  fix: ~
+  fix:
+    patch:
+      content: "{i: i for i in range(3)}"
+      location:
+        row: 1
+        column: 0
+      end_location:
+        row: 1
+        column: 32
+    applied: false
 

src/snapshots/ruff__linter__tests__E713_E713.py.snap

@@ -5,7 +5,7 @@ expression: checks
 - kind: NotInTest
   location:
     row: 2
-    column: 9
+    column: 7
   end_location:
     row: 2
     column: 13
@@ -13,7 +13,7 @@ expression: checks
 - kind: NotInTest
   location:
     row: 5
-    column: 11
+    column: 7
   end_location:
     row: 5
     column: 15
@@ -21,7 +21,7 @@ expression: checks
 - kind: NotInTest
   location:
     row: 8
-    column: 9
+    column: 7
   end_location:
     row: 8
     column: 13
@@ -29,7 +29,7 @@ expression: checks
 - kind: NotInTest
   location:
     row: 11
-    column: 24
+    column: 22
   end_location:
     row: 11
     column: 28
@@ -37,7 +37,7 @@ expression: checks
 - kind: NotInTest
   location:
     row: 14
-    column: 10
+    column: 8
   end_location:
     row: 14
     column: 14

src/snapshots/ruff__linter__tests__E714_E714.py.snap

@@ -5,7 +5,7 @@ expression: checks
 - kind: NotIsTest
   location:
     row: 2
-    column: 9
+    column: 7
   end_location:
     row: 2
     column: 13
@@ -13,7 +13,7 @@ expression: checks
 - kind: NotIsTest
   location:
     row: 5
-    column: 11
+    column: 7
   end_location:
     row: 5
     column: 15
@@ -21,7 +21,7 @@ expression: checks
 - kind: NotIsTest
   location:
     row: 8
-    column: 9
+    column: 7
   end_location:
     row: 8
     column: 22

src/snapshots/ruff__linter__tests__E721_E721.py.snap

@@ -5,7 +5,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 2
-    column: 13
+    column: 3
   end_location:
     row: 2
     column: 24
@@ -13,7 +13,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 5
-    column: 13
+    column: 3
   end_location:
     row: 5
     column: 24
@@ -21,7 +21,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 10
-    column: 7
+    column: 3
   end_location:
     row: 10
     column: 23
@@ -29,7 +29,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 15
-    column: 13
+    column: 3
   end_location:
     row: 15
     column: 34
@@ -37,7 +37,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 18
-    column: 17
+    column: 7
   end_location:
     row: 18
     column: 31
@@ -45,7 +45,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 18
-    column: 45
+    column: 35
   end_location:
     row: 18
     column: 58
@@ -53,7 +53,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 20
-    column: 17
+    column: 7
   end_location:
     row: 20
     column: 28
@@ -61,7 +61,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 22
-    column: 17
+    column: 7
   end_location:
     row: 22
     column: 28
@@ -69,7 +69,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 24
-    column: 17
+    column: 7
   end_location:
     row: 24
     column: 30
@@ -77,7 +77,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 26
-    column: 17
+    column: 7
   end_location:
     row: 26
     column: 29
@@ -85,7 +85,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 28
-    column: 17
+    column: 7
   end_location:
     row: 28
     column: 30
@@ -93,7 +93,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 30
-    column: 17
+    column: 7
   end_location:
     row: 30
     column: 30
@@ -101,7 +101,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 32
-    column: 17
+    column: 7
   end_location:
     row: 32
     column: 34
@@ -109,7 +109,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 34
-    column: 17
+    column: 7
   end_location:
     row: 38
     column: 1
@@ -117,7 +117,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 40
-    column: 17
+    column: 7
   end_location:
     row: 40
     column: 28
@@ -125,7 +125,7 @@ expression: checks
 - kind: TypeComparison
   location:
     row: 42
-    column: 17
+    column: 7
   end_location:
     row: 42
     column: 30

src/snapshots/ruff__linter__tests__F632_F632.py.snap

@@ -5,7 +5,7 @@ expression: checks
 - kind: IsLiteral
   location:
     row: 1
-    column: 5
+    column: 3
   end_location:
     row: 1
     column: 13
@@ -22,7 +22,7 @@ expression: checks
 - kind: IsLiteral
   location:
     row: 4
-    column: 7
+    column: 3
   end_location:
     row: 4
     column: 15
@@ -39,7 +39,7 @@ expression: checks
 - kind: IsLiteral
   location:
     row: 7
-    column: 9
+    column: 3
   end_location:
     row: 7
     column: 17

src/snapshots/ruff__linter__tests__RUF002_RUF002.py.snap

@@ -8,18 +8,18 @@ expression: checks
       - )
   location:
     row: 5
-    column: 53
+    column: 55
   end_location:
     row: 5
-    column: 54
+    column: 56
   fix:
     patch:
       content: )
       location:
         row: 5
-        column: 53
+        column: 55
       end_location:
         row: 5
-        column: 54
+        column: 56
     applied: false
 

src/snapshots/ruff__linter__tests__RUF003_RUF003.py.snap

@@ -0,0 +1,25 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    AmbiguousUnicodeCharacterComment:
+      - ᜵
+      - /
+  location:
+    row: 6
+    column: 61
+  end_location:
+    row: 6
+    column: 62
+  fix:
+    patch:
+      content: /
+      location:
+        row: 6
+        column: 61
+      end_location:
+        row: 6
+        column: 62
+    applied: false
+

src/snapshots/ruff__linter__tests__U004_U004.py.snap

@@ -269,7 +269,7 @@ expression: checks
         row: 98
         column: 4
       end_location:
-        row: 100
+        row: 99
         column: 4
     applied: false
 - kind:

src/snapshots/ruff__linter__tests__U010_U010.py.snap

@@ -0,0 +1,50 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UnnecessaryFutureImport: nested_scopes
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 1
+    column: 61
+  fix: ~
+- kind:
+    UnnecessaryFutureImport: generators
+  location:
+    row: 1
+    column: 0
+  end_location:
+    row: 1
+    column: 61
+  fix: ~
+- kind:
+    UnnecessaryFutureImport: absolute_import
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 48
+  fix: ~
+- kind:
+    UnnecessaryFutureImport: division
+  location:
+    row: 3
+    column: 0
+  end_location:
+    row: 3
+    column: 48
+  fix: ~
+- kind:
+    UnnecessaryFutureImport: generator_stop
+  location:
+    row: 5
+    column: 0
+  end_location:
+    row: 5
+    column: 37
+  fix: ~
+