Method parse_statement

crates/ruff_python_parser/src/parser/statement.rs:113–151

Parses a compound or a single simple statement. See: - -

(&mut self)

    /// - <https://docs.python.org/3/reference/compound_stmts.html>
    /// - <https://docs.python.org/3/reference/simple_stmts.html>
    pub(super) fn parse_statement(&mut self) -> Stmt {
        let start = self.node_start();

        match self.current_token_kind() {
            TokenKind::If => Stmt::If(self.parse_if_statement()),
            TokenKind::For => Stmt::For(self.parse_for_statement(start)),
            TokenKind::While => Stmt::While(self.parse_while_statement()),
            TokenKind::Def => {
                Stmt::FunctionDef(self.parse_function_definition(DecoratorList::new(), start))
            }
            TokenKind::Class => {
                Stmt::ClassDef(self.parse_class_definition(DecoratorList::new(), start))
            }
            TokenKind::Try => Stmt::Try(self.parse_try_statement()),
            TokenKind::With => Stmt::With(self.parse_with_statement(start)),
            TokenKind::At => self.parse_decorators(),
            TokenKind::Async => self.parse_async_statement(),
            token => {
                if token == TokenKind::Match {
                    // Match is considered a soft keyword, so we will treat it as an identifier if
                    // it's followed by an unexpected token.

                    match self.classify_match_token() {
                        MatchTokenKind::Keyword => {
                            return Stmt::Match(self.parse_match_statement());
                        }
                        MatchTokenKind::KeywordOrIdentifier => {
                            if let Some(match_stmt) = self.try_parse_match_statement() {
                                return Stmt::Match(match_stmt);
                            }
                        }
                        MatchTokenKind::Identifier => {}
                    }
                }

                self.parse_single_simple_statement()
            }
        }
    }

    /// Parses a single simple statement.
    ///