Reject semantic syntax errors for lazy imports

Author: charliermarsh

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

@@ -47,7 +47,8 @@ use ruff_python_ast::{PySourceType, helpers, str, visitor};
 use ruff_python_codegen::{Generator, Stylist};
 use ruff_python_index::Indexer;
 use ruff_python_parser::semantic_errors::{
-    SemanticSyntaxChecker, SemanticSyntaxContext, SemanticSyntaxError, SemanticSyntaxErrorKind,
+    LazyImportContext, SemanticSyntaxChecker, SemanticSyntaxContext, SemanticSyntaxError,
+    SemanticSyntaxErrorKind,
 };
 use ruff_python_parser::typing::{AnnotationKind, ParsedAnnotation, parse_type_annotation};
 use ruff_python_parser::{ParseError, Parsed};
@@ -766,6 +767,9 @@ impl SemanticSyntaxContext for Checker<'_> {
                 }
             }
             SemanticSyntaxErrorKind::ReboundComprehensionVariable
+            | SemanticSyntaxErrorKind::LazyImportNotAllowed { .. }
+            | SemanticSyntaxErrorKind::LazyImportStar
+            | SemanticSyntaxErrorKind::LazyFutureImport
             | SemanticSyntaxErrorKind::DuplicateTypeParameter
             | SemanticSyntaxErrorKind::MultipleCaseAssignment(_)
             | SemanticSyntaxErrorKind::IrrefutableCasePattern(_)
@@ -798,6 +802,27 @@ impl SemanticSyntaxContext for Checker<'_> {
         self.semantic.future_annotations_or_stub()
     }
 
+    fn lazy_import_context(&self) -> Option<LazyImportContext> {
+        match self.semantic.current_scope().kind {
+            ScopeKind::Function(_) | ScopeKind::Lambda(_) => {
+                return Some(LazyImportContext::Function);
+            }
+            ScopeKind::Class(_) => return Some(LazyImportContext::Class),
+            ScopeKind::Generator { .. }
+            | ScopeKind::Module
+            | ScopeKind::Type
+            | ScopeKind::DunderClassCell => {}
+        }
+
+        for statement in self.semantic.current_statements().skip(1) {
+            if matches!(statement, Stmt::Try(_)) {
+                return Some(LazyImportContext::TryExceptBlocks);
+            }
+        }
+
+        None
+    }
+
     fn in_async_context(&self) -> bool {
         self.semantic.in_async_context()
     }

crates/ruff_python_parser/resources/inline/err/lazy_import_invalid_context_py315.py

@@ -0,0 +1,23 @@
+# parse_options: {"target-version": "3.15"}
+try:
+    lazy import os
+except:
+    pass
+
+try:
+    x
+except* Exception:
+    lazy import sys
+
+def func():
+    lazy import math
+
+async def async_func():
+    lazy from json import loads
+
+class MyClass:
+    lazy import typing
+
+def outer():
+    class Inner:
+        lazy import json

crates/ruff_python_parser/resources/inline/err/lazy_import_invalid_from_py315.py

@@ -0,0 +1,6 @@
+# parse_options: {"target-version": "3.15"}
+lazy from os import *
+lazy from __future__ import annotations
+
+def func():
+    lazy from sys import *

crates/ruff_python_parser/resources/inline/ok/lazy_import_semantic_ok_py315.py

@@ -0,0 +1,6 @@
+# parse_options: {"target-version": "3.15"}
+import contextlib
+with contextlib.nullcontext():
+    lazy import os
+with contextlib.nullcontext():
+    lazy from sys import path

crates/ruff_python_parser/src/semantic_errors.rs

@@ -57,16 +57,89 @@ impl SemanticSyntaxChecker {
         });
     }
 
+    fn check_lazy_import_context<Ctx: SemanticSyntaxContext>(
+        ctx: &Ctx,
+        range: TextRange,
+        kind: LazyImportKind,
+    ) -> bool {
+        if let Some(context) = ctx.lazy_import_context() {
+            Self::add_error(
+                ctx,
+                SemanticSyntaxErrorKind::LazyImportNotAllowed { context, kind },
+                range,
+            );
+            return true;
+        }
+        false
+    }
+
     fn check_stmt<Ctx: SemanticSyntaxContext>(&mut self, stmt: &ast::Stmt, ctx: &Ctx) {
         match stmt {
             Stmt::ImportFrom(StmtImportFrom {
                 range,
                 module,
                 level,
                 names,
+                is_lazy,
                 ..
             }) => {
-                if matches!(module.as_deref(), Some("__future__")) {
+                let mut handled_lazy_error = false;
+
+                if *is_lazy {
+                    // test_ok lazy_import_semantic_ok_py315
+                    // # parse_options: {"target-version": "3.15"}
+                    // import contextlib
+                    // with contextlib.nullcontext():
+                    //     lazy import os
+                    // with contextlib.nullcontext():
+                    //     lazy from sys import path
+
+                    // test_err lazy_import_invalid_context_py315
+                    // # parse_options: {"target-version": "3.15"}
+                    // try:
+                    //     lazy import os
+                    // except:
+                    //     pass
+                    //
+                    // try:
+                    //     x
+                    // except* Exception:
+                    //     lazy import sys
+                    //
+                    // def func():
+                    //     lazy import math
+                    //
+                    // async def async_func():
+                    //     lazy from json import loads
+                    //
+                    // class MyClass:
+                    //     lazy import typing
+                    //
+                    // def outer():
+                    //     class Inner:
+                    //         lazy import json
+                    if Self::check_lazy_import_context(ctx, *range, LazyImportKind::ImportFrom) {
+                        handled_lazy_error = true;
+                    } else if names.iter().any(|alias| alias.name.as_str() == "*") {
+                        // test_err lazy_import_invalid_from_py315
+                        // # parse_options: {"target-version": "3.15"}
+                        // lazy from os import *
+                        // lazy from __future__ import annotations
+                        //
+                        // def func():
+                        //     lazy from sys import *
+                        Self::add_error(ctx, SemanticSyntaxErrorKind::LazyImportStar, *range);
+                        handled_lazy_error = true;
+                    } else if matches!(module.as_deref(), Some("__future__")) {
+                        Self::add_error(ctx, SemanticSyntaxErrorKind::LazyFutureImport, *range);
+                        handled_lazy_error = true;
+                    }
+                }
+
+                if handled_lazy_error {
+                    // Skip the regular `from`-import validations after reporting the lazy-specific
+                    // syntax error with the highest precedence.
+                } else if matches!(module.as_deref(), Some("__future__")) {
                     for name in names {
                         if !is_known_future_feature(&name.name) {
                             // test_ok valid_future_feature
@@ -114,6 +187,13 @@ impl SemanticSyntaxChecker {
                     }
                 }
             }
+            Stmt::Import(ast::StmtImport {
+                range,
+                is_lazy: true,
+                ..
+            }) => {
+                Self::check_lazy_import_context(ctx, *range, LazyImportKind::Import);
+            }
             Stmt::Match(match_stmt) => {
                 Self::irrefutable_match_case(match_stmt, ctx);
                 for case in &match_stmt.cases {
@@ -748,9 +828,11 @@ impl SemanticSyntaxChecker {
         match stmt {
             Stmt::Expr(StmtExpr { value, .. })
                 if !self.seen_module_docstring_boundary && value.is_string_literal_expr() => {}
-            Stmt::ImportFrom(StmtImportFrom { module, .. }) => {
+            Stmt::ImportFrom(StmtImportFrom {
+                module, is_lazy, ..
+            }) => {
                 // Allow __future__ imports until we see a non-__future__ import.
-                if !matches!(module.as_deref(), Some("__future__")) {
+                if *is_lazy || !matches!(module.as_deref(), Some("__future__")) {
                     self.seen_futures_boundary = true;
                 }
             }
@@ -1114,6 +1196,19 @@ fn is_known_future_feature(name: &str) -> bool {
     )
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, get_size2::GetSize)]
+pub enum LazyImportKind {
+    Import,
+    ImportFrom,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, get_size2::GetSize)]
+pub enum LazyImportContext {
+    Function,
+    Class,
+    TryExceptBlocks,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash, get_size2::GetSize)]
 pub struct SemanticSyntaxError {
     pub kind: SemanticSyntaxErrorKind,
@@ -1231,6 +1326,24 @@ impl Display for SemanticSyntaxError {
             SemanticSyntaxErrorKind::FutureFeatureNotDefined(name) => {
                 write!(f, "Future feature `{name}` is not defined")
             }
+            SemanticSyntaxErrorKind::LazyImportNotAllowed { context, kind } => {
+                let statement = match kind {
+                    LazyImportKind::Import => "lazy import",
+                    LazyImportKind::ImportFrom => "lazy from ... import",
+                };
+                let location = match context {
+                    LazyImportContext::Function => "functions",
+                    LazyImportContext::Class => "classes",
+                    LazyImportContext::TryExceptBlocks => "try/except blocks",
+                };
+                write!(f, "{statement} not allowed inside {location}")
+            }
+            SemanticSyntaxErrorKind::LazyImportStar => {
+                f.write_str("lazy from ... import * is not allowed")
+            }
+            SemanticSyntaxErrorKind::LazyFutureImport => {
+                f.write_str("lazy from __future__ import is not allowed")
+            }
             SemanticSyntaxErrorKind::BreakOutsideLoop => f.write_str("`break` outside loop"),
             SemanticSyntaxErrorKind::ContinueOutsideLoop => f.write_str("`continue` outside loop"),
             SemanticSyntaxErrorKind::GlobalParameter(name) => {
@@ -1257,6 +1370,18 @@ impl Ranged for SemanticSyntaxError {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, get_size2::GetSize)]
 pub enum SemanticSyntaxErrorKind {
+    /// Represents a `lazy` import statement in an invalid context.
+    LazyImportNotAllowed {
+        context: LazyImportContext,
+        kind: LazyImportKind,
+    },
+
+    /// Represents the use of `lazy from ... import *`.
+    LazyImportStar,
+
+    /// Represents the use of `lazy from __future__ import ...`.
+    LazyFutureImport,
+
     /// Represents the use of a `__future__` import after the beginning of a file.
     ///
     /// ## Examples
@@ -2131,6 +2256,12 @@ pub trait SemanticSyntaxContext {
     /// Returns `true` if `__future__`-style type annotations are enabled.
     fn future_annotations_or_stub(&self) -> bool;
 
+    /// Returns the nearest invalid context for a `lazy` import statement, if any.
+    ///
+    /// This should return the innermost relevant restriction in order of precedence:
+    /// function, class, then `try`/`except`.
+    fn lazy_import_context(&self) -> Option<LazyImportContext>;
+
     /// The target Python version for detecting backwards-incompatible syntax changes.
     fn python_version(&self) -> PythonVersion;
 

crates/ruff_python_parser/tests/fixtures.rs

@@ -10,7 +10,7 @@ use ruff_python_ast::visitor::Visitor;
 use ruff_python_ast::visitor::source_order::{SourceOrderVisitor, TraversalSignal, walk_module};
 use ruff_python_ast::{self as ast, AnyNodeRef, Mod, PythonVersion};
 use ruff_python_parser::semantic_errors::{
-    SemanticSyntaxChecker, SemanticSyntaxContext, SemanticSyntaxError,
+    LazyImportContext, SemanticSyntaxChecker, SemanticSyntaxContext, SemanticSyntaxError,
 };
 use ruff_python_parser::{Mode, ParseErrorType, ParseOptions, Parsed, parse_unchecked};
 use ruff_source_file::{LineIndex, OneIndexed, SourceCode};
@@ -532,6 +532,7 @@ struct SemanticSyntaxCheckerVisitor<'a> {
     python_version: PythonVersion,
     source: &'a str,
     scopes: Vec<Scope>,
+    try_depth: u32,
 }
 
 impl<'a> SemanticSyntaxCheckerVisitor<'a> {
@@ -542,6 +543,7 @@ impl<'a> SemanticSyntaxCheckerVisitor<'a> {
             python_version: PythonVersion::default(),
             source,
             scopes: vec![Scope::Module],
+            try_depth: 0,
         }
     }
 
@@ -567,6 +569,20 @@ impl SemanticSyntaxContext for SemanticSyntaxCheckerVisitor<'_> {
         false
     }
 
+    fn lazy_import_context(&self) -> Option<LazyImportContext> {
+        match self.scopes.last() {
+            Some(Scope::Function { .. }) => return Some(LazyImportContext::Function),
+            Some(Scope::Class) => return Some(LazyImportContext::Class),
+            Some(Scope::Module | Scope::Comprehension { .. }) | None => {}
+        }
+
+        if self.try_depth > 0 {
+            return Some(LazyImportContext::TryExceptBlocks);
+        }
+
+        None
+    }
+
     fn python_version(&self) -> PythonVersion {
         self.python_version
     }
@@ -672,6 +688,22 @@ impl Visitor<'_> for SemanticSyntaxCheckerVisitor<'_> {
                 ast::visitor::walk_stmt(self, stmt);
                 self.scopes.pop().unwrap();
             }
+            ast::Stmt::Try(ast::StmtTry {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+                ..
+            }) => {
+                self.try_depth += 1;
+                self.visit_body(body);
+                for handler in handlers {
+                    self.visit_except_handler(handler);
+                }
+                self.visit_body(orelse);
+                self.visit_body(finalbody);
+                self.try_depth -= 1;
+            }
             _ => {
                 ast::visitor::walk_stmt(self, stmt);
             }