pipeline_script/parser/
ptype.rs

1use crate::ast::r#type::Type;
2use crate::core::error::Error;
3use crate::lexer::position::Position;
4use crate::lexer::token::Token;
5use crate::parser::Parser;
6
7impl Parser {
8    pub fn parse_simple_type(&mut self) -> crate::core::result::Result<Type> {
9        let (token, p0) = self.token_stream.next_token();
10
11        match &token {
12            Token::Dot => {
13                let _ = self.parse_special_token(Token::Dot)?;
14                let ty = self.parse_type()?;
15                Ok(Type::ArrayVarArg(Box::new(ty)))
16            }
17            Token::Identifier(id) => match id.as_str() {
18                "Any" => Ok(Type::Any),
19                "Unit" => Ok(Type::Unit),
20                "Int8" => Ok(Type::Int8),
21                "Int16" => Ok(Type::Int16),
22                "Int32" => Ok(Type::Int32),
23                "Int64" => Ok(Type::Int64),
24                "Float" => Ok(Type::Float),
25                "Double" => Ok(Type::Double),
26                "Bool" => Ok(Type::Bool),
27                "String" => Ok(Type::String),
28                "Pointer" => {
29                    if self.token_stream.peek().0 != Token::Less {
30                        return Ok(Type::Pointer(Box::new(Type::Any)));
31                    }
32                    self.parse_generic_type(Type::Pointer)
33                }
34                "Array" => self.parse_generic_type(Type::Array),
35                "Fn" => {
36                    self.parse_special_token(Token::BraceLeft)?;
37                    let mut param_type = vec![];
38
39                    loop {
40                        let peek = self.token_stream.peek().0;
41                        match peek {
42                            Token::BraceRight => {
43                                self.parse_special_token(Token::BraceRight)?;
44                                break;
45                            }
46                            Token::Comma => {
47                                self.parse_special_token(Token::Comma)?;
48                            }
49                            Token::Identifier(_) => {
50                                let ty = self.parse_type()?;
51                                param_type.push(ty);
52                            }
53                            t => {
54                                return Err(Error::UnexpectedToken(
55                                    t.to_string(),
56                                    "Identifier or special token".into(),
57                                    p0,
58                                ))
59                            }
60                        }
61                    }
62
63                    // 检查是否有返回类型
64                    let return_type = if self.try_parse_token(Token::Arrow) {
65                        self.parse_type()?
66                    } else {
67                        Type::Unit
68                    };
69
70                    Ok(Type::Function(
71                        Box::new(return_type),
72                        param_type
73                            .into_iter()
74                            .map(|t| (t.as_str().to_string(), t))
75                            .collect(),
76                        false,
77                    ))
78                }
79                name => Ok(Type::Alias(name.into())),
80            },
81            Token::BracketLeft => {
82                self.parse_special_token(Token::BracketLeft)?;
83                let ty = self.parse_type()?;
84                self.parse_special_token(Token::BracketRight)?;
85                Ok(Type::Array(Box::new(ty)))
86            }
87            _ => Err(Error::UnexpectedToken(
88                token.to_string(),
89                "Identifier or special token".into(),
90                p0,
91            )),
92        }
93    }
94    pub fn parse_type(&mut self) -> crate::core::result::Result<Type> {
95        let ty = self.parse_simple_type()?;
96
97        // 检查是否有泛型参数
98        if !self.try_parse_token(Token::Less) {
99            return Ok(ty);
100        }
101
102        // 解析泛型参数列表
103        let mut list = vec![];
104        let t0 = self.parse_type()?;
105        list.push(t0);
106
107        // 解析结束符
108        self.parse_special_token(Token::Greater)?;
109
110        Ok(Type::Generic(Box::new(ty), list))
111    }
112
113    fn parse_generic_type<F>(&mut self, constructor: F) -> crate::core::result::Result<Type>
114    where
115        F: FnOnce(Box<Type>) -> Type,
116    {
117        self.parse_special_token(Token::Less)?;
118        let el_ty = self.parse_type()?;
119        self.parse_special_token(Token::Greater)?;
120        Ok(constructor(Box::new(el_ty)))
121    }
122    pub(crate) fn parse_generic_list(&mut self) -> crate::core::result::Result<Vec<Type>> {
123        let mut list = vec![];
124
125        // 解析开始符号
126        self.parse_special_token(Token::Less)?;
127
128        // 解析第一个类型
129        let ty = self.parse_type()?;
130        list.push(ty);
131
132        // 解析剩余的类型
133        loop {
134            let (peek, _) = self.token_stream.peek();
135
136            match peek {
137                // 如果是 '|'，则继续解析下一个类型
138                Token::Vertical => {
139                    self.parse_special_token(Token::Vertical)?;
140                    let ty = self.parse_type()?;
141                    list.push(ty);
142                }
143                // 如果是 '>'，则结束解析
144                Token::Greater => {
145                    self.parse_special_token(Token::Greater)?;
146                    break;
147                }
148                // 其他情况，报错
149                t => {
150                    return Err(Error::UnexpectedToken(
151                        t.to_string(),
152                        "| or >".into(),
153                        Position::none(),
154                    ))
155                }
156            }
157        }
158
159        Ok(list)
160    }
161    pub(crate) fn parse_type_generics(&mut self) -> crate::core::result::Result<Vec<Type>> {
162        let mut type_generics = vec![];
163
164        if self.try_parse_token(Token::Less) {
165            loop {
166                let ty = self.parse_type()?;
167                type_generics.push(ty);
168                if !self.try_parse_token(Token::Comma) {
169                    break;
170                }
171            }
172            self.parse_special_token(Token::Greater)?;
173        }
174
175        Ok(type_generics)
176    }
177}
pipeline_script/parser/ptype.rs

pipeline_script/parser/
ptype.rs
