skullbrain-parser 0.1.0

Parses skullbrain tokens into a concrete syntax tree (CST).
Documentation 
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

use skullbrain_diagnostics::{EmitDiagnostics, ParseError};
use skullbrain_lexer::{LiteralKind, TokenKind};

use crate::{
    state::{ConcreteSyntaxTreeBuilder, PositionedToken},
    Diagnostics, ParserState, SyntaxKind,
};

impl<'input, D: Diagnostics, C: ConcreteSyntaxTreeBuilder> ParserState<'input, D, C> {
    pub(crate) fn parse_literal(&mut self) {
        self.parse_token_with(SyntaxKind::Literal, |state, item| {
            state.emit_diagnostic_if_required(&item);
        })
    }

    fn emit_diagnostic_if_required(&mut self, item: &PositionedToken) {
        match item.kind() {
            TokenKind::Literial(kind) => match kind {
                LiteralKind::Int { is_empty, .. } if *is_empty => {
                    self.emit_diagnostic_for_literal(item, ParseError::digits_for_number_is_empty())
                }
                LiteralKind::Double { empty_exponent, .. } if *empty_exponent => {
                    self.emit_diagnostic_for_literal(item, ParseError::exponent_float_is_empty())
                }
                LiteralKind::Str { is_terminated } if !is_terminated => {
                    self.emit_diagnostic_for_literal(item, ParseError::unterminated_string_quote())
                }
                LiteralKind::Boolean(_)
                | LiteralKind::Str { .. }
                | LiteralKind::Double { .. }
                | LiteralKind::Int { .. } => (),
            },
            _ => unreachable!(),
        };
    }

    fn emit_diagnostic_for_literal(&mut self, item: &PositionedToken, error: ParseError) {
        let diagnostic_details = self.diagnostic_details_with_item(&item);
        self.emit_diagnostic(error, diagnostic_details);
    }
}