1use crate::try_parse;
2use dynamic::Type;
3
4use super::{Expr, Parser, Pattern, Span, expr::ExprKind, pattern::PatternKind};
5use anyhow::{Result, anyhow};
6use smol_str::SmolStr;
7
8#[derive(Debug, Clone)]
9pub struct Stmt {
10 pub kind: StmtKind,
11 pub span: Span,
12}
13
14#[derive(Debug, Clone)]
15pub enum StmtKind {
16 Let { pat: Pattern, value: Box<Stmt> },
17 Expr(Expr, bool),
18 Block(Vec<Stmt>),
19 Break,
20 Continue,
21 Return(Option<Expr>),
22 While { cond: Expr, body: Box<Stmt> },
23 Loop(Box<Stmt>),
24 For { pat: Pattern, range: Expr, body: Box<Stmt> },
25 Fn { name: SmolStr, generic_params: Vec<Type>, args: Vec<(SmolStr, Type)>, body: Box<Stmt>, is_pub: bool },
26 Struct { name: SmolStr, def: Type, is_pub: bool },
27 Impl { target: Type, body: Box<Stmt> },
28 If { cond: Expr, then_body: Box<Stmt>, else_body: Option<Box<Stmt>> },
29 Static { name: SmolStr, ty: Type, value: Option<Expr>, is_pub: bool },
30 Const { name: SmolStr, ty: Type, value: Expr, is_pub: bool },
31}
32
33impl Stmt {
34 pub fn new(kind: StmtKind, span: Span) -> Self {
35 Self { kind, span }
36 }
37
38 pub fn expr(&self) -> Option<Expr> {
39 if let StmtKind::Expr(expr, _) = &self.kind { Some(expr.clone()) } else { None }
40 }
41
42 pub fn is_return(&self) -> bool {
43 matches!(self.kind, StmtKind::Return(_))
44 }
45
46 pub fn last_return(&mut self) -> bool {
47 match &mut self.kind {
48 StmtKind::Block(stmts) => stmts.last_mut().map(|stmt| stmt.last_return()).unwrap_or(false),
49 StmtKind::If { then_body, else_body, .. } => {
50 let then_returns = then_body.last_return();
51 let else_returns = else_body.as_mut().map(|body| body.last_return()).unwrap_or(false);
52 then_returns && else_returns
53 }
54 StmtKind::Expr(e, close) => {
55 if !*close {
56 let span = e.span;
57 *self = Self::new(StmtKind::Return(Some(std::mem::take(e))), span);
58 true
59 } else {
60 false
61 }
62 }
63 StmtKind::Return(_) => true,
64 _ => false,
65 }
66 }
67
68 pub fn get_type(&self) -> Option<Type> {
69 match &self.kind {
70 StmtKind::Expr(expr, _) => Some(expr.get_type()),
71 StmtKind::Block(stmts) => stmts.last().and_then(|stmt| stmt.get_type()),
72 StmtKind::If { then_body, .. } => then_body.get_type(),
73 _ => None,
74 }
75 }
76
77 fn get_assign(idx: u32, expr: Expr) -> Self {
78 let span = expr.span;
79 Self::new(StmtKind::Expr(Expr::new(ExprKind::Binary { left: Box::new(Expr::new(ExprKind::Var(idx), span)), op: crate::BinaryOp::Assign, right: Box::new(expr) }, span), true), span)
80 }
81
82 fn get_idx_assign(pat: Expr, idx: usize, expr: Expr) -> Self {
83 let span = pat.span.merge(expr.span);
84 let right = Expr::new(ExprKind::Binary { left: Box::new(expr), op: crate::BinaryOp::Idx, right: Box::new(Expr::new(ExprKind::Value((idx as u32).into()), span)) }, span);
85 Self::new(StmtKind::Expr(Expr::new(ExprKind::Binary { left: Box::new(pat), op: crate::BinaryOp::Assign, right: Box::new(right) }, span), true), span)
86 }
87
88 pub fn bind_pattern(&mut self, pat: Pattern) -> Result<()> {
89 if let Some(expr) = self.expr() {
90 let stmt = match pat.kind {
91 PatternKind::Var { idx, ty } => {
92 if expr.get_type() != ty {
93 Self::get_assign(idx, Expr::new(ExprKind::Typed { value: Box::new(expr), ty }, pat.span))
94 } else {
95 Self::get_assign(idx, expr)
96 }
97 }
98 PatternKind::Tuple(list) | PatternKind::List { elems: list, has_rest: _ } => {
99 let mut stmts = Vec::new();
100 for (idx, p) in list.into_iter().enumerate() {
101 match p.expr() {
102 Ok(p) => stmts.push(Self::get_idx_assign(p, idx, expr.clone())),
103 Err(e) => return Err(e),
104 }
105 }
106 Self::new(StmtKind::Block(stmts), self.span)
107 }
108 p => return Err(anyhow!("不支持的模式绑定: {:?}", p)),
109 };
110 let _ = std::mem::replace(self, stmt);
111 } else {
112 match &mut self.kind {
113 StmtKind::Block(stmts) => {
114 if let Some(stmt) = stmts.last_mut() { stmt.bind_pattern(pat)?; }
115 }
116 StmtKind::If { then_body, else_body, .. } => {
117 then_body.bind_pattern(pat.clone())?;
118 if let Some(e) = else_body { e.bind_pattern(pat)?; }
119 }
120 _ => {}
121 }
122 }
123 Ok(())
124 }
125}
126
127use std::fmt;
128impl fmt::Display for Stmt {
129 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
130 match &self.kind {
131 StmtKind::Let { pat, value } => writeln!(f, "let {:?} = {}", pat, value)?,
132 StmtKind::Block(stmts) => stmts.iter().for_each(|s| {
133 let _ = write!(f, "{}", s);
134 }),
135 StmtKind::Expr(expr, close) => writeln!(f, "{:?}[{}]", expr, close)?,
136 StmtKind::Break => writeln!(f, "break")?,
137 StmtKind::Continue => writeln!(f, "continue")?,
138 StmtKind::Return(r) => writeln!(f, "return {:?}", r)?,
139 StmtKind::While { cond, body } => write!(f, "while {:?}\n{}", cond, body)?,
140 StmtKind::Loop(body) => write!(f, "loop\n{}", body)?,
141 StmtKind::For { pat, range, body } => writeln!(f, "for {:?} in {:?} \n{}", pat, range, body)?,
142 StmtKind::If { cond, then_body, else_body } => {
143 write!(f, "if {:?}\nthen-> {}\n", cond, then_body)?;
144 if let Some(e) = else_body {
145 writeln!(f, "{}", e)?;
146 }
147 }
148 StmtKind::Fn { name, generic_params, args, body, is_pub } => {
149 let generic_suffix = if generic_params.is_empty() { String::new() } else { format!("<{:?}>", generic_params) };
150 if *is_pub {
151 write!(f, "pub fn {:?}{} {:?}\n", name, generic_suffix, args)?
152 } else {
153 write!(f, "fn {:?}{} {:?}\n", name, generic_suffix, args)?
154 }
155 write!(f, "{}", body)?;
156 }
157 _ => {
158 write!(f, "(todo display: {:?})", self.kind)?
159 }
160 }
161 fmt::Result::Ok(())
162 }
163}
164
165impl Parser {
166 pub fn ident_typed(&mut self) -> Result<(SmolStr, Type)> {
167 let name = self.ident()?;
168 self.whitespace()?;
169 if self.take(b':').is_ok() { Ok((name, self.get_type()?)) } else { Ok((name, Type::Any)) }
170 }
171
172 pub fn ident_generic(&mut self) -> Result<(SmolStr, Vec<Type>)> {
173 self.whitespace()?;
174 let name = self.ident()?;
175 self.whitespace()?;
176 let params = if self.get()? == b'<' {
177 self.pos += 1;
178 crate::parse_list!(self, Vec::new(), b'>', b',', self.get_type_param()?)
179 } else {
180 Vec::new()
181 };
182 Ok((name, params))
183 }
184
185 pub fn block(&mut self) -> Result<Stmt> {
186 self.whitespace()?;
187 let start = self.current_pos();
188 if self.get()? == b'{' {
189 self.pos += 1;
190 self.push_decl_scope();
191 let result = (|| -> Result<Stmt> {
192 let body = crate::parse_list!(self, Vec::new(), b'}', 0, self.stmt(false)?);
193 Ok(Stmt::new(StmtKind::Block(body), self.span_from(start)))
194 })();
195 self.pop_decl_scope();
196 result
197 } else {
198 Err(anyhow!("not code block"))
199 }
200 }
201
202 pub fn if_block(&mut self) -> Result<Stmt> {
203 let start = self.spans.last().copied().unwrap_or_else(|| self.current_pos());
204 let cond = self.get_expr_without_struct_literal()?;
205 let then_body = Box::new(self.block()?);
206 self.whitespace()?;
207 let else_body = if self.keyword("else").is_ok() {
208 self.whitespace()?;
209 if self.keyword("if").is_ok() { self.if_block().map(Box::new).ok() } else { self.block().map(Box::new).ok() }
210 } else {
211 None
212 };
213 Ok(Stmt::new(StmtKind::If { cond, then_body, else_body }, Span::new(start, self.current_pos())))
214 }
215
216 pub fn stmt(&mut self, is_pub: bool) -> Result<Stmt> {
217 self.whitespace()?;
218 self.spans.push(self.pos);
219 let start = self.current_pos();
220 let stmt = if self.keyword("let").is_ok() {
221 let pat = self.pattern()?;
222 self.declare_pattern_symbols(&pat)?;
223 self.until(b'=')?;
224 self.whitespace()?;
225 let value = if self.get()? == b'{' {
226 if self.looks_like_dict() {
227 self.get_expr()?
228 } else {
229 return Err(anyhow!("代码块不能直接作为表达式，请使用 || {{ ... }} 包装为匿名函数"));
230 }
231 } else {
232 self.get_expr()?
233 };
234 self.whitespace()?;
235 let close = self.take(b';').is_ok();
236 let stmt = Stmt::new(StmtKind::Expr(value, close), Span::new(start, self.current_pos()));
237 Stmt::new(StmtKind::Let { pat, value: Box::new(stmt) }, Span::new(start, self.current_pos()))
238 } else if self.keyword("break").is_ok() {
239 self.until(b';')?;
240 Stmt::new(StmtKind::Break, Span::new(start, self.current_pos()))
241 } else if self.keyword("continue").is_ok() {
242 self.until(b';')?;
243 Stmt::new(StmtKind::Continue, Span::new(start, self.current_pos()))
244 } else if self.keyword("return").is_ok() {
245 self.whitespace()?;
246 let expr = if matches!(self.get(), Ok(b';' | b'}')) { None } else { Some(self.get_expr()?) };
247 self.whitespace()?;
248 if self.take(b';').is_err() && !matches!(self.get(), Ok(b'}')) {
249 self.until(b';')?;
250 }
251 Stmt::new(StmtKind::Return(expr), Span::new(start, self.current_pos()))
252 } else if self.keyword("if").is_ok() {
253 self.if_block()?
254 } else if self.keyword("loop").is_ok() {
255 Stmt::new(StmtKind::Loop(Box::new(self.block()?)), Span::new(start, self.current_pos()))
256 } else if self.keyword("while").is_ok() {
257 self.whitespace()?;
258 let cond = self.get_expr()?;
259 let body = Box::new(self.block()?);
260 Stmt::new(StmtKind::While { cond, body }, Span::new(start, self.current_pos()))
261 } else if self.keyword("for").is_ok() {
262 self.whitespace()?;
263 let pat = self.pattern()?;
264 self.whitespace()?;
265 self.keyword("in")?;
266 self.whitespace()?;
267 let range = self.get_expr()?;
268 self.push_decl_scope();
269 let result: Result<Stmt> = (|| {
270 self.declare_pattern_symbols(&pat)?;
271 let body = Box::new(self.block()?);
272 Ok(Stmt::new(StmtKind::For { pat, range, body }, Span::new(start, self.current_pos())))
273 })();
274 self.pop_decl_scope();
275 result?
276 } else if self.keyword("fn").is_ok() {
277 self.whitespace()?;
278 let (name, generic_params) = self.ident_generic()?;
279 self.declare_function_name(&name)?;
280 self.until(b'(')?;
281 let args = crate::parse_list!(self, Vec::new(), b')', b',', self.ident_typed()?);
282 let body = Box::new(self.function_body(&args)?);
283 Stmt::new(StmtKind::Fn { name, generic_params, args, body, is_pub }, Span::new(start, self.current_pos()))
284 } else if self.keyword("struct").is_ok() {
285 let (name, params) = self.ident_generic()?;
286 self.declare_symbol(&name)?;
287 if self.until(b'{').is_ok() {
288 let fields = crate::parse_list!(self, Vec::new(), b'}', b',', self.ident_typed()?);
289 if let Some(f) = fields.iter().find(|f| f.1.is_any()) {
290 return Err(anyhow!("字段 {} 的类型未知", f.0));
291 }
292 Stmt::new(StmtKind::Struct { name, def: Type::Struct { params, fields }, is_pub }, Span::new(start, self.current_pos()))
293 } else {
294 self.until(b';')?;
295 Stmt::new(StmtKind::Struct { name, def: Type::Struct { params, fields: Vec::new() }, is_pub }, Span::new(start, self.current_pos()))
296 }
297 } else if self.keyword("const").is_ok() {
298 self.whitespace()?;
299 let (name, ty) = self.ident_typed()?;
300 self.declare_symbol(&name)?;
301 self.until(b'=')?;
302 let value = self.get_expr()?;
303 self.until(b';')?;
304 Stmt::new(StmtKind::Const { name, ty, value, is_pub }, Span::new(start, self.current_pos()))
305 } else if self.keyword("static").is_ok() {
306 self.whitespace()?;
307 let (name, ty) = self.ident_typed()?;
308 self.declare_symbol(&name)?;
309 self.whitespace()?;
310 if self.take(b'=').is_ok() {
311 let expr = self.get_expr()?;
312 self.until(b';')?;
313 Stmt::new(StmtKind::Static { name, ty, value: Some(expr), is_pub }, Span::new(start, self.current_pos()))
314 } else {
315 self.until(b';')?;
316 Stmt::new(StmtKind::Static { name, ty, value: None, is_pub }, Span::new(start, self.current_pos()))
317 }
318 } else if self.keyword("impl").is_ok() {
319 self.whitespace()?;
320 let target = self.get_type()?;
321 Stmt::new(StmtKind::Impl { target, body: Box::new(self.impl_body()?) }, Span::new(start, self.current_pos()))
322 } else if self.keyword("pub").is_ok() {
323 self.stmt(true)?
324 } else {
325 let expr = if self.get()? == b'{' {
326 if self.looks_like_empty_dict() {
327 self.dict()?
328 } else if let Ok(block) = try_parse!(self, self.block()) {
329 let _ = self.spans.pop();
330 return Ok(block);
331 } else if let Ok(dict) = try_parse!(self, self.dict()) {
332 dict
333 } else {
334 let block = self.block()?;
335 let _ = self.spans.pop();
336 return Ok(block);
337 }
338 } else {
339 self.get_expr()?
340 };
341 self.whitespace()?;
342 if self.is_eof() {
343 Stmt::new(StmtKind::Expr(expr, false), Span::new(start, self.current_pos()))
344 } else if self.get()? == b';' {
345 self.pos += 1;
346 Stmt::new(StmtKind::Expr(expr, true), Span::new(start, self.current_pos()))
347 } else if self.get()? == b'}' {
348 Stmt::new(StmtKind::Expr(expr, false), Span::new(start, self.current_pos()))
349 } else {
350 return Err(anyhow!("未结束的表达式"));
351 }
352 };
353 let _ = self.spans.pop();
354 Ok(stmt)
355 }
356}