Method bracket

aiscript-vm/src/parser/mod.rs:1756–1801

(&mut self, _can_assign: bool)

    }

    fn bracket(&mut self, _can_assign: bool) -> Option<Expr<'gc>> {
        let mut elements = Vec::new();
        let line = self.previous.line;

        // A flag to only check CloseBucket once to determine the Expr::EvaluateVariant
        let mut once = iter::once(1);
        if !self.check(TokenType::CloseBracket) {
            loop {
                let item = self.expression()?;
                if once.next().is_some()
                    // EvaluateVariant can only perform on those three Expr.
                    // We allow [self] syntax in enum's method.
                    && matches!(item, Expr::EnumVariant { .. } | Expr::Variable { .. } | Expr::Self_ { .. })
                    && self.match_token(TokenType::CloseBracket)
                {
                    // Evaluate expression value
                    return Some(Expr::EvaluateVariant {
                        expr: Box::new(item),
                        line,
                    });
                }

                elements.push(item);
                if !self.check(TokenType::Comma) && !self.check(TokenType::CloseBracket) {
                    self.error_at_current("Expect ',' after array element.");
                    return None;
                }

                if !self.match_token(TokenType::Comma) {
                    break;
                }

                // Check for trailing comma
                if self.check(TokenType::CloseBracket) {
                    break;
                }
            }
        }

        self.consume(TokenType::CloseBracket, "Expect ']' after array elements.");
        Some(Expr::List {
            elements,
            kind: ListKind::Array,
            line,
        })
    }

    fn call(&mut self, _can_assign: bool) -> Option<Expr<'gc>> {
        let callee = Box::new(self.previous_expr.take()?);