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

zen_expression/parser/
standard.rs
