Method parse_case_guards

core/src/parser.rs:1588–1681

Parses the guards after a `CASE` keyword.

(&mut self)

    /// Parses the guards after a `CASE` keyword.
    fn parse_case_guards(&mut self) -> Result<Vec<CaseGuardSpan>> {
        let mut guards = vec![];

        loop {
            let peeked = self.lexer.peek()?;
            match peeked.token {
                Token::Else => {
                    let token_span = self.lexer.consume_peeked();

                    if !guards.is_empty() {
                        return Err(Error::Bad(
                            token_span.pos,
                            "CASE ELSE must be on its own".to_owned(),
                        ));
                    }

                    let peeked = self.lexer.peek()?;
                    if peeked.token != Token::Eol && peeked.token != Token::Eof {
                        return Err(Error::Bad(
                            peeked.pos,
                            "Expected newline after CASE ELSE".to_owned(),
                        ));
                    }

                    break;
                }

                Token::Is => {
                    self.lexer.consume_peeked();

                    let token_span = self.lexer.read()?;
                    let rel_op = match token_span.token {
                        Token::Equal => CaseRelOp::Equal,
                        Token::NotEqual => CaseRelOp::NotEqual,
                        Token::Less => CaseRelOp::Less,
                        Token::LessEqual => CaseRelOp::LessEqual,
                        Token::Greater => CaseRelOp::Greater,
                        Token::GreaterEqual => CaseRelOp::GreaterEqual,
                        _ => {
                            return Err(Error::Bad(
                                token_span.pos,
                                "Expected relational operator".to_owned(),
                            ));
                        }
                    };

                    let expr =
                        self.parse_required_expr("Missing expression after relational operator")?;
                    guards.push(CaseGuardSpan::Is(rel_op, expr));
                }

                _ => {
                    let from_expr = self.parse_required_expr("Missing expression in CASE guard")?;

                    let peeked = self.lexer.peek()?;
                    match peeked.token {
                        Token::Eol | Token::Comma => {
                            guards.push(CaseGuardSpan::Is(CaseRelOp::Equal, from_expr));