Method for_statement

aiscript-vm/src/parser/mod.rs:1113–1161

(&mut self)

    }

    fn for_statement(&mut self) -> Option<Stmt<'gc>> {
        let initializer = if self.match_token(TokenType::Semicolon) {
            None
        } else if self.match_token(TokenType::Let) {
            Some(Box::new(self.var_declaration(Visibility::Private)?))
        } else {
            Some(Box::new(self.expression_statement()?))
        };

        let condition = if !self.check(TokenType::Semicolon) {
            self.expression()?
        } else {
            Expr::Literal {
                value: Literal::Boolean(true),
                line: self.previous.line,
            }
        };
        self.consume(TokenType::Semicolon, "Expect ';' after loop condition.");

        // Parse increment - optional
        let increment = if !self.check(TokenType::OpenBrace) {
            self.stop_at_brace = true;
            let expr = self.parse_precedence(Precedence::Assignment)?;
            self.stop_at_brace = false;
            Some(expr)
        } else {
            // Peek ahead to check for empty object literal
            if self.check(TokenType::OpenBrace)
                && matches!(self.peek_next(), Some(t) if t.kind == TokenType::CloseBrace)
            {
                self.error_at_current("Empty object literal not allowed in for loop increment");
                return None;
            }
            None
        };

        self.consume(TokenType::OpenBrace, "Expect '{' before loop body.");
        self.loop_depth += 1;
        let body = Box::new(self.block_statement()?);
        self.loop_depth -= 1;

        Some(Stmt::Loop {
            initializer,
            condition,
            increment,
            body,
            line: self.previous.line,
        })
    }

    fn if_statement(&mut self) -> Option<Stmt<'gc>> {
        // Set the flag before parsing condition