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

pipeline_script/parser/
ptype.rs
