Method parse_async_statement

crates/ruff_python_parser/src/parser/statement.rs:2840–2900

Parses a statement that is valid after an `async` token. If the statement is not a valid `async` statement, an error will be reported and it will be parsed as a statement. See: - - - <https://docs.python.org/3/reference/compound_stmt

(&mut self)

    /// - <https://docs.python.org/3/reference/compound_stmts.html#the-async-for-statement>
    /// - <https://docs.python.org/3/reference/compound_stmts.html#coroutine-function-definition>
    fn parse_async_statement(&mut self) -> Stmt {
        let async_start = self.node_start();
        self.bump(TokenKind::Async);

        match self.current_token_kind() {
            // test_ok async_function_definition
            // async def foo(): ...
            TokenKind::Def => Stmt::FunctionDef(ast::StmtFunctionDef {
                is_async: true,
                ..self.parse_function_definition(DecoratorList::new(), async_start)
            }),

            // test_ok async_with_statement
            // async with item: ...
            TokenKind::With => Stmt::With(ast::StmtWith {
                is_async: true,
                ..self.parse_with_statement(async_start)
            }),

            // test_ok async_for_statement
            // async for target in iter: ...
            TokenKind::For => Stmt::For(ast::StmtFor {
                is_async: true,
                ..self.parse_for_statement(async_start)
            }),

            kind => {
                // test_err async_unexpected_token
                // async class Foo: ...
                // async while test: ...
                // async x = 1
                // async async def foo(): ...
                // async match test:
                //     case _: ...
                self.add_error(
                    ParseErrorType::UnexpectedTokenAfterAsync(kind),
                    self.current_token_range(),
                );

                // Although this statement is not a valid `async` statement,
                // we still parse it. Guard the recursive recovery path so
                // `async async async ...` cannot overflow the parser stack.
                if let Some(stmt) = self.with_recursion(Self::parse_statement) {
                    stmt
                } else {
                    let range = self.node_range(async_start);
                    self.add_error(ParseErrorType::RecursionLimitExceeded, range);
                    Stmt::Expr(ast::StmtExpr {
                        range,
                        value: Box::new(Expr::Name(ast::ExprName {
                            range,
                            id: Name::new_static("async"),
                            ctx: ExprContext::Invalid,
                            node_index: AtomicNodeIndex::NONE,
                        })),
                        node_index: AtomicNodeIndex::NONE,
                    })
                }