Method object

aiscript-vm/src/parser/mod.rs:1448–1600

(&mut self, _can_assign: bool)

    }

    fn object(&mut self, _can_assign: bool) -> Option<Expr<'gc>> {
        if self.stop_at_brace {
            self.error("Cannot use object literals in flow control conditions");
            return None;
        }

        let line = self.previous.line;
        let previous_expr = self.previous_expr.take();
        let mut properties = Vec::new();

        if !self.check(TokenType::CloseBrace) {
            loop {
                let property = if self.match_token(TokenType::OpenBracket) {
                    // Computed property name: [expr]
                    let key_expr = Box::new(self.expression()?);
                    self.consume(
                        TokenType::CloseBracket,
                        "Expect ']' after computed property name.",
                    );
                    self.consume(TokenType::Colon, "Expect ':' after computed property name.");
                    let value = Box::new(self.expression()?);

                    ObjectProperty::Computed { key_expr, value }
                } else if self.check(TokenType::String) {
                    // String literal key
                    self.advance();
                    let key = Token::new(
                        TokenType::Identifier,
                        self.previous.lexeme,
                        self.previous.line,
                    );
                    self.consume(TokenType::Colon, "Expect ':' after property name.");
                    let value = Box::new(self.expression()?);

                    ObjectProperty::Literal { key, value }
                } else if self.check(TokenType::Identifier) {
                    // Could be either shorthand {a} or regular {a: expr}
                    self.advance();
                    let key = self.previous;

                    if self.match_token(TokenType::Colon) {
                        // Regular property
                        let value = Box::new(self.expression()?);
                        ObjectProperty::Literal { key, value }
                    } else {
                        // Shorthand property {a} -> {a: a}
                        let value = Box::new(Expr::Variable {
                            name: key,
                            line: key.line,
                        });
                        ObjectProperty::Literal { key, value }
                    }
                } else {
                    self.error_at_current(
                        "Expect property name string, identifier, or computed [expression].",
                    );
                    return None;
                };