moduforge_rules_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/// 标准解析器结构体
9/// 用于解析完整的表达式，支持所有语法特性
10#[derive(Debug)]
11pub struct Standard;
12
13impl<'arena, 'token_ref> Parser<'arena, 'token_ref, Standard> {
14    /// 执行标准解析
15    /// 解析完整的表达式并返回解析结果
16    pub fn parse(&self) -> ParserResult<'arena> {
17        let root = self.binary_expression(0);
18
19        ParserResult {
20            root,
21            is_complete: self.is_done(),
22            metadata: self.node_metadata.clone().map(|t| t.into_inner()),
23        }
24    }
25
26    /// 解析二元表达式
27    /// 使用算符优先级分析法解析二元操作符表达式
28    ///
29    /// # 参数
30    /// * `precedence` - 最小优先级，只处理优先级不低于此值的操作符
31    #[cfg_attr(feature = "stack-protection", recursive::recursive)]
32    fn binary_expression(
33        &self,
34        precedence: u8,
35    ) -> &'arena Node<'arena> {
36        // 解析左操作数
37        let mut node_left = self.unary_expression();
38        let Some(mut token) = self.current() else {
39            return node_left;
40        };
41
42        // 处理二元操作符序列
43        while let TokenKind::Operator(operator) = &token.kind {
44            if self.is_done() {
45                break;
46            }
47
48            // 检查操作符是否为有效的二元操作符
49            let Some(op) = BINARY_OPERATORS.get(operator) else {
50                break;
51            };
52
53            // 检查优先级：如果当前操作符优先级低于最小优先级，则停止
54            if op.precedence < precedence {
55                break;
56            }
57
58            self.next();
59            // 根据结合性确定右操作数的最小优先级
60            let node_right = match op.associativity {
61                Associativity::Left => {
62                    self.binary_expression(op.precedence + 1)
63                }, // 左结合：提高优先级
64                _ => self.binary_expression(op.precedence), // 右结合：保持优先级
65            };
66
67            // 创建二元操作节点
68            node_left = self.node(
69                Node::Binary {
70                    operator: *operator,
71                    left: node_left,
72                    right: node_right,
73                },
74                |h| NodeMetadata {
75                    span: h.span(node_left, node_right).unwrap_or_default(),
76                },
77            );
78
79            // 获取下一个令牌继续处理
80            let Some(t) = self.current() else {
81                break;
82            };
83            token = t;
84        }
85
86        // 在最低优先级（0）时处理条件表达式（三元操作符）
87        if precedence == 0 {
88            if let Some(conditional_node) =
89                self.conditional(node_left, |_| self.binary_expression(0))
90            {
91                node_left = conditional_node;
92            }
93        }
94
95        node_left
96    }
97
98    /// 解析一元表达式
99    /// 处理一元操作符、括号表达式、区间表达式和字面量
100    fn unary_expression(&self) -> &'arena Node<'arena> {
101        let Some(token) = self.current() else {
102            return self.error(AstNodeError::Custom {
103                message: self
104                    .bump
105                    .alloc_str("Unexpected end of unary expression"),
106                span: (self.prev_token_end(), self.prev_token_end()),
107            });
108        };
109
110        // 处理回调引用 (#)
111        if self.depth() > 0
112            && token.kind
113                == TokenKind::Identifier(Identifier::CallbackReference)
114        {
115            self.next();
116
117            let node =
118                self.node(Node::Pointer, |_| NodeMetadata { span: token.span });
119            return self.with_postfix(node, |_| self.binary_expression(0));
120        }
121
122        // 处理一元操作符（如 +x, -x, !x）
123        if let TokenKind::Operator(operator) = &token.kind {
124            let Some(unary_operator) = UNARY_OPERATORS.get(operator) else {
125                return self.error(AstNodeError::UnexpectedToken {
126                    expected: "UnaryOperator",
127                    received: self
128                        .bump
129                        .alloc_str(token.kind.to_string().as_str()),
130                    span: token.span,
131                });
132            };
133
134            self.next();
135            let expr = self.binary_expression(unary_operator.precedence);
136            let node = self.node(
137                Node::Unary { operator: *operator, node: expr },
138                |h| NodeMetadata {
139                    span: (
140                        token.span.0,
141                        h.metadata(expr).map(|n| n.span.1).unwrap_or_default(),
142                    ),
143                },
144            );
145
146            return node;
147        }
148
149        // 尝试解析区间表达式（如 [1, 10]、(0, 100) 等）
150        if let Some(interval_node) =
151            self.interval(|_| self.binary_expression(0))
152        {
153            return interval_node;
154        }
155
156        // 处理括号表达式
157        if token.kind == TokenKind::Bracket(Bracket::LeftParenthesis) {
158            let p_start = self.current().map(|s| s.span.0);
159
160            self.next();
161            let binary_node = self.binary_expression(0);
162            if let Some(error_node) =
163                self.expect(TokenKind::Bracket(Bracket::RightParenthesis))
164            {
165                return error_node;
166            };
167
168            let expr =
169                self.node(Node::Parenthesized(binary_node), |_| NodeMetadata {
170                    span: (p_start.unwrap_or_default(), self.prev_token_end()),
171                });
172
173            return self.with_postfix(expr, |_| self.binary_expression(0));
174        }
175
176        // 解析字面量（数字、字符串、标识符等）
177        self.literal(|_| self.binary_expression(0))
178    }
179}
moduforge_rules_expression/parser/standard.rs

moduforge_rules_expression/parser/
standard.rs
