wright 0.10.1

The wright programming language compiler and tooling.
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
42
43
44
45
46
47
48
49

//! Boolean literal representation and parsing in Wright source.

use crate::parser::{
    ast::metadata::AstNodeMeta,
    error::{ParserError, ParserErrorVariant},
    lexer::{
        tokens::{Token, TokenTy},
        IndexedToken,
    },
    state::ParserState,
    util::NodeParserResult,
};

/// A boolean literal (true or false) in Wright source code.
#[derive(Debug)]
pub struct BooleanLiteral<'src> {
    /// The AST Node Metadata.
    pub meta: AstNodeMeta<'src>,
    /// The value of this literal
    pub value: bool,
}

impl<'src> BooleanLiteral<'src> {
    /// Attempt to parse a boolean literal from the lexer held by the parser state.
    /// Do not mutate parser state if a viable [`TokenTy`] is not available from the lexer. 
    pub fn parse(parser_state: &mut ParserState<'src>) -> NodeParserResult<Self> {
        // Try to parse a `true` token and a `false` token.
        for (token_ty, value) in [(TokenTy::True, true), (TokenTy::False, false)] {
            // Try to take the appropriate token from the parser state.
            if let Some(IndexedToken {
                index,
                token: Token { length, .. },
            }) = parser_state.next_token_if_ty_eq(token_ty)
            {
                // On success, return the popped token's appropriate AST node.
                return Ok(BooleanLiteral {
                    meta: parser_state.make_ast_node_meta(index, length),
                    value,
                });
            }
        }
    
        // If neither parse succeeds, return an error.
        Err(ParserError {
            byte_range: parser_state.peek_byte_range(),
            ty: ParserErrorVariant::Expected("boolean literal"),
        })   
    }
}