ralix 0.2.0

A simple, type-safe, tree walking interpreter
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

use crate::{
    Expression, Parser, ParserDiagnostic, ParserResult, Token,
    expressions::{ElseConsequence, IfConsequence},
    parser::expressions::Precedence,
};

impl Parser<'_> {
    pub fn parse_if_expression(&mut self) -> ParserResult<Expression> {
        let mut consequences = Vec::new();
        let con = self.parse_if_consequence()?;
        consequences.push(con);

        let mut else_consequence = None;

        while self.is_peek_token(Token::Else) {
            self.skip_peek_token(Token::Else);

            if self.is_current_token(Token::If) {
                let con = self.parse_if_consequence()?;
                consequences.push(con);
            } else {
                if !self.is_current_token(Token::Colon) {
                    return Err(ParserDiagnostic::SyntaxError {
                        expected: Token::Colon,
                        got: self.current_token.clone(),
                    });
                }
                self.next_token();

                let expr = self.parse_expression(Precedence::Lowest)?;
                else_consequence = Some(ElseConsequence::new(expr));
                break;
            }
        }

        Ok(Expression::IfElse {
            consequences,
            else_consequence,
        })
    }

    fn parse_if_consequence(&mut self) -> ParserResult<IfConsequence> {
        self.consume_current_token(Token::If);

        let condition = self.parse_expression(Precedence::Lowest)?;
        self.expect_token(Token::Colon)?;
        let consequence = self.parse_expression(Precedence::Lowest)?;

        Ok(IfConsequence::from((condition, consequence)))
    }
}