revive-yul 0.2.1

The revive YUL parser library.
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

//! The symbol lexeme.

use crate::lexer::token::lexeme::Lexeme;
use crate::lexer::token::location::Location;
use crate::lexer::token::Token;

/// The symbol lexeme.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Symbol {
    /// The `:=` symbol.
    Assignment,
    /// The `->` symbol.
    Arrow,
    /// The `{` symbol.
    BracketCurlyLeft,
    /// The `}` symbol.
    BracketCurlyRight,
    /// The `(` symbol.
    ParenthesisLeft,
    /// The `)` symbol.
    ParenthesisRight,
    /// The `,` symbol.
    Comma,
    /// The `:` symbol.
    Colon,
}

impl Symbol {
    /// Parses the symbol, returning it as a token.
    pub fn parse(input: &str) -> Option<Token> {
        let (symbol, length) = match &input[..2] {
            ":=" => (Self::Assignment, 2),
            "->" => (Self::Arrow, 2),

            _ => match &input[..1] {
                "{" => (Self::BracketCurlyLeft, 1),
                "}" => (Self::BracketCurlyRight, 1),
                "(" => (Self::ParenthesisLeft, 1),
                ")" => (Self::ParenthesisRight, 1),
                "," => (Self::Comma, 1),
                ":" => (Self::Colon, 1),

                _ => return None,
            },
        };

        Some(Token::new(
            Location::new(0, length),
            Lexeme::Symbol(symbol),
            length,
        ))
    }
}

impl std::fmt::Display for Symbol {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Assignment => write!(f, ":="),
            Self::Arrow => write!(f, "->"),
            Self::BracketCurlyLeft => write!(f, "{{"),
            Self::BracketCurlyRight => write!(f, "}}"),
            Self::ParenthesisLeft => write!(f, "("),
            Self::ParenthesisRight => write!(f, ")"),
            Self::Comma => write!(f, ","),
            Self::Colon => write!(f, ":"),
        }
    }
}