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

pipeline_script/parser/
mod.rs
