zen_expression/parser/
standard.rs

1use crate::lexer::{Bracket, Identifier, TokenKind};
2use crate::parser::ast::{AstNodeError, Node};
3use crate::parser::constants::{Associativity, BINARY_OPERATORS, UNARY_OPERATORS};
4use crate::parser::parser::Parser;
5use crate::parser::result::ParserResult;
6use crate::parser::NodeMetadata;
7
8#[derive(Debug)]
9pub struct Standard;
10
11impl<'arena, 'token_ref> Parser<'arena, 'token_ref, Standard> {
12    pub fn parse(&self) -> ParserResult<'arena> {
13        let root = self.binary_expression(0);
14
15        ParserResult {
16            root,
17            is_complete: self.is_done(),
18            metadata: self.node_metadata.clone().map(|t| t.into_inner()),
19        }
20    }
21
22    fn binary_expression(&self, precedence: u8) -> &'arena Node<'arena> {
23        let mut node_left = self.unary_expression();
24        let Some(mut token) = self.current() else {
25            return node_left;
26        };
27
28        while let TokenKind::Operator(operator) = &token.kind {
29            if self.is_done() {
30                break;
31            }
32
33            let Some(op) = BINARY_OPERATORS.get(operator) else {
34                break;
35            };
36
37            if op.precedence < precedence {
38                break;
39            }
40
41            self.next();
42            let node_right = match op.associativity {
43                Associativity::Left => self.binary_expression(op.precedence + 1),
44                _ => self.binary_expression(op.precedence),
45            };
46
47            node_left = self.node(
48                Node::Binary {
49                    operator: *operator,
50                    left: node_left,
51                    right: node_right,
52                },
53                |h| NodeMetadata {
54                    span: h.span(node_left, node_right).unwrap_or_default(),
55                },
56            );
57
58            let Some(t) = self.current() else {
59                break;
60            };
61            token = t;
62        }
63
64        if precedence == 0 {
65            if let Some(conditional_node) =
66                self.conditional(node_left, |_| self.binary_expression(0))
67            {
68                node_left = conditional_node;
69            }
70        }
71
72        node_left
73    }
74
75    fn unary_expression(&self) -> &'arena Node<'arena> {
76        let Some(token) = self.current() else {
77            return self.error(AstNodeError::Custom {
78                message: self.bump.alloc_str("Unexpected end of unary expression"),
79                span: (self.prev_token_end(), self.prev_token_end()),
80            });
81        };
82
83        if self.depth() > 0 && token.kind == TokenKind::Identifier(Identifier::CallbackReference) {
84            self.next();
85
86            let node = self.node(Node::Pointer, |_| NodeMetadata { span: token.span });
87            return self.with_postfix(node, |_| self.binary_expression(0));
88        }
89
90        if let TokenKind::Operator(operator) = &token.kind {
91            let Some(unary_operator) = UNARY_OPERATORS.get(operator) else {
92                return self.error(AstNodeError::UnexpectedToken {
93                    expected: "UnaryOperator",
94                    received: self.bump.alloc_str(token.kind.to_string().as_str()),
95                    span: token.span,
96                });
97            };
98
99            self.next();
100            let expr = self.binary_expression(unary_operator.precedence);
101            let node = self.node(
102                Node::Unary {
103                    operator: *operator,
104                    node: expr,
105                },
106                |h| NodeMetadata {
107                    span: (
108                        token.span.0,
109                        h.metadata(expr).map(|n| n.span.1).unwrap_or_default(),
110                    ),
111                },
112            );
113
114            return node;
115        }
116
117        if let Some(interval_node) = self.interval(|_| self.binary_expression(0)) {
118            return interval_node;
119        }
120
121        if token.kind == TokenKind::Bracket(Bracket::LeftParenthesis) {
122            let p_start = self.current().map(|s| s.span.0);
123
124            self.next();
125            let binary_node = self.binary_expression(0);
126            if let Some(error_node) = self.expect(TokenKind::Bracket(Bracket::RightParenthesis)) {
127                return error_node;
128            };
129
130            let expr = self.node(Node::Parenthesized(binary_node), |_| NodeMetadata {
131                span: (p_start.unwrap_or_default(), self.prev_token_end()),
132            });
133
134            return self.with_postfix(expr, |_| self.binary_expression(0));
135        }
136
137        self.literal(|_| self.binary_expression(0))
138    }
139}
zen_expression/parser/standard.rs

zen_expression/parser/
standard.rs
