Implement flake8-future-annotations FA100

README.md

@@ -262,6 +262,7 @@ quality tools, including:
 - [flake8-eradicate](https://pypi.org/project/flake8-eradicate/)
 - [flake8-errmsg](https://pypi.org/project/flake8-errmsg/)
 - [flake8-executable](https://pypi.org/project/flake8-executable/)
+- [flake8-future-annotations](https://pypi.org/project/flake8-future-annotations/)
 - [flake8-gettext](https://pypi.org/project/flake8-gettext/)
 - [flake8-implicit-str-concat](https://pypi.org/project/flake8-implicit-str-concat/)
 - [flake8-import-conventions](https://github.com/joaopalmeiro/flake8-import-conventions)

crates/ruff/resources/test/fixtures/flake8_future_annotations/edge_case.py

@@ -0,0 +1,7 @@
+from typing import List
+import typing as t
+
+
+def main(_: List[int]) -> None:
+    a_list: t.List[str] = []
+    a_list.append("hello")

crates/ruff/resources/test/fixtures/flake8_future_annotations/from_typing_import.py

@@ -0,0 +1,6 @@
+from typing import List
+
+
+def main() -> None:
+    a_list: List[str] = []
+    a_list.append("hello")

crates/ruff/resources/test/fixtures/flake8_future_annotations/from_typing_import_many.py

@@ -0,0 +1,8 @@
+from typing import Dict, List, Optional, Set, Union, cast
+
+
+def main() -> None:
+    a_list: List[Optional[str]] = []
+    a_list.append("hello")
+    a_dict = cast(Dict[int | None, Union[int, Set[bool]]], {})
+    a_dict[1] = {True, False}

crates/ruff/resources/test/fixtures/flake8_future_annotations/import_typing.py

@@ -0,0 +1,6 @@
+import typing
+
+
+def main() -> None:
+    a_list: typing.List[str] = []
+    a_list.append("hello")

crates/ruff/resources/test/fixtures/flake8_future_annotations/import_typing_as.py

@@ -0,0 +1,6 @@
+import typing as t
+
+
+def main() -> None:
+    a_list: t.List[str] = []
+    a_list.append("hello")

crates/ruff/resources/test/fixtures/flake8_future_annotations/no_future_import_uses_lowercase.py

@@ -0,0 +1,7 @@
+def main() -> None:
+    a_list: list[str] = []
+    a_list.append("hello")
+
+
+def hello(y: dict[str, int]) -> None:
+    del y

crates/ruff/resources/test/fixtures/flake8_future_annotations/no_future_import_uses_union.py

@@ -0,0 +1,7 @@
+def main() -> None:
+    a_list: list[str] | None = []
+    a_list.append("hello")
+
+
+def hello(y: dict[str, int] | None) -> None:
+    del y

crates/ruff/resources/test/fixtures/flake8_future_annotations/no_future_import_uses_union_inner.py

@@ -0,0 +1,8 @@
+def main() -> None:
+    a_list: list[str | None] = []
+    a_list.append("hello")
+
+
+def hello(y: dict[str | None, int]) -> None:
+    z: tuple[str, str | None, str] = tuple(y)
+    del z

crates/ruff/resources/test/fixtures/flake8_future_annotations/ok_no_types.py

@@ -0,0 +1,3 @@
+def main() -> str:
+    a_str = "hello"
+    return a_str

crates/ruff/resources/test/fixtures/flake8_future_annotations/ok_non_simplifiable_types.py

@@ -0,0 +1,10 @@
+from typing import NamedTuple
+
+
+class Stuff(NamedTuple):
+    x: int
+
+
+def main() -> None:
+    a_list = Stuff(5)
+    print(a_list)

crates/ruff/resources/test/fixtures/flake8_future_annotations/ok_uses_future.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+
+def main() -> None:
+    a_list: list[str] = []
+    a_list.append("hello")

crates/ruff/resources/test/fixtures/flake8_future_annotations/ok_variable_name.py

@@ -0,0 +1,8 @@
+import typing
+
+IRRELEVANT = typing.TypeVar
+
+
+def main() -> None:
+    List: list[str] = []
+    List.append("hello")

crates/ruff/src/checkers/ast/mod.rs

@@ -40,12 +40,12 @@ use crate::registry::{AsRule, Rule};
 use crate::rules::{
     flake8_2020, flake8_annotations, flake8_bandit, flake8_blind_except, flake8_boolean_trap,
     flake8_bugbear, flake8_builtins, flake8_comprehensions, flake8_datetimez, flake8_debugger,
-    flake8_django, flake8_errmsg, flake8_gettext, flake8_implicit_str_concat,
-    flake8_import_conventions, flake8_logging_format, flake8_pie, flake8_print, flake8_pyi,
-    flake8_pytest_style, flake8_raise, flake8_return, flake8_self, flake8_simplify,
-    flake8_tidy_imports, flake8_type_checking, flake8_unused_arguments, flake8_use_pathlib, mccabe,
-    numpy, pandas_vet, pep8_naming, pycodestyle, pydocstyle, pyflakes, pygrep_hooks, pylint,
-    pyupgrade, ruff, tryceratops,
+    flake8_django, flake8_errmsg, flake8_future_annotations, flake8_gettext,
+    flake8_implicit_str_concat, flake8_import_conventions, flake8_logging_format, flake8_pie,
+    flake8_print, flake8_pyi, flake8_pytest_style, flake8_raise, flake8_return, flake8_self,
+    flake8_simplify, flake8_tidy_imports, flake8_type_checking, flake8_unused_arguments,
+    flake8_use_pathlib, mccabe, numpy, pandas_vet, pep8_naming, pycodestyle, pydocstyle, pyflakes,
+    pygrep_hooks, pylint, pyupgrade, ruff, tryceratops,
 };
 use crate::settings::types::PythonVersion;
 use crate::settings::{flags, Settings};
@@ -1167,7 +1167,20 @@ where
                         pyupgrade::rules::unnecessary_builtin_import(self, stmt, module, names);
                     }
                 }
-
+                if self
+                    .settings
+                    .rules
+                    .enabled(Rule::MissingFutureAnnotationsWithImports)
+                {
+                    if let Some(module) = module.as_deref() {
+                        flake8_future_annotations::rules::check_missing_future_annotations_from_typing_import(
+                            self,
+                            stmt,
+                            module,
+                            names,
+                        );
+                    }
+                }
                 if self.settings.rules.enabled(Rule::BannedApi) {
                     if let Some(module) = helpers::resolve_imported_module_path(
                         *level,
@@ -2416,6 +2429,16 @@ where
                 if self.settings.rules.enabled(Rule::BannedApi) {
                     flake8_tidy_imports::banned_api::banned_attribute_access(self, expr);
                 }
+                if self
+                    .settings
+                    .rules
+                    .enabled(Rule::MissingFutureAnnotationsWithImports)
+                    && analyze::typing::is_pep585_builtin(expr, &self.ctx)
+                {
+                    flake8_future_annotations::rules::check_missing_future_annotations_import(
+                        self, expr,
+                    );
+                }
                 if self.settings.rules.enabled(Rule::PrivateMemberAccess) {
                     flake8_self::rules::private_member_access(self, expr);
                 }

crates/ruff/src/codes.rs

@@ -327,6 +327,9 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<Rule> {
         (Flake8Annotations, "206") => Rule::MissingReturnTypeClassMethod,
         (Flake8Annotations, "401") => Rule::AnyType,
 
+        // flake8-future-annotations
+        (Flake8FutureAnnotations, "100") => Rule::MissingFutureAnnotationsWithImports,
+
         // flake8-2020
         (Flake82020, "101") => Rule::SysVersionSlice3,
         (Flake82020, "102") => Rule::SysVersion2,

crates/ruff/src/registry.rs

@@ -287,6 +287,8 @@ ruff_macros::register_rules!(
     rules::flake8_annotations::rules::MissingReturnTypeStaticMethod,
     rules::flake8_annotations::rules::MissingReturnTypeClassMethod,
     rules::flake8_annotations::rules::AnyType,
+    // flake8-future-annotations
+    rules::flake8_future_annotations::rules::MissingFutureAnnotationsWithImports,
     // flake8-2020
     rules::flake8_2020::rules::SysVersionSlice3,
     rules::flake8_2020::rules::SysVersion2,
@@ -752,6 +754,9 @@ pub enum Linter {
     /// [flake8-executable](https://pypi.org/project/flake8-executable/)
     #[prefix = "EXE"]
     Flake8Executable,
+    /// [flake8-future-annotations](https://pypi.org/project/flake8-future-annotations/)
+    #[prefix = "FA"]
+    Flake8FutureAnnotations,
     /// [flake8-implicit-str-concat](https://pypi.org/project/flake8-implicit-str-concat/)
     #[prefix = "ISC"]
     Flake8ImplicitStrConcat,

crates/ruff/src/rules/flake8_future_annotations/mod.rs

@@ -0,0 +1,36 @@
+//! Rules from [flake8-future-annotations](https://pypi.org/project/flake8-future-annotations/).
+pub(crate) mod rules;
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use anyhow::Result;
+    use test_case::test_case;
+
+    use crate::registry::Rule;
+    use crate::test::test_path;
+    use crate::{assert_messages, settings};
+
+    #[test_case(Path::new("edge_case.py"); "edge_case")]
+    #[test_case(Path::new("from_typing_import.py"); "from_typing_import")]
+    #[test_case(Path::new("from_typing_import_many.py"); "from_typing_import_many")]
+    #[test_case(Path::new("import_typing.py"); "import_typing")]
+    #[test_case(Path::new("import_typing_as.py"); "import_typing_as")]
+    #[test_case(Path::new("no_future_import_uses_lowercase.py"); "no_future_import_uses_lowercase")]
+    #[test_case(Path::new("no_future_import_uses_union.py"); "no_future_import_uses_union")]
+    #[test_case(Path::new("no_future_import_uses_union_inner.py"); "no_future_import_uses_union_inner")]
+    #[test_case(Path::new("ok_no_types.py"); "ok_no_types")]
+    #[test_case(Path::new("ok_non_simplifiable_types.py"); "ok_non_simplifiable_types")]
+    #[test_case(Path::new("ok_uses_future.py"); "ok_uses_future")]
+    #[test_case(Path::new("ok_variable_name.py"); "ok_variable_name")]
+    fn rules(path: &Path) -> Result<()> {
+        let snapshot = path.to_string_lossy().into_owned();
+        let diagnostics = test_path(
+            Path::new("flake8_future_annotations").join(path).as_path(),
+            &settings::Settings::for_rules(vec![Rule::MissingFutureAnnotationsWithImports]),
+        )?;
+        assert_messages!(snapshot, diagnostics);
+        Ok(())
+    }
+}

crates/ruff/src/rules/flake8_future_annotations/rules.rs

@@ -0,0 +1,113 @@
+use crate::checkers::ast::Checker;
+use itertools::Itertools;
+use ruff_diagnostics::{Diagnostic, Violation};
+use ruff_macros::{derive_message_formats, violation};
+use ruff_python_ast::types::Range;
+use rustpython_parser::ast::{AliasData, Expr, Located, Stmt};
+
+/// ## What it does
+/// Checks for missing `from __future__ import annotations` import if a type used in the
+/// module can be rewritten using PEP 563.
+///
+/// ## Why is this bad?
+///
+/// Pairs well with pyupgrade with the --py37-plus flag or higher, since pyupgrade only
+/// replaces type annotations with the PEP 563 rules if `from __future__ import annotations`
+/// is present.
+///
+/// ## Example
+/// ```python
+/// import typing as t
+/// from typing import List
+///
+/// def function(a_dict: t.Dict[str, t.Optional[int]]) -> None:
+///     a_list: List[str] = []
+///     a_list.append("hello")
+/// ```
+///
+/// To fix the lint error:
+/// ```python
+/// from __future__ import annotations
+///
+/// import typing as t
+/// from typing import List
+///
+/// def function(a_dict: t.Dict[str, t.Optional[int]]) -> None:
+///     a_list: List[str] = []
+///     a_list.append("hello")
+/// ```
+///
+/// After running additional pyupgrade autofixes:
+/// ```python
+/// from __future__ import annotations
+///
+/// def function(a_dict: dict[str, int | None]) -> None:
+///     a_list: list[str] = []
+///     a_list.append("hello")
+/// ```
+#[violation]
+pub struct MissingFutureAnnotationsWithImports {
+    pub names: Vec<String>,
+}
+
+impl Violation for MissingFutureAnnotationsWithImports {
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        let MissingFutureAnnotationsWithImports { names } = self;
+        let names = names.iter().map(|name| format!("`{name}`")).join(", ");
+        format!("Missing from __future__ import annotations but imports: {names}")
+    }
+}
+
+// PEP_593_SUBSCRIPTS
+pub const FUTURE_ANNOTATIONS_REWRITE_ELIGIBLE: &[&[&str]] = &[
+    &["typing", "DefaultDict"],
+    &["typing", "Deque"],
+    &["typing", "Dict"],
+    &["typing", "FrozenSet"],
+    &["typing", "List"],
+    &["typing", "Optional"],
+    &["typing", "Set"],
+    &["typing", "Tuple"],
+    &["typing", "Type"],
+    &["typing", "Union"],
+    &["typing_extensions", "Type"],
+];
+
+/// FA100
+pub fn check_missing_future_annotations_from_typing_import(
+    checker: &mut Checker,
+    stmt: &Stmt,
+    module: &str,
+    names: &[Located<AliasData>],
+) {
+    let result: Vec<String> = names
+        .iter()
+        .map(|name| name.node.name.as_str())
+        .filter(|alias| FUTURE_ANNOTATIONS_REWRITE_ELIGIBLE.contains(&[module, alias].as_slice()))
+        .map(std::string::ToString::to_string)
+        .sorted()
+        .collect();
+
+    if !checker.ctx.annotations_future_enabled && !result.is_empty() {
+        checker.diagnostics.push(Diagnostic::new(
+            MissingFutureAnnotationsWithImports { names: result },
+            Range::from(stmt),
+        ));
+    }
+}
+
+pub fn check_missing_future_annotations_import(checker: &mut Checker, expr: &Expr) {
+    if let Some(binding) = checker.ctx.resolve_call_path(expr) {
+        if !checker.ctx.annotations_future_enabled
+            && FUTURE_ANNOTATIONS_REWRITE_ELIGIBLE.contains(&binding.as_slice())
+        {
+            checker.diagnostics.push(Diagnostic::new(
+                MissingFutureAnnotationsWithImports {
+                    names: vec![binding.iter().join(".")],
+                },
+                Range::from(expr),
+            ));
+        }
+    }
+}

crates/ruff/src/rules/flake8_future_annotations/snapshots/ruff__rules__flake8_future_annotations__tests__edge_case.py.snap

@@ -0,0 +1,19 @@
+---
+source: crates/ruff/src/rules/flake8_future_annotations/mod.rs
+---
+edge_case.py:1:1: FA100 Missing from __future__ import annotations but imports: `List`
+  |
+1 | from typing import List
+  | ^^^^^^^^^^^^^^^^^^^^^^^ FA100
+2 | import typing as t
+  |
+
+edge_case.py:6:13: FA100 Missing from __future__ import annotations but imports: `typing.List`
+  |
+6 | def main(_: List[int]) -> None:
+7 |     a_list: t.List[str] = []
+  |             ^^^^^^ FA100
+8 |     a_list.append("hello")
+  |
+
+

crates/ruff/src/rules/flake8_future_annotations/snapshots/ruff__rules__flake8_future_annotations__tests__from_typing_import.py.snap

@@ -0,0 +1,10 @@
+---
+source: crates/ruff/src/rules/flake8_future_annotations/mod.rs
+---
+from_typing_import.py:1:1: FA100 Missing from __future__ import annotations but imports: `List`
+  |
+1 | from typing import List
+  | ^^^^^^^^^^^^^^^^^^^^^^^ FA100
+  |
+
+

crates/ruff/src/rules/flake8_future_annotations/snapshots/ruff__rules__flake8_future_annotations__tests__from_typing_import_many.py.snap

@@ -0,0 +1,10 @@
+---
+source: crates/ruff/src/rules/flake8_future_annotations/mod.rs
+---
+from_typing_import_many.py:1:1: FA100 Missing from __future__ import annotations but imports: `Dict`, `List`, `Optional`, `Set`, `Union`
+  |
+1 | from typing import Dict, List, Optional, Set, Union, cast
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FA100
+  |
+
+

crates/ruff/src/rules/flake8_future_annotations/snapshots/ruff__rules__flake8_future_annotations__tests__import_typing.py.snap

@@ -0,0 +1,12 @@
+---
+source: crates/ruff/src/rules/flake8_future_annotations/mod.rs
+---
+import_typing.py:5:13: FA100 Missing from __future__ import annotations but imports: `typing.List`
+  |
+5 | def main() -> None:
+6 |     a_list: typing.List[str] = []
+  |             ^^^^^^^^^^^ FA100
+7 |     a_list.append("hello")
+  |
+
+