language-servers/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-08-04 02:39:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

[syntax-errors] Make async-comprehension-in-sync-comprehension more specific (#17460)

Browse source 
## Summary

While adding semantic error support to red-knot, I noticed duplicate
diagnostics for code like this:

```py
# error: [invalid-syntax] "cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.9 (syntax was added in 3.11)"
# error: [invalid-syntax] "`asynchronous comprehension` outside of an asynchronous function"
 [reveal_type(x) async for x in AsyncIterable()]
```

Beyond the duplication, the first error message doesn't make much sense
because this syntax is _not_ allowed on Python 3.11 either.

To fix this, this PR renames the
`async-comprehension-outside-async-function` semantic syntax error to
`async-comprehension-in-sync-comprehension` and fixes the rule to avoid
applying outside of sync comprehensions at all.

## Test Plan

New linter test demonstrating the false positive. The mdtests from my red-knot 
PR also reflect this change.
This commit is contained in:
Brent Westbrook 2025-04-24 15:45:54 -04:00 • committed by GitHub
parent f7b48510b5
commit 92ecfc908b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 25 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/red_knot_python_semantic/resources/mdtest/diagnostics/semantic_syntax_errors.md
View file

@ -19,7 +19,7 @@ async def elements(n):
yield n
async def f():
# error: 19 [invalid-syntax] "cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax was added in 3.11)"
# error: 19 [invalid-syntax] "cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (syntax was added in 3.11)"
return {n: [x async for x in elements(n)] for n in range(3)}
```

6
crates/red_knot_python_semantic/resources/mdtest/snapshots/semantic_syntax_errors.md_-_Semantic_syntax_error_diagnostics_-_`async`_comprehensions_in_synchronous_comprehensions_-_Python_3.10.snap
View file

@ -16,7 +16,7 @@ mdtest path: crates/red_knot_python_semantic/resources/mdtest/diagnostics/semant
2 | yield n
3 |
4 | async def f():
5 | # error: 19 [invalid-syntax] "cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax was added in 3.11)"
5 | # error: 19 [invalid-syntax] "cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (syntax was added in 3.11)"
6 | return {n: [x async for x in elements(n)] for n in range(3)}
7 | async def test():
8 | return [[x async for x in elements(n)] async for n in range(3)]
@ -36,9 +36,9 @@ error: invalid-syntax
--> /src/mdtest_snippet.py:6:19
|
4 | async def f():
5 | # error: 19 [invalid-syntax] "cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax...
5 | # error: 19 [invalid-syntax] "cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (synt...
6 | return {n: [x async for x in elements(n)] for n in range(3)}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax was added in 3.11)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (syntax was added in 3.11)
7 | async def test():
8 | return [[x async for x in elements(n)] async for n in range(3)]
|

2
crates/ruff_linter/src/checkers/ast/mod.rs
View file

@ -615,7 +615,7 @@ impl SemanticSyntaxContext for Checker<'_> {
| SemanticSyntaxErrorKind::DuplicateMatchKey(_)
| SemanticSyntaxErrorKind::DuplicateMatchClassAttribute(_)
| SemanticSyntaxErrorKind::InvalidStarExpression
| SemanticSyntaxErrorKind::AsyncComprehensionOutsideAsyncFunction(_)
| SemanticSyntaxErrorKind::AsyncComprehensionInSyncComprehension(_)
| SemanticSyntaxErrorKind::DuplicateParameter(_) => {
if self.settings.preview.is_enabled() {
self.semantic_errors.borrow_mut().push(error);

1
crates/ruff_linter/src/linter.rs
View file

@ -1022,6 +1022,7 @@ mod tests {
",
PythonVersion::PY310
)]
#[test_case("false_positive", "[x async for x in y]", PythonVersion::PY310)]
fn test_async_comprehension_in_sync_comprehension(
name: &str,
contents: &str,

2
crates/ruff_linter/src/snapshots/ruff_linter__linter__tests__async_comprehension_in_sync_comprehension_error_on_310_3.10.snap
View file

@ -1,7 +1,7 @@
---
source: crates/ruff_linter/src/linter.rs
---
<filename>:1:27: SyntaxError: cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax was added in 3.11)
<filename>:1:27: SyntaxError: cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (syntax was added in 3.11)
|
1 | async def f(): return [[x async for x in foo(n)] for n in range(3)]
| ^^^^^^^^^^^^^^^^^^^^^

3
crates/ruff_linter/src/snapshots/ruff_linter__linter__tests__async_comprehension_in_sync_comprehension_false_positive_3.10.snap Normal file
View file

@ -0,0 +1,3 @@
---
source: crates/ruff_linter/src/linter.rs
---

2
crates/ruff_linter/src/snapshots/ruff_linter__linter__tests__async_comprehension_in_sync_comprehension_notebook_3.10.snap
View file

@ -1,7 +1,7 @@
---
source: crates/ruff_linter/src/linter.rs
---
resources/test/fixtures/syntax_errors/async_comprehension.ipynb:3:5: SyntaxError: cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax was added in 3.11)
resources/test/fixtures/syntax_errors/async_comprehension.ipynb:3:5: SyntaxError: cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (syntax was added in 3.11)
|
1 | async def elements(n): yield n
2 | [x async for x in elements(5)] # okay, async at top level

18
crates/ruff_python_parser/src/semantic_errors.rs
View file

@ -573,7 +573,7 @@ impl SemanticSyntaxChecker {
elt, generators, ..
}) => {
Self::check_generator_expr(elt, generators, ctx);
Self::async_comprehension_outside_async_function(ctx, generators);
Self::async_comprehension_in_sync_comprehension(ctx, generators);
for generator in generators.iter().filter(|g| g.is_async) {
Self::await_outside_async_function(
ctx,
@ -590,7 +590,7 @@ impl SemanticSyntaxChecker {
}) => {
Self::check_generator_expr(key, generators, ctx);
Self::check_generator_expr(value, generators, ctx);
Self::async_comprehension_outside_async_function(ctx, generators);
Self::async_comprehension_in_sync_comprehension(ctx, generators);
for generator in generators.iter().filter(|g| g.is_async) {
Self::await_outside_async_function(
ctx,
@ -801,7 +801,7 @@ impl SemanticSyntaxChecker {
}
}
fn async_comprehension_outside_async_function<Ctx: SemanticSyntaxContext>(
fn async_comprehension_in_sync_comprehension<Ctx: SemanticSyntaxContext>(
ctx: &Ctx,
generators: &[ast::Comprehension],
) {
@ -813,7 +813,7 @@ impl SemanticSyntaxChecker {
if ctx.in_notebook() && ctx.in_module_scope() {
return;
}
if ctx.in_async_context() && !ctx.in_sync_comprehension() {
if !ctx.in_sync_comprehension() {
return;
}
for generator in generators.iter().filter(|gen| gen.is_async) {
@ -845,7 +845,7 @@ impl SemanticSyntaxChecker {
// async def j(): return [([y for y in range(1)], [z async for z in range(2)]) for x in range(5)]
Self::add_error(
ctx,
SemanticSyntaxErrorKind::AsyncComprehensionOutsideAsyncFunction(python_version),
SemanticSyntaxErrorKind::AsyncComprehensionInSyncComprehension(python_version),
generator.range,
);
}
@ -914,11 +914,11 @@ impl Display for SemanticSyntaxError {
SemanticSyntaxErrorKind::InvalidStarExpression => {
f.write_str("can't use starred expression here")
}
SemanticSyntaxErrorKind::AsyncComprehensionOutsideAsyncFunction(python_version) => {
SemanticSyntaxErrorKind::AsyncComprehensionInSyncComprehension(python_version) => {
write!(
f,
"cannot use an asynchronous comprehension outside of an asynchronous \
function on Python {python_version} (syntax was added in 3.11)",
"cannot use an asynchronous comprehension inside of a synchronous comprehension \
on Python {python_version} (syntax was added in 3.11)",
)
}
SemanticSyntaxErrorKind::YieldOutsideFunction(kind) => {
@ -1187,7 +1187,7 @@ pub enum SemanticSyntaxErrorKind {
/// This was discussed in [BPO 33346] and fixed in Python 3.11.
///
/// [BPO 33346]: https://github.com/python/cpython/issues/77527
AsyncComprehensionOutsideAsyncFunction(PythonVersion),
AsyncComprehensionInSyncComprehension(PythonVersion),
/// Represents the use of `yield`, `yield from`, or `await` outside of a function scope.
///

10
crates/ruff_python_parser/tests/snapshots/invalid_syntax@nested_async_comprehension_py310.py.snap
View file

@ -780,7 +780,7 @@ Module(
|
1 | # parse_options: {"target-version": "3.10"}
2 | async def f(): return [[x async for x in foo(n)] for n in range(3)] # list
| ^^^^^^^^^^^^^^^^^^^^^ Syntax Error: cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax was added in 3.11)
| ^^^^^^^^^^^^^^^^^^^^^ Syntax Error: cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (syntax was added in 3.11)
3 | async def g(): return [{x: 1 async for x in foo(n)} for n in range(3)] # dict
4 | async def h(): return [{x async for x in foo(n)} for n in range(3)] # set
|
@ -790,7 +790,7 @@ Module(
1 | # parse_options: {"target-version": "3.10"}
2 | async def f(): return [[x async for x in foo(n)] for n in range(3)] # list
3 | async def g(): return [{x: 1 async for x in foo(n)} for n in range(3)] # dict
| ^^^^^^^^^^^^^^^^^^^^^ Syntax Error: cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax was added in 3.11)
| ^^^^^^^^^^^^^^^^^^^^^ Syntax Error: cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (syntax was added in 3.11)
4 | async def h(): return [{x async for x in foo(n)} for n in range(3)] # set
5 | async def i(): return [([y async for y in range(1)], [z for z in range(2)]) for x in range(5)]
|
@ -800,7 +800,7 @@ Module(
2 | async def f(): return [[x async for x in foo(n)] for n in range(3)] # list
3 | async def g(): return [{x: 1 async for x in foo(n)} for n in range(3)] # dict
4 | async def h(): return [{x async for x in foo(n)} for n in range(3)] # set
| ^^^^^^^^^^^^^^^^^^^^^ Syntax Error: cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax was added in 3.11)
| ^^^^^^^^^^^^^^^^^^^^^ Syntax Error: cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (syntax was added in 3.11)
5 | async def i(): return [([y async for y in range(1)], [z for z in range(2)]) for x in range(5)]
6 | async def j(): return [([y for y in range(1)], [z async for z in range(2)]) for x in range(5)]
|
@ -810,7 +810,7 @@ Module(
3 | async def g(): return [{x: 1 async for x in foo(n)} for n in range(3)] # dict
4 | async def h(): return [{x async for x in foo(n)} for n in range(3)] # set
5 | async def i(): return [([y async for y in range(1)], [z for z in range(2)]) for x in range(5)]
| ^^^^^^^^^^^^^^^^^^^^^^^ Syntax Error: cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax was added in 3.11)
| ^^^^^^^^^^^^^^^^^^^^^^^ Syntax Error: cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (syntax was added in 3.11)
6 | async def j(): return [([y for y in range(1)], [z async for z in range(2)]) for x in range(5)]
|
@ -819,5 +819,5 @@ Module(
4 | async def h(): return [{x async for x in foo(n)} for n in range(3)] # set
5 | async def i(): return [([y async for y in range(1)], [z for z in range(2)]) for x in range(5)]
6 | async def j(): return [([y for y in range(1)], [z async for z in range(2)]) for x in range(5)]
| ^^^^^^^^^^^^^^^^^^^^^^^ Syntax Error: cannot use an asynchronous comprehension outside of an asynchronous function on Python 3.10 (syntax was added in 3.11)
| ^^^^^^^^^^^^^^^^^^^^^^^ Syntax Error: cannot use an asynchronous comprehension inside of a synchronous comprehension on Python 3.10 (syntax was added in 3.11)
|