Method match_pattern

aiscript-vm/src/parser/mod.rs:2076–2127

(&mut self)

    }

    fn match_pattern(&mut self) -> Option<MatchPattern<'gc>> {
        if self.match_token(TokenType::Underscore) {
            return Some(MatchPattern::Wildcard);
        }

        let current_kind = self.current.kind;
        let start = match current_kind {
            TokenType::Number | TokenType::True | TokenType::False => {
                self.advance();
                if self.check(TokenType::DotDot) || self.check(TokenType::DotDotEq) {
                    let start_expr = Box::new(Expr::Literal {
                        value: self.parse_literal(self.previous)?,
                        line: self.previous.line,
                    });
                    self.parse_range_pattern(Some(start_expr))?
                } else {
                    MatchPattern::Literal {
                        value: self.parse_literal(self.previous)?,
                    }
                }
            }
            TokenType::String => {
                self.advance();
                MatchPattern::Literal {
                    value: Literal::String(self.ctx.intern(self.previous.lexeme.as_bytes())),
                }
            }
            TokenType::Identifier | TokenType::Error => {
                if self.peek_next().map(|t| t.kind) == Some(TokenType::ColonColon) {
                    self.advance(); // consume enum name
                    let enum_name = self.previous;
                    self.advance(); // consume ::
                    self.consume(TokenType::Identifier, "Expect variant name after '::'.");
                    let variant = self.previous;

                    MatchPattern::EnumVariant { enum_name, variant }
                } else {
                    // Variable binding pattern
                    self.advance(); // consume identifier
                    MatchPattern::Variable {
                        name: self.previous,
                    }
                }
            }
            TokenType::DotDot | TokenType::DotDotEq => self.parse_range_pattern(None)?,
            _ => {
                self.error_at_current("Expected match pattern.");
                return None;
            }
        };
        Some(start)
    }

    fn parse_range_pattern(&mut self, start: Option<Box<Expr<'gc>>>) -> Option<MatchPattern<'gc>> {
        let inclusive = self.match_token(TokenType::DotDotEq);