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            let (n, _) = self.with_postfix(node, &|_| self.binary_expression(0));
89            return n;
90        }
91
92        if let TokenKind::Operator(operator) = &token.kind {
93            let Some(unary_operator) = UNARY_OPERATORS.get(operator) else {
94                return self.error(AstNodeError::UnexpectedToken {
95                    expected: "UnaryOperator",
96                    received: self.bump.alloc_str(token.kind.to_string().as_str()),
97                    span: token.span,
98                });
99            };
100
101            self.next();
102            let expr = self.binary_expression(unary_operator.precedence);
103            let node = self.node(
104                Node::Unary {
105                    operator: *operator,
106                    node: expr,
107                },
108                |h| NodeMetadata {
109                    span: (
110                        token.span.0,
111                        h.metadata(expr).map(|n| n.span.1).unwrap_or_default(),
112                    ),
113                },
114            );
115
116            return node;
117        }
118
119        if let Some(interval_node) = self.interval(&|_| self.binary_expression(0)) {
120            return interval_node;
121        }
122
123        if token.kind == TokenKind::Bracket(Bracket::LeftParenthesis) {
124            let p_start = self.current().map(|s| s.span.0);
125
126            self.next();
127            let binary_node = self.binary_expression(0);
128            if let Some(error_node) = self.expect(TokenKind::Bracket(Bracket::RightParenthesis)) {
129                return error_node;
130            };
131
132            let expr = self.node(Node::Parenthesized(binary_node), |_| NodeMetadata {
133                span: (p_start.unwrap_or_default(), self.prev_token_end()),
134            });
135
136            let (n, _) = self.with_postfix(expr, &|_| self.binary_expression(0));
137            return n;
138        }
139
140        self.literal(&|_| self.binary_expression(0))
141    }
142}
zen_expression/parser/standard.rs

zen_expression/parser/
standard.rs
