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

use crate::{Literal, Parser, ParserDiagnostic, ParserResult, Token, types::Type};

mod type_parsers;

impl Parser<'_> {
    pub fn parse_type_definition(&mut self) -> ParserResult<Type> {
        let initial_type = match &self.current_token {
            Token::TyInt => Type::Int,
            Token::TyBool => Type::Bool,
            Token::TyChar => Type::Char,
            Token::TyFloat => Type::Float,
            Token::TyString => Type::String,
            Token::TyArr => self.parse_array_type_definition()?,
            Token::TyMap => self.parse_hashmap_type_definition()?,
            Token::Type => self.parse_type_as_value_type_definition()?,
            Token::Function => self.parse_function_type_definition()?,
            Token::Ident(literal) => self.parse_identifier_type_definition(literal.clone())?,
            t => {
                return Err(ParserDiagnostic::TypeMistake(Literal::from(t.literal())));
            }
        };

        self.parse_primary_type(initial_type)
    }

    pub fn parse_primary_type(&mut self, initial_type: Type) -> ParserResult<Type> {
        let ty = match &self.peek_token {
            Token::Asterisk => Type::Addr(Box::new(initial_type)),
            Token::QuestionMark => Type::Nullable(Box::new(initial_type)),
            _ => return Ok(initial_type),
        };

        self.next_token();

        self.parse_primary_type(ty)
    }
}