scala/
parser.rs

1use crate::ast::*;
2use crate::token::{Span, Token, TokenKind};
3
4#[derive(Debug, Clone)]
5pub struct ParseError {
6    pub message: String,
7    pub span: Span,
8}
9
10impl ParseError {
11    pub fn new(message: impl Into<String>, span: Span) -> Self {
12        ParseError { message: message.into(), span }
13    }
14}
15
16impl std::fmt::Display for ParseError {
17    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
18        write!(f, "parse error at {}: {}", self.span, self.message)
19    }
20}
21
22impl std::error::Error for ParseError {}
23
24pub struct Parser {
25    tokens: Vec<Token>,
26    pos: usize,
27}
28
29impl Parser {
30    pub fn new(tokens: Vec<Token>) -> Self {
31        Parser { tokens, pos: 0 }
32    }
33
34    pub fn parse(tokens: Vec<Token>) -> Result<Vec<Stmt>, ParseError> {
35        let mut parser = Parser::new(tokens);
36        let mut stmts = Vec::new();
37        while !parser.is_at_end() {
38            if parser.peek_kind() == Some(&TokenKind::Semicolon) {
39                parser.advance();
40                continue;
41            }
42            if let Some(stmt) = parser.parse_top_level_stmt()? {
43                stmts.push(stmt);
44            }
45        }
46        Ok(stmts)
47    }
48
49    pub fn parse_expr(tokens: Vec<Token>) -> Result<Expr, ParseError> {
50        let mut parser = Parser::new(tokens);
51        let expr = parser.parse_expression()?;
52        Ok(expr)
53    }
54
55    fn is_at_end(&self) -> bool {
56        self.pos >= self.tokens.len() || self.peek_kind() == Some(&TokenKind::Eof)
57    }
58
59    fn peek(&self) -> &Token {
60        self.tokens.get(self.pos).unwrap_or_else(|| self.tokens.last().unwrap())
61    }
62
63    fn peek_kind(&self) -> Option<&TokenKind> {
64        if self.pos < self.tokens.len() {
65            Some(&self.tokens[self.pos].kind)
66        } else {
67            None
68        }
69    }
70
71    fn peek_at(&self, offset: usize) -> &Token {
72        let idx = self.pos + offset;
73        self.tokens.get(idx).unwrap_or_else(|| self.tokens.last().unwrap())
74    }
75
76    fn advance(&mut self) -> Token {
77        let tok = self.tokens.get(self.pos).cloned().unwrap_or_else(|| self.tokens.last().cloned().unwrap());
78        if self.pos < self.tokens.len() {
79            self.pos += 1;
80        }
81        tok
82    }
83
84    fn expect(&mut self, kind: &TokenKind) -> Result<Token, ParseError> {
85        let tok = self.peek().clone();
86        if &tok.kind == kind {
87            self.advance();
88            Ok(tok)
89        } else {
90            Err(ParseError::new(
91                format!("expected {}, got {}", kind, tok.kind),
92                tok.span,
93            ))
94        }
95    }
96
97    fn expect_identifier(&mut self) -> Result<(String, Span), ParseError> {
98        let tok = self.peek().clone();
99        match &tok.kind {
100            TokenKind::Identifier(name) => {
101                let name = name.clone();
102                self.advance();
103                Ok((name, tok.span))
104            }
105            _ => Err(ParseError::new(format!("expected identifier, got {}", tok.kind), tok.span)),
106        }
107    }
108
109    fn skip_semicolons(&mut self) {
110        while self.peek_kind() == Some(&TokenKind::Semicolon) {
111            self.advance();
112        }
113    }
114
115    fn current_span(&self) -> Span {
116        self.peek().span.clone()
117    }
118
119    fn lookahead_typed_params(&self) -> bool {
120        let offset = 0usize;
121        loop {
122            let tok = self.peek_at(offset);
123            match &tok.kind {
124                TokenKind::Identifier(_name) => {
125                    let next = self.peek_at(offset + 1);
126                    if next.kind == TokenKind::Colon {
127                        let after_colon = self.peek_at(offset + 2);
128                        match &after_colon.kind {
129                            TokenKind::Identifier(_) | TokenKind::LeftBracket => {
130                                return true;
131                            }
132                            _ => return false,
133                        }
134                    } else {
135                        return false;
136                    }
137                }
138                _ => return false,
139            }
140        }
141    }
142
143    fn parse_typed_params_list(&mut self) -> Result<Vec<Param>, ParseError> {
144        let mut params = Vec::new();
145        loop {
146            let (name, _) = self.expect_identifier()?;
147            let type_ann = if self.peek_kind() == Some(&TokenKind::Colon) {
148                self.advance();
149                Some(self.parse_type()?)
150            } else {
151                None
152            };
153            params.push(Param { name, type_ann, default: None });
154            if self.peek_kind() == Some(&TokenKind::Comma) {
155                self.advance();
156            } else {
157                break;
158            }
159        }
160        Ok(params)
161    }
162
163    fn parse_top_level_stmt(&mut self) -> Result<Option<Stmt>, ParseError> {
164        match self.peek_kind() {
165            Some(TokenKind::Package) => {
166                self.advance();
167                let mut path = vec![self.expect_identifier()?.0];
168                while self.peek_kind() == Some(&TokenKind::Dot) {
169                    self.advance();
170                    path.push(self.expect_identifier()?.0);
171                }
172                self.skip_semicolons();
173                Ok(None)
174            }
175            Some(TokenKind::Import) => {
176                let import = self.parse_import()?;
177                Ok(Some(import))
178            }
179            Some(TokenKind::Val) => {
180                let d = self.parse_val_decl()?;
181                self.skip_semicolons();
182                Ok(Some(d))
183            }
184            Some(TokenKind::Var) => {
185                let d = self.parse_var_decl()?;
186                self.skip_semicolons();
187                Ok(Some(d))
188            }
189            Some(TokenKind::Def) => {
190                let d = self.parse_def_decl()?;
191                self.skip_semicolons();
192                Ok(Some(Stmt::DefDecl(d)))
193            }
194            Some(TokenKind::Class) | Some(TokenKind::Case) => {
195                let d = self.parse_class_decl()?;
196                self.skip_semicolons();
197                Ok(Some(Stmt::ClassDecl(d)))
198            }
199            Some(TokenKind::Trait) => {
200                let d = self.parse_trait_decl()?;
201                self.skip_semicolons();
202                Ok(Some(Stmt::TraitDecl(d)))
203            }
204            Some(TokenKind::Object) => {
205                let d = self.parse_object_decl()?;
206                self.skip_semicolons();
207                Ok(Some(Stmt::ObjectDecl(d)))
208            }
209            Some(TokenKind::Type) => {
210                let d = self.parse_type_decl()?;
211                self.skip_semicolons();
212                Ok(Some(d))
213            }
214            Some(TokenKind::Abstract) => {
215                self.advance();
216                if self.peek_kind() == Some(&TokenKind::Class) {
217                    let mut d = self.parse_class_decl()?;
218                    d.is_abstract = true;
219                    self.skip_semicolons();
220                    Ok(Some(Stmt::ClassDecl(d)))
221                } else {
222                    Err(ParseError::new("expected 'class' after 'abstract'", self.current_span()))
223                }
224            }
225            Some(TokenKind::Sealed) => {
226                self.advance();
227                if self.peek_kind() == Some(&TokenKind::Trait) {
228                    self.parse_trait_decl().map(|d| {
229                        self.skip_semicolons();
230                        Some(Stmt::TraitDecl(d))
231                    })
232                } else if self.peek_kind() == Some(&TokenKind::Abstract) {
233                    self.advance();
234                    if self.peek_kind() == Some(&TokenKind::Class) {
235                        let mut d = self.parse_class_decl()?;
236                        d.is_abstract = true;
237                        self.skip_semicolons();
238                        Ok(Some(Stmt::ClassDecl(d)))
239                    } else {
240                        Err(ParseError::new("expected 'class'", self.current_span()))
241                    }
242                } else {
243                    Err(ParseError::new("expected 'trait' or 'abstract class' after 'sealed'", self.current_span()))
244                }
245            }
246            _ => {
247                let expr = self.parse_expression()?;
248                self.skip_semicolons();
249                Ok(Some(Stmt::Expr(expr)))
250            }
251        }
252    }
253
254    fn parse_import(&mut self) -> Result<Stmt, ParseError> {
255        let span = self.current_span();
256        self.advance(); // consume 'import'
257        let mut path = vec![self.expect_identifier()?.0];
258        while self.peek_kind() == Some(&TokenKind::Dot) {
259            self.advance();
260            if self.peek_kind() == Some(&TokenKind::Underscore) {
261                self.advance();
262                path.push("_".into());
263                return Ok(Stmt::ImportDecl {
264                    path,
265                    selectors: ImportSelectors::All,
266                    span,
267                });
268            }
269            path.push(self.expect_identifier()?.0);
270        }
271        let selectors = if self.peek_kind() == Some(&TokenKind::LeftBrace) {
272            self.advance();
273            let mut names = Vec::new();
274            loop {
275                names.push(self.expect_identifier()?.0);
276                if self.peek_kind() == Some(&TokenKind::Comma) {
277                    self.advance();
278                } else {
279                    break;
280                }
281            }
282            self.expect(&TokenKind::RightBrace)?;
283            ImportSelectors::Names(names)
284        } else {
285            ImportSelectors::All
286        };
287        Ok(Stmt::ImportDecl { path, selectors, span })
288    }
289
290    fn parse_val_decl(&mut self) -> Result<Stmt, ParseError> {
291        let span = self.current_span();
292        self.advance(); // consume 'val'
293        let pattern = self.parse_pattern()?;
294        let type_ann = if self.peek_kind() == Some(&TokenKind::Colon) {
295            self.advance();
296            Some(self.parse_type()?)
297        } else {
298            None
299        };
300        self.expect(&TokenKind::Equals)?;
301        let value = self.parse_expression()?;
302        Ok(Stmt::ValDecl { pattern, type_ann, value, span })
303    }
304
305    fn parse_var_decl(&mut self) -> Result<Stmt, ParseError> {
306        let span = self.current_span();
307        self.advance(); // consume 'var'
308        let pattern = self.parse_pattern()?;
309        let type_ann = if self.peek_kind() == Some(&TokenKind::Colon) {
310            self.advance();
311            Some(self.parse_type()?)
312        } else {
313            None
314        };
315        self.expect(&TokenKind::Equals)?;
316        let value = self.parse_expression()?;
317        Ok(Stmt::VarDecl { pattern, type_ann, value, span })
318    }
319
320    fn parse_def_decl(&mut self) -> Result<DefDecl, ParseError> {
321        let span = self.current_span();
322        self.advance(); // consume 'def'
323        let (name, _) = self.expect_identifier()?;
324        let type_params = self.parse_type_params_opt()?;
325        let mut params = if self.peek_kind() == Some(&TokenKind::LeftParen) {
326            self.parse_params()?
327        } else {
328            Vec::new()
329        };
330
331        while self.peek_kind() == Some(&TokenKind::LeftParen) {
332            let extra_params = self.parse_params()?;
333            let outer_body_span = self.current_span();
334            let ret_type = if self.peek_kind() == Some(&TokenKind::Colon) {
335                self.advance();
336                let t = self.parse_type()?;
337                Some(t)
338            } else {
339                None
340            };
341            let inner_body = if self.peek_kind() == Some(&TokenKind::Equals) {
342                self.advance();
343                self.parse_expression()?
344            } else if self.peek_kind() == Some(&TokenKind::LeftBrace) {
345                self.parse_block()?
346            } else {
347                break;
348            };
349            let _param_names: Vec<String> = extra_params.iter().map(|p| p.name.clone()).collect();
350            params.push(Param {
351                name: format!("__curried__{}", extra_params.len()),
352                type_ann: None,
353                default: None,
354            });
355            let fn_val = Expr::Lambda {
356                params: extra_params,
357                body: Box::new(inner_body),
358                span: outer_body_span,
359            };
360            return Ok(DefDecl {
361                name,
362                type_params,
363                params,
364                return_type: ret_type,
365                body: fn_val,
366                span,
367            });
368        }
369
370        let return_type = if self.peek_kind() == Some(&TokenKind::Colon) {
371            self.advance();
372            Some(self.parse_type()?)
373        } else {
374            None
375        };
376        let body = if self.peek_kind() == Some(&TokenKind::Equals) {
377            self.advance();
378            self.parse_expression()?
379        } else if self.peek_kind() == Some(&TokenKind::LeftBrace) {
380            self.parse_block()?
381        } else {
382            Expr::Literal { value: Literal::Unit, span: self.current_span() }
383        };
384        Ok(DefDecl { name, type_params, params, return_type, body, span })
385    }
386
387    fn parse_class_decl(&mut self) -> Result<ClassDecl, ParseError> {
388        let span = self.current_span();
389        let is_case = if self.peek_kind() == Some(&TokenKind::Case) {
390            self.advance();
391            true
392        } else {
393            false
394        };
395        self.advance(); // consume 'class'
396        let (name, _) = self.expect_identifier()?;
397        let type_params = self.parse_type_params_opt()?;
398        let ctor_params = if self.peek_kind() == Some(&TokenKind::LeftParen) {
399            self.parse_params()?
400        } else {
401            Vec::new()
402        };
403        let mut parents = Vec::new();
404        if self.peek_kind() == Some(&TokenKind::Extends) {
405            self.advance();
406            let (parent_name, _) = self.expect_identifier()?;
407            let parent_args = if self.peek_kind() == Some(&TokenKind::LeftParen) {
408                self.parse_arguments()?
409            } else {
410                Vec::new()
411            };
412            parents.push((parent_name, parent_args));
413            while self.peek_kind() == Some(&TokenKind::With) {
414                self.advance();
415                let (parent_name, _) = self.expect_identifier()?;
416                let parent_args = if self.peek_kind() == Some(&TokenKind::LeftParen) {
417                    self.parse_arguments()?
418                } else {
419                    Vec::new()
420                };
421                parents.push((parent_name, parent_args));
422            }
423        }
424        let body = if self.peek_kind() == Some(&TokenKind::LeftBrace) {
425            self.parse_class_body()?
426        } else {
427            Vec::new()
428        };
429        Ok(ClassDecl {
430            name, type_params, ctor_params, parents, body, is_case, is_abstract: false, span,
431        })
432    }
433
434    fn parse_trait_decl(&mut self) -> Result<TraitDecl, ParseError> {
435        let span = self.current_span();
436        self.advance(); // consume 'trait'
437        let (name, _) = self.expect_identifier()?;
438        let type_params = self.parse_type_params_opt()?;
439        let mut parents = Vec::new();
440        if self.peek_kind() == Some(&TokenKind::Extends) {
441            self.advance();
442            let (parent_name, _) = self.expect_identifier()?;
443            parents.push(parent_name);
444            while self.peek_kind() == Some(&TokenKind::With) {
445                self.advance();
446                let (parent_name, _) = self.expect_identifier()?;
447                parents.push(parent_name);
448            }
449        }
450        let body = if self.peek_kind() == Some(&TokenKind::LeftBrace) {
451            self.parse_class_body()?
452        } else {
453            Vec::new()
454        };
455        Ok(TraitDecl { name, type_params, parents, body, span })
456    }
457
458    fn parse_object_decl(&mut self) -> Result<ObjectDecl, ParseError> {
459        let span = self.current_span();
460        self.advance(); // consume 'object'
461        let (name, _) = self.expect_identifier()?;
462        let mut parents = Vec::new();
463        if self.peek_kind() == Some(&TokenKind::Extends) {
464            self.advance();
465            let (parent_name, _) = self.expect_identifier()?;
466            let parent_args = if self.peek_kind() == Some(&TokenKind::LeftParen) {
467                self.parse_arguments()?
468            } else {
469                Vec::new()
470            };
471            parents.push((parent_name, parent_args));
472            while self.peek_kind() == Some(&TokenKind::With) {
473                self.advance();
474                let (parent_name, _) = self.expect_identifier()?;
475                let parent_args = if self.peek_kind() == Some(&TokenKind::LeftParen) {
476                    self.parse_arguments()?
477                } else {
478                    Vec::new()
479                };
480                parents.push((parent_name, parent_args));
481            }
482        }
483        let body = if self.peek_kind() == Some(&TokenKind::LeftBrace) {
484            self.parse_class_body()?
485        } else {
486            Vec::new()
487        };
488        Ok(ObjectDecl { name, parents, body, span })
489    }
490
491    fn parse_type_decl(&mut self) -> Result<Stmt, ParseError> {
492        let span = self.current_span();
493        self.advance(); // consume 'type'
494        let (name, _) = self.expect_identifier()?;
495        let type_params = self.parse_type_params_opt()?;
496        self.expect(&TokenKind::Equals)?;
497        let rhs = self.parse_type()?;
498        Ok(Stmt::TypeDecl { name, type_params, rhs, span })
499    }
500
501    fn parse_class_body(&mut self) -> Result<Vec<Stmt>, ParseError> {
502        self.expect(&TokenKind::LeftBrace)?;
503        let mut stmts = Vec::new();
504        while self.peek_kind() != Some(&TokenKind::RightBrace) && !self.is_at_end() {
505            if self.peek_kind() == Some(&TokenKind::Semicolon) {
506                self.advance();
507                continue;
508            }
509            match self.peek_kind() {
510                Some(TokenKind::Val) => {
511                    stmts.push(self.parse_val_decl()?);
512                }
513                Some(TokenKind::Var) => {
514                    stmts.push(self.parse_var_decl()?);
515                }
516                Some(TokenKind::Def) => {
517                    stmts.push(Stmt::DefDecl(self.parse_def_decl()?));
518                }
519                Some(TokenKind::This) if self.peek_at(1).kind == TokenKind::LeftParen => {
520                    self.advance(); // this
521                    let _params = self.parse_params()?;
522                    let _body = if self.peek_kind() == Some(&TokenKind::Equals) {
523                        self.advance();
524                        Some(self.parse_expression()?)
525                    } else {
526                        None
527                    };
528                }
529                Some(TokenKind::Type) => {
530                    stmts.push(self.parse_type_decl()?);
531                }
532                Some(TokenKind::Override) => {
533                    self.advance();
534                    if self.peek_kind() == Some(&TokenKind::Def) {
535                        stmts.push(Stmt::DefDecl(self.parse_def_decl()?));
536                    }
537                }
538                Some(TokenKind::Private) | Some(TokenKind::Protected) => {
539                    self.advance();
540                    if self.peek_kind() == Some(&TokenKind::Def) {
541                        stmts.push(Stmt::DefDecl(self.parse_def_decl()?));
542                    } else if self.peek_kind() == Some(&TokenKind::Val) {
543                        stmts.push(self.parse_val_decl()?);
544                    } else if self.peek_kind() == Some(&TokenKind::Var) {
545                        stmts.push(self.parse_var_decl()?);
546                    }
547                }
548                _ => {
549                    let expr = self.parse_expression()?;
550                    stmts.push(Stmt::Expr(expr));
551                }
552            }
553            self.skip_semicolons();
554        }
555        self.expect(&TokenKind::RightBrace)?;
556        Ok(stmts)
557    }
558
559    fn parse_params(&mut self) -> Result<Vec<Param>, ParseError> {
560        self.expect(&TokenKind::LeftParen)?;
561        let mut params = Vec::new();
562        while self.peek_kind() != Some(&TokenKind::RightParen) {
563            if self.peek_kind() == Some(&TokenKind::Val) || self.peek_kind() == Some(&TokenKind::Var) {
564                self.advance();
565            }
566            let (name, _) = self.expect_identifier()?;
567            let type_ann = if self.peek_kind() == Some(&TokenKind::Colon) {
568                self.advance();
569                if self.peek_kind() == Some(&TokenKind::Star) {
570                    self.advance();
571                    Some(TypeExpr::Parameterized {
572                        base: Box::new(TypeExpr::simple("Seq")),
573                        args: vec![self.parse_type()?],
574                        span: Span::zero(),
575                    })
576                } else {
577                    Some(self.parse_type()?)
578                }
579            } else {
580                None
581            };
582            let default = if self.peek_kind() == Some(&TokenKind::Equals) {
583                self.advance();
584                Some(self.parse_expression()?)
585            } else {
586                None
587            };
588            params.push(Param { name, type_ann, default });
589            if self.peek_kind() == Some(&TokenKind::Comma) {
590                self.advance();
591            } else {
592                break;
593            }
594        }
595        self.expect(&TokenKind::RightParen)?;
596        Ok(params)
597    }
598
599    fn parse_type_params_opt(&mut self) -> Result<Vec<TypeParam>, ParseError> {
600        if self.peek_kind() != Some(&TokenKind::LeftBracket) {
601            return Ok(Vec::new());
602        }
603        self.advance();
604        let mut params = Vec::new();
605        while self.peek_kind() != Some(&TokenKind::RightBracket) {
606            let variance = if self.peek_kind() == Some(&TokenKind::Plus) {
607                self.advance();
608                Variance::Covariant
609            } else if self.peek_kind() == Some(&TokenKind::Minus) {
610                self.advance();
611                Variance::Contravariant
612            } else {
613                Variance::Invariant
614            };
615            let (name, _) = self.expect_identifier()?;
616            let upper_bound = if self.peek_kind() == Some(&TokenKind::LessThan) {
617                self.advance();
618                Some(self.parse_type()?)
619            } else {
620                None
621            };
622            let lower_bound = if self.peek_kind() == Some(&TokenKind::GreaterThan) {
623                self.advance();
624                Some(self.parse_type()?)
625            } else {
626                None
627            };
628            params.push(TypeParam { name, variance, upper_bound, lower_bound });
629            if self.peek_kind() == Some(&TokenKind::Comma) {
630                self.advance();
631            } else {
632                break;
633            }
634        }
635        self.expect(&TokenKind::RightBracket)?;
636        Ok(params)
637    }
638
639    fn parse_type(&mut self) -> Result<TypeExpr, ParseError> {
640        let span = self.current_span();
641        let mut ty = self.parse_simple_type()?;
642        if self.peek_kind() == Some(&TokenKind::Arrow) {
643            self.advance();
644            let result = self.parse_type()?;
645            let params = match ty {
646                TypeExpr::Tuple { elements, .. } if elements.len() > 1 => elements,
647                other => vec![other],
648            };
649            ty = TypeExpr::Function {
650                params,
651                result: Box::new(result),
652                span,
653            };
654        }
655        Ok(ty)
656    }
657
658    fn parse_simple_type(&mut self) -> Result<TypeExpr, ParseError> {
659        let span = self.current_span();
660        if self.peek_kind() == Some(&TokenKind::LeftParen) {
661            self.advance();
662            if self.peek_kind() == Some(&TokenKind::RightParen) {
663                self.advance();
664                return Ok(TypeExpr::Tuple { elements: vec![], span });
665            }
666            let first = self.parse_type()?;
667            if self.peek_kind() == Some(&TokenKind::Comma) {
668                let mut elements = vec![first];
669                while self.peek_kind() == Some(&TokenKind::Comma) {
670                    self.advance();
671                    elements.push(self.parse_type()?);
672                }
673                self.expect(&TokenKind::RightParen)?;
674                return Ok(TypeExpr::Tuple { elements, span });
675            }
676            self.expect(&TokenKind::RightParen)?;
677            return Ok(first);
678        }
679
680        if self.peek_kind() == Some(&TokenKind::Underscore) {
681            self.advance();
682            return Ok(TypeExpr::Wildcard {
683                upper: None,
684                lower: None,
685                span,
686            });
687        }
688
689        let (name, _) = self.expect_identifier()?;
690        let mut ty = TypeExpr::Simple { name, span: span.clone() };
691
692        if self.peek_kind() == Some(&TokenKind::LeftBracket) {
693            self.advance();
694            let mut args = Vec::new();
695            while self.peek_kind() != Some(&TokenKind::RightBracket) {
696                args.push(self.parse_type()?);
697                if self.peek_kind() == Some(&TokenKind::Comma) {
698                    self.advance();
699                } else {
700                    break;
701                }
702            }
703            self.expect(&TokenKind::RightBracket)?;
704            ty = TypeExpr::Parameterized { base: Box::new(ty), args, span };
705        }
706
707        Ok(ty)
708    }
709
710    fn parse_arguments(&mut self) -> Result<Vec<Expr>, ParseError> {
711        self.expect(&TokenKind::LeftParen)?;
712        let mut args = Vec::new();
713        while self.peek_kind() != Some(&TokenKind::RightParen) {
714            args.push(self.parse_expression()?);
715            if self.peek_kind() == Some(&TokenKind::Comma) {
716                self.advance();
717            } else {
718                break;
719            }
720        }
721        self.expect(&TokenKind::RightParen)?;
722        Ok(args)
723    }
724
725    fn parse_expression(&mut self) -> Result<Expr, ParseError> {
726        let _span = self.current_span();
727        let expr = self.parse_assignment()?;
728        Ok(expr)
729    }
730
731    fn parse_assignment(&mut self) -> Result<Expr, ParseError> {
732        let span = self.current_span();
733        let expr = self.parse_or()?;
734        if self.peek_kind() == Some(&TokenKind::Equals) {
735            self.advance();
736            let value = self.parse_assignment()?;
737            Ok(Expr::Assign {
738                target: Box::new(expr),
739                value: Box::new(value),
740                span,
741            })
742        } else {
743            Ok(expr)
744        }
745    }
746
747    fn parse_or(&mut self) -> Result<Expr, ParseError> {
748        let span = self.current_span();
749        let mut left = self.parse_and()?;
750        while self.peek_kind() == Some(&TokenKind::PipePipe) {
751            self.advance();
752            let right = self.parse_and()?;
753            left = Expr::Binary {
754                left: Box::new(left),
755                op: BinOp::Or,
756                right: Box::new(right),
757                span,
758            };
759        }
760        Ok(left)
761    }
762
763    fn parse_and(&mut self) -> Result<Expr, ParseError> {
764        let span = self.current_span();
765        let mut left = self.parse_equality()?;
766        while self.peek_kind() == Some(&TokenKind::AmpersandAmpersand) {
767            self.advance();
768            let right = self.parse_equality()?;
769            left = Expr::Binary {
770                left: Box::new(left),
771                op: BinOp::And,
772                right: Box::new(right),
773                span,
774            };
775        }
776        Ok(left)
777    }
778
779    fn parse_equality(&mut self) -> Result<Expr, ParseError> {
780        let span = self.current_span();
781        let mut left = self.parse_comparison()?;
782        loop {
783            let op = match self.peek_kind() {
784                Some(TokenKind::EqualsEquals) => BinOp::Eq,
785                Some(TokenKind::BangEquals) => BinOp::Neq,
786                _ => break,
787            };
788            self.advance();
789            let right = self.parse_comparison()?;
790            left = Expr::Binary {
791                left: Box::new(left),
792                op,
793                right: Box::new(right),
794                span,
795            };
796        }
797        Ok(left)
798    }
799
800    fn parse_comparison(&mut self) -> Result<Expr, ParseError> {
801        let span = self.current_span();
802        let mut left = self.parse_additive()?;
803        loop {
804            let op = match self.peek_kind() {
805                Some(TokenKind::LessThan) => BinOp::Lt,
806                Some(TokenKind::GreaterThan) => BinOp::Gt,
807                Some(TokenKind::LessEquals) => BinOp::Leq,
808                Some(TokenKind::GreaterEquals) => BinOp::Geq,
809                _ => break,
810            };
811            self.advance();
812            let right = self.parse_additive()?;
813            left = Expr::Binary {
814                left: Box::new(left),
815                op,
816                right: Box::new(right),
817                span,
818            };
819        }
820        Ok(left)
821    }
822
823    fn parse_additive(&mut self) -> Result<Expr, ParseError> {
824        let span = self.current_span();
825        let mut left = self.parse_multiplicative()?;
826        loop {
827            let op = match self.peek_kind() {
828                Some(TokenKind::Plus) => BinOp::Add,
829                Some(TokenKind::Minus) => BinOp::Sub,
830                Some(TokenKind::Pipe) => BinOp::BitOr,
831                Some(TokenKind::Caret) => BinOp::BitXor,
832                _ => break,
833            };
834            self.advance();
835            let right = self.parse_multiplicative()?;
836            left = Expr::Binary {
837                left: Box::new(left),
838                op,
839                right: Box::new(right),
840                span,
841            };
842        }
843        Ok(left)
844    }
845
846    fn parse_multiplicative(&mut self) -> Result<Expr, ParseError> {
847        let span = self.current_span();
848        let mut left = self.parse_shift()?;
849        loop {
850            let op = match self.peek_kind() {
851                Some(TokenKind::Star) => BinOp::Mul,
852                Some(TokenKind::Slash) => BinOp::Div,
853                Some(TokenKind::Percent) => BinOp::Mod,
854                Some(TokenKind::Ampersand) => BinOp::BitAnd,
855                _ => break,
856            };
857            self.advance();
858            let right = self.parse_shift()?;
859            left = Expr::Binary {
860                left: Box::new(left),
861                op,
862                right: Box::new(right),
863                span,
864            };
865        }
866        Ok(left)
867    }
868
869    fn parse_shift(&mut self) -> Result<Expr, ParseError> {
870        let span = self.current_span();
871        let mut left = self.parse_unary()?;
872        loop {
873            let op = match self.peek_kind() {
874                Some(TokenKind::LeftShift) => BinOp::LeftShift,
875                Some(TokenKind::RightShift) => BinOp::RightShift,
876                Some(TokenKind::UnsignedRightShift) => BinOp::UnsignedRightShift,
877                _ => break,
878            };
879            self.advance();
880            let right = self.parse_unary()?;
881            left = Expr::Binary {
882                left: Box::new(left),
883                op,
884                right: Box::new(right),
885                span,
886            };
887        }
888        Ok(left)
889    }
890
891    fn parse_unary(&mut self) -> Result<Expr, ParseError> {
892        let span = self.current_span();
893        match self.peek_kind() {
894            Some(TokenKind::Minus) => {
895                self.advance();
896                let operand = self.parse_unary()?;
897                Ok(Expr::Unary {
898                    op: UnaryOp::Negate,
899                    operand: Box::new(operand),
900                    span,
901                })
902            }
903            Some(TokenKind::Plus) => {
904                self.advance();
905                let operand = self.parse_unary()?;
906                Ok(Expr::Unary {
907                    op: UnaryOp::Positive,
908                    operand: Box::new(operand),
909                    span,
910                })
911            }
912            Some(TokenKind::Exclaim) => {
913                self.advance();
914                let operand = self.parse_unary()?;
915                Ok(Expr::Unary {
916                    op: UnaryOp::Not,
917                    operand: Box::new(operand),
918                    span,
919                })
920            }
921            Some(TokenKind::Tilde) => {
922                self.advance();
923                let operand = self.parse_unary()?;
924                Ok(Expr::Unary {
925                    op: UnaryOp::BitNot,
926                    operand: Box::new(operand),
927                    span,
928                })
929            }
930            _ => self.parse_postfix(),
931        }
932    }
933
934    fn parse_postfix(&mut self) -> Result<Expr, ParseError> {
935        let mut expr = self.parse_primary()?;
936        loop {
937            let span = self.current_span();
938            match self.peek_kind() {
939                Some(TokenKind::Dot) => {
940                    self.advance();
941                    let (name, _) = self.expect_identifier()?;
942                    if self.peek_kind() == Some(&TokenKind::LeftParen) {
943                        let args = self.parse_arguments()?;
944                        expr = Expr::MethodCall {
945                            receiver: Box::new(expr),
946                            method: name,
947                            args,
948                            span,
949                        };
950                    } else if self.peek_kind() == Some(&TokenKind::Underscore) {
951                        self.advance();
952                    } else {
953                        expr = Expr::FieldAccess {
954                            receiver: Box::new(expr),
955                            field: name,
956                            span,
957                        };
958                    }
959                }
960                Some(TokenKind::LeftParen) => {
961                    let args = self.parse_arguments()?;
962                    expr = Expr::Apply {
963                        func: Box::new(expr),
964                        args,
965                        span,
966                    };
967                }
968                Some(TokenKind::UnitLiteral) => {
969                    self.advance();
970                    expr = Expr::Apply {
971                        func: Box::new(expr),
972                        args: vec![],
973                        span,
974                    };
975                }
976                Some(TokenKind::LeftBracket) => {
977                    self.advance();
978                    let mut type_args = Vec::new();
979                    while self.peek_kind() != Some(&TokenKind::RightBracket) {
980                        type_args.push(self.parse_type()?);
981                        if self.peek_kind() == Some(&TokenKind::Comma) {
982                            self.advance();
983                        } else {
984                            break;
985                        }
986                    }
987                    self.expect(&TokenKind::RightBracket)?;
988                    expr = Expr::TypeApply {
989                        expr: Box::new(expr),
990                        type_args,
991                        span,
992                    };
993                }
994                Some(TokenKind::Match) => {
995                    self.advance();
996                    let cases = self.parse_match_cases()?;
997                    expr = Expr::Match {
998                        scrutinee: Box::new(expr),
999                        cases,
1000                        span,
1001                    };
1002                }
1003                _ => break,
1004            }
1005        }
1006        Ok(expr)
1007    }
1008
1009    fn parse_primary(&mut self) -> Result<Expr, ParseError> {
1010        let span = self.current_span();
1011        match self.peek_kind().cloned() {
1012            Some(TokenKind::IntLiteral(v)) => {
1013                self.advance();
1014                Ok(Expr::Literal { value: Literal::Int(v), span })
1015            }
1016            Some(TokenKind::LongLiteral(v)) => {
1017                self.advance();
1018                Ok(Expr::Literal { value: Literal::Long(v), span })
1019            }
1020            Some(TokenKind::DoubleLiteral(v)) => {
1021                self.advance();
1022                Ok(Expr::Literal { value: Literal::Double(v), span })
1023            }
1024            Some(TokenKind::FloatLiteral(v)) => {
1025                self.advance();
1026                Ok(Expr::Literal { value: Literal::Float(v), span })
1027            }
1028            Some(TokenKind::BoolLiteral(b)) => {
1029                self.advance();
1030                Ok(Expr::Literal { value: Literal::Bool(b), span })
1031            }
1032            Some(TokenKind::StringLiteral(s)) => {
1033                self.advance();
1034                Ok(Expr::Literal { value: Literal::String(s), span })
1035            }
1036            Some(TokenKind::CharLiteral(c)) => {
1037                self.advance();
1038                Ok(Expr::Literal { value: Literal::Char(c), span })
1039            }
1040            Some(TokenKind::NullLiteral) => {
1041                self.advance();
1042                Ok(Expr::Literal { value: Literal::Null, span })
1043            }
1044            Some(TokenKind::UnitLiteral) => {
1045                self.advance();
1046                if self.peek_kind() == Some(&TokenKind::Arrow) {
1047                    self.advance();
1048                    let body = self.parse_expression()?;
1049                    return Ok(Expr::Lambda {
1050                        params: vec![],
1051                        body: Box::new(body),
1052                        span,
1053                    });
1054                }
1055                Ok(Expr::Literal { value: Literal::Unit, span })
1056            }
1057            Some(TokenKind::Identifier(name)) => {
1058                self.advance();
1059                let name_clone = name.clone();
1060                if self.peek_kind() == Some(&TokenKind::Arrow) {
1061                    self.advance();
1062                    let body = self.parse_expression()?;
1063                    return Ok(Expr::Lambda {
1064                        params: vec![Param {
1065                            name: name_clone,
1066                            type_ann: None,
1067                            default: None,
1068                        }],
1069                        body: Box::new(body),
1070                        span,
1071                    });
1072                }
1073                Ok(Expr::Identifier { name, span })
1074            }
1075            Some(TokenKind::Underscore) => {
1076                self.advance();
1077                if self.peek_kind() == Some(&TokenKind::Arrow) {
1078                    self.advance();
1079                    let body = self.parse_expression()?;
1080                    return Ok(Expr::Lambda {
1081                        params: vec![Param {
1082                            name: "_".into(),
1083                            type_ann: None,
1084                            default: None,
1085                        }],
1086                        body: Box::new(body),
1087                        span,
1088                    });
1089                }
1090                Ok(Expr::Identifier { name: "_".into(), span })
1091            }
1092            Some(TokenKind::This) => {
1093                self.advance();
1094                Ok(Expr::This(span))
1095            }
1096            Some(TokenKind::Super) => {
1097                self.advance();
1098                Ok(Expr::Super(span))
1099            }
1100            Some(TokenKind::If) => self.parse_if(),
1101            Some(TokenKind::While) => self.parse_while(),
1102            Some(TokenKind::Do) => self.parse_do_while(),
1103            Some(TokenKind::For) => self.parse_for(),
1104            Some(TokenKind::Return) => {
1105                self.advance();
1106                let value = if !matches!(self.peek_kind(),
1107                    Some(TokenKind::Semicolon) |
1108                    Some(TokenKind::RightBrace) |
1109                    Some(TokenKind::Eof)
1110                ) {
1111                    Some(Box::new(self.parse_expression()?))
1112                } else {
1113                    None
1114                };
1115                Ok(Expr::Return { value, span })
1116            }
1117            Some(TokenKind::Throw) => {
1118                self.advance();
1119                let value = self.parse_expression()?;
1120                Ok(Expr::Throw { value: Box::new(value), span })
1121            }
1122            Some(TokenKind::Try) => self.parse_try(),
1123            Some(TokenKind::New) => self.parse_new(),
1124            Some(TokenKind::LeftBrace) => self.parse_block(),
1125            Some(TokenKind::LeftParen) => {
1126                self.advance();
1127                if self.peek_kind() == Some(&TokenKind::RightParen) {
1128                    self.advance();
1129                    if self.peek_kind() == Some(&TokenKind::Arrow) {
1130                        self.advance();
1131                        let body = self.parse_expression()?;
1132                        return Ok(Expr::Lambda {
1133                            params: vec![],
1134                            body: Box::new(body),
1135                            span,
1136                        });
1137                    }
1138                    return Ok(Expr::Literal { value: Literal::Unit, span });
1139                }
1140                let is_typed_params = self.lookahead_typed_params();
1141                if is_typed_params {
1142                    let params = self.parse_typed_params_list()?;
1143                    self.expect(&TokenKind::RightParen)?;
1144                    self.expect(&TokenKind::Arrow)?;
1145                    let body = self.parse_expression()?;
1146                    return Ok(Expr::Lambda { params, body: Box::new(body), span });
1147                }
1148                let first = self.parse_expression()?;
1149                if self.peek_kind() == Some(&TokenKind::Comma) {
1150                    let mut elements = vec![first];
1151                    while self.peek_kind() == Some(&TokenKind::Comma) {
1152                        self.advance();
1153                        elements.push(self.parse_expression()?);
1154                    }
1155                    self.expect(&TokenKind::RightParen)?;
1156                    if self.peek_kind() == Some(&TokenKind::Arrow) {
1157                        self.advance();
1158                        let body = self.parse_expression()?;
1159                        let params: Vec<Param> = elements.iter().map(|e| Param {
1160                            name: match e {
1161                                Expr::Identifier { name, .. } => name.clone(),
1162                                _ => "_".into(),
1163                            },
1164                            type_ann: None,
1165                            default: None,
1166                        }).collect();
1167                        return Ok(Expr::Lambda { params, body: Box::new(body), span });
1168                    }
1169                    return Ok(Expr::Tuple { elements, span });
1170                }
1171                self.expect(&TokenKind::RightParen)?;
1172                if self.peek_kind() == Some(&TokenKind::Arrow) {
1173                    self.advance();
1174                    let body = self.parse_expression()?;
1175                    Ok(Expr::Lambda {
1176                        params: vec![Param {
1177                            name: match &first {
1178                                Expr::Identifier { name, .. } => name.clone(),
1179                                _ => "_".into(),
1180                            },
1181                            type_ann: None,
1182                            default: None,
1183                        }],
1184                        body: Box::new(body),
1185                        span,
1186                    })
1187                } else {
1188                    Ok(Expr::Paren { expr: Box::new(first), span })
1189                }
1190            }
1191            Some(TokenKind::Operator(op)) if op == "::" || op == ":+:" || op == "#::" => {
1192                self.advance();
1193                let right = self.parse_postfix()?;
1194                Ok(Expr::MethodCall {
1195                    receiver: Box::new(right),
1196                    method: op,
1197                    args: vec![],
1198                    span,
1199                })
1200            }
1201            _ => {
1202                let tok = self.peek().clone();
1203                Err(ParseError::new(
1204                    format!("unexpected token: {}", tok.kind),
1205                    tok.span,
1206                ))
1207            }
1208        }
1209    }
1210
1211    fn parse_if(&mut self) -> Result<Expr, ParseError> {
1212        let span = self.current_span();
1213        self.advance(); // consume 'if'
1214        self.expect(&TokenKind::LeftParen)?;
1215        let cond = self.parse_expression()?;
1216        self.expect(&TokenKind::RightParen)?;
1217        let then_branch = self.parse_expression()?;
1218        let else_branch = if self.peek_kind() == Some(&TokenKind::Else) {
1219            self.advance();
1220            Some(Box::new(self.parse_expression()?))
1221        } else {
1222            None
1223        };
1224        Ok(Expr::If {
1225            cond: Box::new(cond),
1226            then_branch: Box::new(then_branch),
1227            else_branch,
1228            span,
1229        })
1230    }
1231
1232    fn parse_while(&mut self) -> Result<Expr, ParseError> {
1233        let span = self.current_span();
1234        self.advance(); // consume 'while'
1235        self.expect(&TokenKind::LeftParen)?;
1236        let cond = self.parse_expression()?;
1237        self.expect(&TokenKind::RightParen)?;
1238        let body = self.parse_expression()?;
1239        Ok(Expr::While {
1240            cond: Box::new(cond),
1241            body: Box::new(body),
1242            span,
1243        })
1244    }
1245
1246    fn parse_do_while(&mut self) -> Result<Expr, ParseError> {
1247        let span = self.current_span();
1248        self.advance(); // consume 'do'
1249        let body = self.parse_expression()?;
1250        self.expect(&TokenKind::While)?;
1251        self.expect(&TokenKind::LeftParen)?;
1252        let cond = self.parse_expression()?;
1253        self.expect(&TokenKind::RightParen)?;
1254        Ok(Expr::DoWhile {
1255            body: Box::new(body),
1256            cond: Box::new(cond),
1257            span,
1258        })
1259    }
1260
1261    fn parse_for(&mut self) -> Result<Expr, ParseError> {
1262        let span = self.current_span();
1263        self.advance(); // consume 'for'
1264        let (enums, _enum_span) = if self.peek_kind() == Some(&TokenKind::LeftBrace) {
1265            self.advance();
1266            let enums = self.parse_enumerators()?;
1267            self.expect(&TokenKind::RightBrace)?;
1268            (enums, span.clone())
1269        } else {
1270            self.expect(&TokenKind::LeftParen)?;
1271            let enums = self.parse_enumerators()?;
1272            self.expect(&TokenKind::RightParen)?;
1273            (enums, span.clone())
1274        };
1275        let is_yield = if self.peek_kind() == Some(&TokenKind::Yield) {
1276            self.advance();
1277            true
1278        } else {
1279            false
1280        };
1281        let body = self.parse_expression()?;
1282        Ok(Expr::For {
1283            enumerators: enums,
1284            body: Box::new(body),
1285            is_yield,
1286            span,
1287        })
1288    }
1289
1290    fn parse_enumerators(&mut self) -> Result<Vec<Enumerator>, ParseError> {
1291        let mut enums = Vec::new();
1292        loop {
1293            let span = self.current_span();
1294            if self.peek_kind() == Some(&TokenKind::Val) {
1295                self.advance();
1296                let pattern = self.parse_pattern()?;
1297                self.expect(&TokenKind::Equals)?;
1298                let expr = self.parse_expression()?;
1299                enums.push(Enumerator::Val { pattern, expr, span });
1300            } else if self.peek_kind() == Some(&TokenKind::If) {
1301                self.advance();
1302                let cond = self.parse_expression()?;
1303                enums.push(Enumerator::Filter { cond, span });
1304            } else {
1305                let pattern = self.parse_pattern()?;
1306                if self.peek_kind() == Some(&TokenKind::LeftArrow) {
1307                    self.advance();
1308                    let expr = self.parse_expression()?;
1309                    enums.push(Enumerator::Generator { pattern, expr, span });
1310                } else {
1311                    break;
1312                }
1313            }
1314            let needs_sep = matches!(self.peek_kind(),
1315                Some(TokenKind::Semicolon) | Some(TokenKind::Val) |
1316                Some(TokenKind::If) | Some(TokenKind::Identifier(_)) |
1317                Some(TokenKind::Underscore)
1318            );
1319            if self.peek_kind() == Some(&TokenKind::Semicolon) {
1320                self.advance();
1321            } else if !needs_sep {
1322                break;
1323            }
1324        }
1325        Ok(enums)
1326    }
1327
1328    fn parse_try(&mut self) -> Result<Expr, ParseError> {
1329        let span = self.current_span();
1330        self.advance(); // consume 'try'
1331        let body = self.parse_expression()?;
1332        let catches = if self.peek_kind() == Some(&TokenKind::Catch) {
1333            self.advance();
1334            self.parse_match_cases()?
1335        } else {
1336            Vec::new()
1337        };
1338        let finally_block = if self.peek_kind() == Some(&TokenKind::Finally) {
1339            self.advance();
1340            Some(Box::new(self.parse_expression()?))
1341        } else {
1342            None
1343        };
1344        Ok(Expr::Try {
1345            body: Box::new(body),
1346            catches,
1347            finally_block,
1348            span,
1349        })
1350    }
1351
1352    fn parse_new(&mut self) -> Result<Expr, ParseError> {
1353        let span = self.current_span();
1354        self.advance(); // consume 'new'
1355        let (class_name, _) = self.expect_identifier()?;
1356        let type_args = if self.peek_kind() == Some(&TokenKind::LeftBracket) {
1357            self.advance();
1358            let mut args = Vec::new();
1359            while self.peek_kind() != Some(&TokenKind::RightBracket) {
1360                args.push(self.parse_type()?);
1361                if self.peek_kind() == Some(&TokenKind::Comma) {
1362                    self.advance();
1363                } else {
1364                    break;
1365                }
1366            }
1367            self.expect(&TokenKind::RightBracket)?;
1368            args
1369        } else {
1370            Vec::new()
1371        };
1372        let args = if self.peek_kind() == Some(&TokenKind::LeftParen) {
1373            self.parse_arguments()?
1374        } else {
1375            Vec::new()
1376        };
1377        Ok(Expr::New { class_name, type_args, args, span })
1378    }
1379
1380    fn parse_block(&mut self) -> Result<Expr, ParseError> {
1381        let span = self.current_span();
1382        self.expect(&TokenKind::LeftBrace)?;
1383        let mut stmts = Vec::new();
1384        while self.peek_kind() != Some(&TokenKind::RightBrace) && !self.is_at_end() {
1385            if self.peek_kind() == Some(&TokenKind::Semicolon) {
1386                self.advance();
1387                continue;
1388            }
1389            match self.peek_kind() {
1390                Some(TokenKind::Val) => {
1391                    stmts.push(self.parse_val_decl()?);
1392                }
1393                Some(TokenKind::Var) => {
1394                    stmts.push(self.parse_var_decl()?);
1395                }
1396                Some(TokenKind::Def) => {
1397                    stmts.push(Stmt::DefDecl(self.parse_def_decl()?));
1398                }
1399                Some(TokenKind::Class) | Some(TokenKind::Case) => {
1400                    stmts.push(Stmt::ClassDecl(self.parse_class_decl()?));
1401                }
1402                Some(TokenKind::Trait) => {
1403                    stmts.push(Stmt::TraitDecl(self.parse_trait_decl()?));
1404                }
1405                Some(TokenKind::Object) => {
1406                    stmts.push(Stmt::ObjectDecl(self.parse_object_decl()?));
1407                }
1408                Some(TokenKind::Import) => {
1409                    stmts.push(self.parse_import()?);
1410                }
1411                _ => {
1412                    stmts.push(Stmt::Expr(self.parse_expression()?));
1413                }
1414            }
1415            self.skip_semicolons();
1416        }
1417        self.expect(&TokenKind::RightBrace)?;
1418        Ok(Expr::Block { stmts, span })
1419    }
1420
1421    fn parse_match_cases(&mut self) -> Result<Vec<MatchCase>, ParseError> {
1422        let expect_brace = self.peek_kind() == Some(&TokenKind::LeftBrace);
1423        if expect_brace {
1424            self.advance();
1425        }
1426        let mut cases = Vec::new();
1427        while !self.is_at_end() {
1428            if expect_brace && self.peek_kind() == Some(&TokenKind::RightBrace) {
1429                self.advance();
1430                break;
1431            }
1432            if self.peek_kind() == Some(&TokenKind::Case) {
1433                self.advance();
1434            } else {
1435                break;
1436            }
1437            let pattern = self.parse_pattern()?;
1438            let guard = if self.peek_kind() == Some(&TokenKind::If) {
1439                self.advance();
1440                Some(self.parse_expression()?)
1441            } else {
1442                None
1443            };
1444            self.expect(&TokenKind::Arrow)?;
1445            let body = self.parse_expression()?;
1446            cases.push(MatchCase {
1447                pattern,
1448                guard,
1449                body,
1450                span: Span::zero(),
1451            });
1452            self.skip_semicolons();
1453        }
1454        Ok(cases)
1455    }
1456
1457    fn parse_pattern(&mut self) -> Result<Pattern, ParseError> {
1458        self.parse_pattern_alternative()
1459    }
1460
1461    fn parse_pattern_alternative(&mut self) -> Result<Pattern, ParseError> {
1462        let span = self.current_span();
1463        let mut pat = self.parse_pattern_base()?;
1464        while self.peek_kind() == Some(&TokenKind::Pipe) {
1465            self.advance();
1466            let right = self.parse_pattern_base()?;
1467            pat = Pattern::Alternative {
1468                left: Box::new(pat),
1469                right: Box::new(right),
1470                span,
1471            };
1472        }
1473        Ok(pat)
1474    }
1475
1476    fn parse_pattern_base(&mut self) -> Result<Pattern, ParseError> {
1477        let span = self.current_span();
1478        match self.peek_kind().cloned() {
1479            Some(TokenKind::Underscore) => {
1480                self.advance();
1481                Ok(Pattern::Wildcard(span))
1482            }
1483            Some(TokenKind::IntLiteral(v)) => {
1484                self.advance();
1485                Ok(Pattern::Literal { value: Literal::Int(v), span })
1486            }
1487            Some(TokenKind::LongLiteral(v)) => {
1488                self.advance();
1489                Ok(Pattern::Literal { value: Literal::Long(v), span })
1490            }
1491            Some(TokenKind::DoubleLiteral(v)) => {
1492                self.advance();
1493                Ok(Pattern::Literal { value: Literal::Double(v), span })
1494            }
1495            Some(TokenKind::FloatLiteral(v)) => {
1496                self.advance();
1497                Ok(Pattern::Literal { value: Literal::Float(v), span })
1498            }
1499            Some(TokenKind::BoolLiteral(b)) => {
1500                self.advance();
1501                Ok(Pattern::Literal { value: Literal::Bool(b), span })
1502            }
1503            Some(TokenKind::StringLiteral(s)) => {
1504                self.advance();
1505                Ok(Pattern::Literal { value: Literal::String(s), span })
1506            }
1507            Some(TokenKind::CharLiteral(c)) => {
1508                self.advance();
1509                Ok(Pattern::Literal { value: Literal::Char(c), span })
1510            }
1511            Some(TokenKind::NullLiteral) => {
1512                self.advance();
1513                Ok(Pattern::Literal { value: Literal::Null, span })
1514            }
1515            Some(TokenKind::Minus) => {
1516                self.advance();
1517                match self.peek_kind().cloned() {
1518                    Some(TokenKind::IntLiteral(v)) => {
1519                        self.advance();
1520                        Ok(Pattern::Literal { value: Literal::Int(-v), span })
1521                    }
1522                    Some(TokenKind::DoubleLiteral(v)) => {
1523                        self.advance();
1524                        Ok(Pattern::Literal { value: Literal::Double(-v), span })
1525                    }
1526                    _ => Err(ParseError::new("expected number after '-'", self.current_span())),
1527                }
1528            }
1529            Some(TokenKind::Identifier(name)) => {
1530                self.advance();
1531                let name_clone = name.clone();
1532                if self.peek_kind() == Some(&TokenKind::LeftParen) {
1533                    self.advance();
1534                    let mut args = Vec::new();
1535                    while self.peek_kind() != Some(&TokenKind::RightParen) {
1536                        if self.peek_kind() == Some(&TokenKind::Underscore) && self.peek_at(1).kind == TokenKind::Star {
1537                            self.advance();
1538                            self.advance();
1539                            args.push(Pattern::SequenceWildcard(self.current_span()));
1540                        } else {
1541                            args.push(self.parse_pattern()?);
1542                        }
1543                        if self.peek_kind() == Some(&TokenKind::Comma) {
1544                            self.advance();
1545                        } else {
1546                            break;
1547                        }
1548                    }
1549                    self.expect(&TokenKind::RightParen)?;
1550                    Ok(Pattern::Constructor { name, args, span })
1551                } else if self.peek_kind() == Some(&TokenKind::Colon) {
1552                    self.advance();
1553                    let type_ann = self.parse_type()?;
1554                    Ok(Pattern::Typed {
1555                        pattern: Box::new(Pattern::Variable { name: name_clone, span: span.clone() }),
1556                        type_ann,
1557                        span,
1558                    })
1559                } else {
1560                    Ok(Pattern::Variable { name, span })
1561                }
1562            }
1563            Some(TokenKind::LeftParen) => {
1564                self.advance();
1565                if self.peek_kind() == Some(&TokenKind::RightParen) {
1566                    self.advance();
1567                    return Ok(Pattern::Tuple { elements: vec![], span });
1568                }
1569                let first = self.parse_pattern()?;
1570                if self.peek_kind() == Some(&TokenKind::Comma) {
1571                    let mut elements = vec![first];
1572                    while self.peek_kind() == Some(&TokenKind::Comma) {
1573                        self.advance();
1574                        elements.push(self.parse_pattern()?);
1575                    }
1576                    self.expect(&TokenKind::RightParen)?;
1577                    Ok(Pattern::Tuple { elements, span })
1578                } else {
1579                    self.expect(&TokenKind::RightParen)?;
1580                    Ok(first)
1581                }
1582            }
1583            _ => Err(ParseError::new(
1584                format!("unexpected token in pattern: {}", self.peek().kind),
1585                self.current_span(),
1586            )),
1587        }
1588    }
1589}
1590
1591#[cfg(test)]
1592mod tests {
1593    use super::*;
1594    use crate::lexer::Lexer;
1595
1596    fn parse_stmts(source: &str) -> Vec<Stmt> {
1597        let tokens = Lexer::tokenize(source).unwrap();
1598        Parser::parse(tokens).unwrap()
1599    }
1600
1601    fn parse_one_expr(source: &str) -> Expr {
1602        let tokens = Lexer::tokenize(source).unwrap();
1603        Parser::parse_expr(tokens).unwrap()
1604    }
1605
1606    #[test]
1607    fn test_literal_int() {
1608        if let Expr::Literal { value: Literal::Int(42), .. } = parse_one_expr("42") {
1609        } else {
1610            panic!("expected int literal 42");
1611        }
1612    }
1613
1614    #[test]
1615    fn test_binary_add() {
1616        if let Expr::Binary { op: BinOp::Add, .. } = parse_one_expr("1 + 2") {
1617        } else {
1618            panic!("expected binary add");
1619        }
1620    }
1621
1622    #[test]
1623    fn test_precedence() {
1624        if let Expr::Binary { op: BinOp::Add, left: _, right, .. } = parse_one_expr("1 + 2 * 3") {
1625            if let Expr::Binary { op: BinOp::Mul, .. } = *right {
1626            } else {
1627                panic!("expected mul on right");
1628            }
1629        } else {
1630            panic!("expected binary add");
1631        }
1632    }
1633
1634    #[test]
1635    fn test_if_else() {
1636        match parse_one_expr("if (true) 1 else 2") {
1637            Expr::If { .. } => {}
1638            _ => panic!("expected if expression"),
1639        }
1640    }
1641
1642    #[test]
1643    fn test_block() {
1644        match parse_one_expr("{ val x = 1; x }") {
1645            Expr::Block { stmts, .. } => assert_eq!(stmts.len(), 2),
1646            _ => panic!("expected block"),
1647        }
1648    }
1649
1650    #[test]
1651    fn test_lambda() {
1652        match parse_one_expr("(x) => x + 1") {
1653            Expr::Lambda { params, .. } => assert_eq!(params.len(), 1),
1654            _ => panic!("expected lambda"),
1655        }
1656    }
1657
1658    #[test]
1659    fn test_val_decl() {
1660        let stmts = parse_stmts("val x = 42");
1661        match &stmts[0] {
1662            Stmt::ValDecl { pattern, value, .. } => {
1663                if let Pattern::Variable { name, .. } = pattern {
1664                    assert_eq!(name, "x");
1665                }
1666                if let Expr::Literal { value: Literal::Int(42), .. } = value {
1667                } else {
1668                    panic!("expected int 42");
1669                }
1670            }
1671            _ => panic!("expected val decl"),
1672        }
1673    }
1674
1675    #[test]
1676    fn test_def_decl() {
1677        let stmts = parse_stmts("def add(a: Int, b: Int): Int = a + b");
1678        match &stmts[0] {
1679            Stmt::DefDecl(DefDecl { name, params, return_type, .. }) => {
1680                assert_eq!(name, "add");
1681                assert_eq!(params.len(), 2);
1682                assert!(return_type.is_some());
1683            }
1684            _ => panic!("expected def decl"),
1685        }
1686    }
1687
1688    #[test]
1689    fn test_class_decl() {
1690        let stmts = parse_stmts("class Point(val x: Int, val y: Int)");
1691        match &stmts[0] {
1692            Stmt::ClassDecl(ClassDecl { name, ctor_params, .. }) => {
1693                assert_eq!(name, "Point");
1694                assert_eq!(ctor_params.len(), 2);
1695            }
1696            _ => panic!("expected class decl"),
1697        }
1698    }
1699
1700    #[test]
1701    fn test_case_class() {
1702        let stmts = parse_stmts("case class Foo(x: Int, y: String)");
1703        match &stmts[0] {
1704            Stmt::ClassDecl(ClassDecl { name, is_case, .. }) => {
1705                assert_eq!(name, "Foo");
1706                assert!(is_case);
1707            }
1708            _ => panic!("expected case class"),
1709        }
1710    }
1711
1712    #[test]
1713    fn test_match_expr() {
1714        match parse_one_expr("x match { case 0 => 1 case _ => 2 }") {
1715            Expr::Match { cases, .. } => assert_eq!(cases.len(), 2),
1716            _ => panic!("expected match"),
1717        }
1718    }
1719
1720    #[test]
1721    fn test_method_call() {
1722        match parse_one_expr("obj.method(1, 2)") {
1723            Expr::MethodCall { method, args, .. } => {
1724                assert_eq!(method, "method");
1725                assert_eq!(args.len(), 2);
1726            }
1727            _ => panic!("expected method call"),
1728        }
1729    }
1730
1731    #[test]
1732    fn test_tuple() {
1733        match parse_one_expr("(1, 2, 3)") {
1734            Expr::Tuple { elements, .. } => assert_eq!(elements.len(), 3),
1735            _ => panic!("expected tuple"),
1736        }
1737    }
1738
1739    #[test]
1740    fn test_new_expr() {
1741        match parse_one_expr("new Point(1, 2)") {
1742            Expr::New { class_name, args, .. } => {
1743                assert_eq!(class_name, "Point");
1744                assert_eq!(args.len(), 2);
1745            }
1746            _ => panic!("expected new"),
1747        }
1748    }
1749
1750    #[test]
1751    fn test_for_comprehension() {
1752        match parse_one_expr("for (x <- List(1, 2)) yield x") {
1753            Expr::For { is_yield, enumerators, .. } => {
1754                assert!(is_yield);
1755                assert_eq!(enumerators.len(), 1);
1756            }
1757            _ => panic!("expected for"),
1758        }
1759    }
1760
1761    #[test]
1762    fn test_trait_decl() {
1763        let stmts = parse_stmts("trait Greeter { def greet(name: String): String }");
1764        match &stmts[0] {
1765            Stmt::TraitDecl(TraitDecl { name, body, .. }) => {
1766                assert_eq!(name, "Greeter");
1767                assert_eq!(body.len(), 1);
1768            }
1769            _ => panic!("expected trait"),
1770        }
1771    }
1772
1773    #[test]
1774    fn test_object_decl() {
1775        let stmts = parse_stmts("object Math { def square(x: Int): Int = x * x }");
1776        match &stmts[0] {
1777            Stmt::ObjectDecl(ObjectDecl { name, body, .. }) => {
1778                assert_eq!(name, "Math");
1779                assert_eq!(body.len(), 1);
1780            }
1781            _ => panic!("expected object"),
1782        }
1783    }
1784
1785    #[test]
1786    fn test_type_param() {
1787        let stmts = parse_stmts("class Box[T](val content: T)");
1788        match &stmts[0] {
1789            Stmt::ClassDecl(ClassDecl { name, type_params, .. }) => {
1790                assert_eq!(name, "Box");
1791                assert_eq!(type_params.len(), 1);
1792            }
1793            _ => panic!("expected class"),
1794        }
1795    }
1796}
scala/parser.rs

scala/
parser.rs
