Method match_expression

aiscript-vm/src/parser/mod.rs:1974–2035

(&mut self, _can_assign: bool)

    }

    fn match_expression(&mut self, _can_assign: bool) -> Option<Expr<'gc>> {
        let line = self.previous.line;
        self.stop_at_brace = true;
        let expr = Box::new(self.expression()?);
        self.stop_at_brace = false;

        self.consume(TokenType::OpenBrace, "Expect '{' after match expression.");

        if self.check(TokenType::CloseBrace) {
            self.error_at_current(
                "Empty match not allowed. A match expression must have at least one arm.",
            );
            return None;
        }

        let mut arms: Vec<MatchArm> = Vec::new();
        let mut seen_patterns = HashSet::new();
        let mut has_wildcard = false;

        // Set mode for parsing match arms
        self.in_match_arm = true;
        while !self.check(TokenType::CloseBrace) && !self.is_at_end() {
            let arm = self.match_arm()?;

            for pattern in &arm.patterns {
                match pattern {
                    MatchPattern::Wildcard => {
                        if has_wildcard {
                            self.error("Multiple wildcard patterns in match expression.");
                        }
                        has_wildcard = true;
                    }
                    MatchPattern::EnumVariant { enum_name, variant } => {
                        let pattern_key = format!("{}::{}", enum_name.lexeme, variant.lexeme);
                        if !seen_patterns.insert(pattern_key) {
                            self.error_at(*variant, "Duplicate match pattern.");
                        }
                    }
                    MatchPattern::Literal { value } => {
                        if !seen_patterns.insert(format!("{:?}", value)) {
                            self.error("Duplicate match pattern.");
                        }
                    }
                    MatchPattern::Variable { name } => {
                        // FIXME: incorrect duplicate pattern checking due guard hash
                        if !seen_patterns.insert(format!("{} {:?}", name.lexeme, arm.guard)) {
                            self.error("Duplicate match pattern.");
                        }
                    }
                    MatchPattern::Range { .. } => {
                        // Range patterns are validated during parsing
                    }
                }
            }
            arms.push(arm);
        }
        self.in_match_arm = false;