pipeline_script/parser/
mod.rs

1use crate::ast::module::Module;
2use crate::ast::r#struct::{Struct, StructField};
3use crate::ast::r#type::Type;
4use crate::context::Context;
5use crate::core::result::Result;
6use crate::lexer::iter::TokenStream;
7use crate::lexer::token::Token;
8use crate::lexer::Lexer;
9use slotmap::DefaultKey;
10use std::vec;
11
12mod expr;
13mod function;
14mod helper;
15mod ptype;
16mod stmt;
17
18pub struct Parser {
19    token_stream: TokenStream,
20    module: DefaultKey,
21    parent_module: DefaultKey,
22    current_module: DefaultKey,
23    function_keyword: String,
24    var_keyword: String,
25    val_keyword: String,
26    in_function_scope: bool,
27}
28impl Parser {
29    pub fn new(lexer: Lexer, ctx: &Context) -> Self {
30        let name = lexer.get_file_name();
31        let module = ctx.register_module(Module::new(name));
32        Self {
33            token_stream: TokenStream::new(lexer),
34            current_module: module,
35            parent_module: module,
36            module,
37            function_keyword: "fn".into(),
38            var_keyword: "let".into(),
39            val_keyword: "const".into(),
40            in_function_scope: false,
41        }
42    }
43    pub fn parse_module(&mut self, ctx: &Context) -> Result<()> {
44        self.parse_keyword("module")?;
45        let (name, _) = self.parse_identifier()?;
46        let module = Module::new(name.clone());
47        let module = ctx.register_module(module);
48        self.parent_module = self.current_module;
49        self.current_module = module;
50        self.parse_special_token(Token::ParenLeft)?;
51        while !self.token_stream.is_eof() {
52            let stmt = self.parse_stmt(ctx)?;
53            if stmt.is_noop() {
54                break;
55            }
56            ctx.apply_mut_module(self.current_module, |m| m.add_stmt(stmt.clone()));
57        }
58        self.parse_special_token(Token::ParenRight)?;
59        ctx.apply_mut_module(self.parent_module, |m| {
60            m.register_submodule(&name, self.current_module)
61        });
62        Ok(())
63    }
64    pub fn parse(&mut self, ctx: &Context) -> Result<DefaultKey> {
65        while !self.token_stream.is_eof() {
66            let stmt = self.parse_stmt(ctx)?;
67            if stmt.is_noop() {
68                break;
69            }
70            ctx.apply_mut_module(self.module, |m| m.add_stmt(stmt.clone()));
71        }
72        Ok(self.module)
73    }
74
75    fn parse_struct(&mut self, ctx: &Context) -> Result<()> {
76        let _ = self.parse_keyword("struct")?;
77        let (struct_name, _) = self.parse_identifier()?;
78        let mut generic = vec![];
79        if self.next_is(Token::Less) {
80            generic = self.parse_generic_list().unwrap();
81        }
82        let _ = self.parse_special_token(Token::ParenLeft)?;
83        let mut fields = vec![];
84        loop {
85            let (token, _) = self.token_stream.peek();
86            match token {
87                Token::Identifier(id) => {
88                    let _ = self.parse_identifier()?;
89                    let _ = self.parse_special_token(Token::Colon)?;
90                    let ty = self.parse_type()?;
91                    fields.push(StructField::new(id, ty));
92                    continue;
93                }
94                Token::Comma => {
95                    self.parse_special_token(Token::Comma)?;
96                    continue;
97                }
98                Token::ParenRight => {
99                    self.parse_special_token(Token::ParenRight)?;
100                    break;
101                }
102                _ => break,
103            }
104        }
105        let struct_declaration = Struct::new(struct_name.clone(), fields, generic.clone());
106        ctx.apply_mut_module(self.current_module, |m| {
107            m.register_struct(&struct_name, struct_declaration.clone())
108        });
109        Ok(())
110    }
111    fn parse_enum(&mut self, ctx: &Context) -> Result<()> {
112        // 解析enum关键字
113        let _ = self.parse_keyword("enum")?;
114
115        // 解析枚举名称
116        let (enum_name, _) = self.parse_identifier()?;
117
118        // 解析泛型参数
119        let generic = self.parse_type_generics().unwrap();
120
121        // 解析枚举体
122        self.parse_special_token(Token::ParenLeft)?;
123
124        // 解析枚举变体
125        let mut variants = vec![];
126        loop {
127            let (token, _) = self.token_stream.peek();
128            match token {
129                Token::ParenRight => {
130                    self.parse_special_token(Token::ParenRight)?;
131                    break;
132                }
133                Token::Identifier(_) => {
134                    let (variant_name, _) = self.parse_identifier()?;
135
136                    // 检查是否有关联类型
137                    let mut variant_type = None;
138                    if self.try_parse_token(Token::BraceLeft) {
139                        // 解析关联类型
140                        let ty = self.parse_type()?;
141                        self.parse_special_token(Token::BraceRight)?;
142                        variant_type = Some(ty);
143                    }
144
145                    variants.push((variant_name, variant_type));
146
147                    // 检查是否有逗号
148                    if self.try_parse_token(Token::Comma) {
149                        continue;
150                    }
151                }
152                _ => {
153                    break;
154                }
155            }
156        }
157
158        // 创建枚举类型并注册到模块
159        let enum_type = Type::Enum(Some(enum_name.clone()), variants);
160
161        // 注册枚举类型为别名
162        ctx.apply_mut_module(self.current_module, |m| {
163            let generic = generic.iter().map(|it| it.as_str()).collect();
164            m.register_type_alias(&enum_name, enum_type.clone(), generic)
165        });
166        Ok(())
167    }
168    fn parse_trait(&mut self) {}
169
170    pub fn is_in_global_scope(&self) -> bool {
171        !self.in_function_scope
172    }
173}
pipeline_script/parser/mod.rs

pipeline_script/parser/
mod.rs
