Method parse_for_statement

parser/src/parser/parser.rs:408–452

(&mut self)

    }

    fn parse_for_statement(&mut self) -> Result<Statement, ParsingError> {
        let node = self.start_node();
        let is_async = self.eat(Kind::Async);
        self.bump(Kind::For);
        let target = self.parse_target_list()?;
        self.expect(Kind::In)?;
        let iter_list = self.parse_starred_list(Kind::Colon)?;
        let iter = match iter_list.len() {
            0 => {
                panic!("Unexpected token {:?}", self.cur_token());
            }
            1 => iter_list.into_iter().next().unwrap(),
            _ => Expression::Tuple(Box::new(Tuple {
                node: self.finish_node(node),
                elements: iter_list,
            })),
        };

        self.expect(Kind::Colon)?;
        let body = self.parse_suite()?;
        let orelse = if self.eat(Kind::Else) {
            self.expect(Kind::Colon)?;
            self.parse_suite()?
        } else {
            vec![]
        };

        if is_async {
            Ok(Statement::AsyncForStatement(Box::new(AsyncFor {
                node: self.finish_node(node),
                target,
                iter,
                body,
                orelse,
            })))
        } else {
            Ok(Statement::ForStatement(Box::new(For {
                node: self.finish_node(node),
                target,
                iter,
                body,
                orelse,
            })))
        }
    }

    fn parse_with_statement(&mut self) -> Result<Statement, ParsingError> {
        let node = self.start_node();