[syntax-errors] Async comprehension in sync comprehension

crates/ruff/tests/lint.rs

@@ -5564,3 +5564,90 @@ fn semantic_syntax_errors() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn async_comprehension_in_sync_comprehension() {
+    let contents = "async def f(): return [[x async for x in foo(n)] for n in range(3)]";
+
+    // error on 3.10
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--config", "lint.select = []"])
+        .args(["--target-version", "py310"])
+        .arg("--preview")
+        .arg("-")
+        .pass_stdin(contents),
+        @r"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:27: SyntaxError: cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax was added in 3.11)
+    Found 1 error.
+
+    ----- stderr -----
+    ");
+
+    // okay on 3.11
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--config", "lint.select = []"])
+        .args(["--target-version", "py311"])
+        .arg("--preview")
+        .arg("-")
+        .pass_stdin(contents),
+        @r"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    All checks passed!
+
+    ----- stderr -----
+    ");
+
+    let contents =
+        "async def test(): return [[x async for x in elements(n)] async for n in range(3)]";
+
+    // okay on 3.10 because everything is async
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--config", "lint.select = []"])
+        .args(["--target-version", "py310"])
+        .arg("--preview")
+        .arg("-")
+        .pass_stdin(contents),
+        @r"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    All checks passed!
+
+    ----- stderr -----
+    ");
+
+    // this one will only pass if `SemanticSyntaxChecker::exit_expr` and `exit_stmt` have been wired
+    // up correctly
+    assert_cmd_snapshot!(
+        Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--config", "lint.select = []"])
+        .args(["--target-version", "py310"])
+        .arg("--preview")
+        .arg("-")
+		.pass_stdin("
+async def f(): [x for x in foo()] and [x async for x in foo()]
+async def f():
+    def g(): ...
+    [x async for x in foo()]
+		"),
+        @r"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    All checks passed!
+
+    ----- stderr -----
+    ");
+}

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

@@ -573,7 +573,8 @@ impl SemanticSyntaxContext for Checker<'_> {
             | SemanticSyntaxErrorKind::IrrefutableCasePattern(_)
             | SemanticSyntaxErrorKind::SingleStarredAssignment
             | SemanticSyntaxErrorKind::WriteToDebug(_)
-            | SemanticSyntaxErrorKind::InvalidStarExpression => {
+            | SemanticSyntaxErrorKind::InvalidStarExpression
+            | SemanticSyntaxErrorKind::AsyncComprehensionOutsideAsyncFunction(_) => {
                 if self.settings.preview.is_enabled() {
                     self.semantic_errors.borrow_mut().push(error);
                 }
@@ -584,7 +585,12 @@ impl SemanticSyntaxContext for Checker<'_> {
 
 impl<'a> Visitor<'a> for Checker<'a> {
     fn visit_stmt(&mut self, stmt: &'a Stmt) {
-        self.with_semantic_checker(|semantic, context| semantic.visit_stmt(stmt, context));
+        // For functions, defer semantic syntax error checks until the body of the function is
+        // visited
+        let is_function_def_stmt = stmt.is_function_def_stmt();
+        if !is_function_def_stmt {
+            self.with_semantic_checker(|semantic, context| semantic.enter_stmt(stmt, context));
+        }
 
         // Step 0: Pre-processing
         self.semantic.push_node(stmt);
@@ -1187,6 +1193,10 @@ impl<'a> Visitor<'a> for Checker<'a> {
         self.semantic.flags = flags_snapshot;
         self.semantic.pop_node();
         self.last_stmt_end = stmt.end();
+
+        if !is_function_def_stmt {
+            self.semantic_checker.exit_stmt();
+        }
     }
 
     fn visit_annotation(&mut self, expr: &'a Expr) {
@@ -1197,7 +1207,7 @@ impl<'a> Visitor<'a> for Checker<'a> {
     }
 
     fn visit_expr(&mut self, expr: &'a Expr) {
-        self.with_semantic_checker(|semantic, context| semantic.visit_expr(expr, context));
+        self.with_semantic_checker(|semantic, context| semantic.enter_expr(expr, context));
 
         // Step 0: Pre-processing
         if self.source_type.is_stub()
@@ -1736,6 +1746,8 @@ impl<'a> Visitor<'a> for Checker<'a> {
         self.semantic.flags = flags_snapshot;
         analyze::expression(expr, self);
         self.semantic.pop_node();
+
+        self.semantic_checker.exit_expr();
     }
 
     fn visit_except_handler(&mut self, except_handler: &'a ExceptHandler) {
@@ -2571,17 +2583,23 @@ impl<'a> Checker<'a> {
             for snapshot in deferred_functions {
                 self.semantic.restore(snapshot);
 
+                let stmt = self.semantic.current_statement();
+
                 let Stmt::FunctionDef(ast::StmtFunctionDef {
                     body, parameters, ..
-                }) = self.semantic.current_statement()
+                }) = stmt
                 else {
                     unreachable!("Expected Stmt::FunctionDef")
                 };
 
+                self.with_semantic_checker(|semantic, context| semantic.enter_stmt(stmt, context));
+
                 self.visit_parameters(parameters);
                 // Set the docstring state before visiting the function body.
                 self.docstring_state = DocstringState::Expected(ExpectedDocstringKind::Function);
                 self.visit_body(body);
+
+                self.semantic_checker.exit_stmt();
             }
         }
         self.semantic.restore(snapshot);

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

@@ -0,0 +1,6 @@
+# parse_options: {"target-version": "3.10"}
+async def f(): return [[x async for x in foo(n)] for n in range(3)]    # list
+async def g(): return [{x: 1 async for x in foo(n)} for n in range(3)] # dict
+async def h(): return [{x async for x in foo(n)} for n in range(3)]    # set
+async def i(): return [([y async for y in range(1)], [z for z in range(2)]) for x in range(5)]
+async def j(): return [([y for y in range(1)], [z async for z in range(2)]) for x in range(5)]

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

@@ -0,0 +1,2 @@
+# parse_options: {"target-version": "3.10"}
+async def test(): return [[x async for x in elements(n)] async for n in range(3)]

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

@@ -0,0 +1,9 @@
+# parse_options: {"target-version": "3.10"}
+# this case fails if exit_expr doesn't run
+async def f():
+    [_ for n in range(3)]
+    [_ async for n in range(3)]
+# and this fails without exit_stmt
+async def f():
+    def g(): ...
+    [_ async for n in range(3)]

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

@@ -0,0 +1,4 @@
+# parse_options: {"target-version": "3.11"}
+async def f(): return [[x async for x in foo(n)] for n in range(3)]    # list
+async def g(): return [{x: 1 async for x in foo(n)} for n in range(3)] # dict
+async def h(): return [{x async for x in foo(n)} for n in range(3)]    # set