implement F404 too

Author: ntBre

crates/red_knot_python_semantic/src/types/infer.rs

@@ -4815,7 +4815,7 @@ impl<'db> TypeInferenceBuilder<'db> {
         self.types.syntax_diagnostics.extend(
             self.syntax_checker
                 .finish()
-                .map(|error| SyntaxDiagnostic::from_syntax_error(&error, file)),
+                .map(|error| SyntaxDiagnostic::from_syntax_error(error, file)),
         );
         self.types.shrink_to_fit();
         self.types

crates/ruff_linter/src/checkers/ast/analyze/statement.rs

@@ -852,14 +852,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                     if checker.enabled(Rule::FutureFeatureNotDefined) {
                         pyflakes::rules::future_feature_not_defined(checker, alias);
                     }
-                    if checker.enabled(Rule::LateFutureImport) {
-                        if checker.semantic.seen_futures_boundary() {
-                            checker.report_diagnostic(Diagnostic::new(
-                                pyflakes::rules::LateFutureImport,
-                                stmt.range(),
-                            ));
-                        }
-                    }
                 } else if &alias.name == "*" {
                     if checker.enabled(Rule::UndefinedLocalWithNestedImportStarUsage) {
                         if !matches!(checker.semantic.current_scope().kind, ScopeKind::Module) {

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

@@ -26,7 +26,7 @@ use std::path::Path;
 
 use itertools::Itertools;
 use log::debug;
-use ruff_python_syntax_errors::SyntaxChecker;
+use ruff_python_syntax_errors::{SyntaxChecker, SyntaxError, SyntaxErrorKind};
 use rustc_hash::{FxHashMap, FxHashSet};
 
 use ruff_diagnostics::{Diagnostic, IsolationLevel};
@@ -66,6 +66,7 @@ use crate::importer::Importer;
 use crate::noqa::NoqaMapping;
 use crate::package::PackageRoot;
 use crate::registry::Rule;
+use crate::rules::pyflakes::rules::LateFutureImport;
 use crate::rules::{flake8_pyi, flake8_type_checking, pyflakes, pyupgrade};
 use crate::settings::{flags, LinterSettings};
 use crate::{docstrings, noqa, Locator};
@@ -2736,18 +2737,29 @@ pub(crate) fn check_ast(
     checker.analyze.scopes.push(ScopeId::global());
     analyze::deferred_scopes(&checker);
 
-    // checker.syntax_checker.
-
     let mut diagnostics = checker.diagnostics.take();
 
-    diagnostics.extend(checker.syntax_checker.finish().map(|error| {
-        Diagnostic::new(
+    diagnostics.extend(
+        checker
+            .syntax_checker
+            .finish()
+            .filter_map(|error| try_diagnostic_from_syntax_error(error, &checker)),
+    );
+
+    diagnostics
+}
+
+fn try_diagnostic_from_syntax_error(error: &SyntaxError, checker: &Checker) -> Option<Diagnostic> {
+    match error.kind {
+        SyntaxErrorKind::MatchBeforePy310 => Some(Diagnostic::new(
             crate::rules::syntax::VersionSyntaxError {
                 message: error.message(),
             },
             error.range,
-        )
-    }));
-
-    diagnostics
+        )),
+        SyntaxErrorKind::LateFutureImport if checker.enabled(Rule::LateFutureImport) => {
+            Some(Diagnostic::new(LateFutureImport, error.range))
+        }
+        SyntaxErrorKind::LateFutureImport => None,
+    }
 }

crates/ruff_linter/src/rules/syntax/mod.rs

@@ -7,6 +7,7 @@ pub struct VersionSyntaxError {
 }
 
 impl Violation for VersionSyntaxError {
+    #[allow(clippy::useless_format)]
     #[derive_message_formats]
     fn message(&self) -> String {
         format!("{}", self.message)

crates/ruff_python_syntax_errors/src/lib.rs

@@ -5,8 +5,8 @@
 //! a parent `Visitor`.
 
 use ruff_python_ast::{
-    visitor::source_order::{SourceOrderVisitor, TraversalSignal},
-    AnyNodeRef, StmtMatch,
+    visitor::source_order::{walk_stmt, SourceOrderVisitor, TraversalSignal},
+    AnyNodeRef, Stmt, StmtExpr, StmtImportFrom, StmtMatch,
 };
 use ruff_text_size::TextRange;
 
@@ -16,18 +16,24 @@ pub struct SyntaxChecker {
     target_version: PythonVersion,
     /// The cumulative set of syntax errors found when visiting the source AST.
     errors: Vec<SyntaxError>,
+
+    /// these could be grouped into a bitflags struct like `SemanticModel`
+    seen_futures_boundary: bool,
+    seen_docstring_boundary: bool,
 }
 
 impl SyntaxChecker {
     pub fn new(target_version: PythonVersion) -> Self {
         Self {
             target_version,
             errors: Vec::new(),
+            seen_futures_boundary: false,
+            seen_docstring_boundary: false,
         }
     }
 
-    pub fn finish(self) -> impl Iterator<Item = SyntaxError> {
-        self.errors.into_iter()
+    pub fn finish(&self) -> impl Iterator<Item = &SyntaxError> {
+        self.errors.iter()
     }
 }
 
@@ -64,19 +70,24 @@ impl SyntaxError {
                 major = self.target_version.major,
                 minor = self.target_version.minor,
             ),
+            SyntaxErrorKind::LateFutureImport => {
+				"__future__ imports must be at the top of the file".to_string()
+			}
         }
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum SyntaxErrorKind {
     MatchBeforePy310,
+    LateFutureImport,
 }
 
 impl SyntaxErrorKind {
     pub const fn as_str(self) -> &'static str {
         match self {
             SyntaxErrorKind::MatchBeforePy310 => "match-before-python-310",
+            SyntaxErrorKind::LateFutureImport => "late-future-import",
         }
     }
 }
@@ -93,6 +104,15 @@ impl<'a> SourceOrderVisitor<'a> for SyntaxChecker {
                     });
                 }
             }
+            AnyNodeRef::StmtImportFrom(StmtImportFrom { range, module, .. }) => {
+                if self.seen_futures_boundary && matches!(module.as_deref(), Some("__future__")) {
+                    self.errors.push(SyntaxError {
+                        kind: SyntaxErrorKind::LateFutureImport,
+                        range: *range,
+                        target_version: self.target_version,
+                    });
+                }
+            }
             AnyNodeRef::ModModule(_)
             | AnyNodeRef::ModExpression(_)
             | AnyNodeRef::StmtFunctionDef(_)
@@ -111,7 +131,6 @@ impl<'a> SourceOrderVisitor<'a> for SyntaxChecker {
             | AnyNodeRef::StmtTry(_)
             | AnyNodeRef::StmtAssert(_)
             | AnyNodeRef::StmtImport(_)
-            | AnyNodeRef::StmtImportFrom(_)
             | AnyNodeRef::StmtGlobal(_)
             | AnyNodeRef::StmtNonlocal(_)
             | AnyNodeRef::StmtExpr(_)
@@ -187,6 +206,33 @@ impl<'a> SourceOrderVisitor<'a> for SyntaxChecker {
         }
         TraversalSignal::Skip
     }
+
+    fn visit_stmt(&mut self, stmt: &'a ruff_python_ast::Stmt) {
+        match stmt {
+            Stmt::Expr(StmtExpr { value, .. })
+                if !self.seen_docstring_boundary && value.is_string_literal_expr() =>
+            {
+                self.seen_docstring_boundary = true;
+            }
+            Stmt::ImportFrom(StmtImportFrom { module, .. }) => {
+                self.seen_docstring_boundary = true;
+                // Allow __future__ imports until we see a non-__future__ import.
+                if let Some("__future__") = module.as_deref() {
+                } else {
+                    self.seen_futures_boundary = true;
+                }
+            }
+            Stmt::Import(_) => {
+                self.seen_docstring_boundary = true;
+                self.seen_futures_boundary = true;
+            }
+            _ => {
+                self.seen_docstring_boundary = true;
+                self.seen_futures_boundary = true;
+            }
+        }
+        walk_stmt(self, stmt);
+    }
 }
 
 #[cfg(test)]